import requests
import time

class CryptoPriceClient:
    """Simple client for fetching crypto price data via CoinGecko API."""
    
    BASE_URL = "https://api.coingecko.com/api/v3"
    
    def __init__(self, api_key=None):
        self.session = requests.Session()
        if api_key:
            self.session.headers.update({"x-cg-demo-api-key": api_key})
    
    def get_price(self, coin_ids, vs_currencies="usd"):
        """Fetch current prices for one or more coins."""
        endpoint = f"{self.BASE_URL}/simple/price"
        params = {
            "ids": coin_ids if isinstance(coin_ids, str) else ",".join(coin_ids),
            "vs_currencies": vs_currencies,
            "include_24hr_change": "true",
            "include_market_cap": "true"
        }
        try:
            response = self.session.get(endpoint, params=params, timeout=10)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"API request failed: {e}")
            return None
    
    def get_ohlcv(self, coin_id, days=30, vs_currency="usd"):
        """Fetch OHLCV candle data for charting."""
        endpoint = f"{self.BASE_URL}/coins/{coin_id}/ohlc"
        params = {"vs_currency": vs_currency, "days": days}
        try:
            response = self.session.get(endpoint, params=params, timeout=10)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"OHLCV request failed: {e}")
            return None


# Usage
client = CryptoPriceClient()

# Fetch current prices
prices = client.get_price(["bitcoin", "ethereum", "solana"])
if prices:
    for coin, data in prices.items():
        print(f"{coin}: ${data['usd']:,.2f} ({data['usd_24h_change']:+.2f}%)")

# Fetch 30-day OHLCV for chart data
ohlcv = client.get_ohlcv("bitcoin", days=30)
if ohlcv:
    print(f"\nBitcoin 30-day candles: {len(ohlcv)} data points")
    # Each candle: [timestamp, open, high, low, close]
    latest = ohlcv[-1]
    print(f"Latest candle — O: ${latest[1]:,.0f} H: ${latest[2]:,.0f} L: ${latest[3]:,.0f} C: ${latest[4]:,.0f}")

import requests
import pandas as pd
from datetime import datetime

def fetch_price_history(coin_id, days="max", vs_currency="usd"):
    """Fetch full price history from CoinGecko's crypto historical price data API."""
    url = f"https://api.coingecko.com/api/v3/coins/{coin_id}/market_chart"
    params = {"vs_currency": vs_currency, "days": days, "interval": "daily"}
    
    response = requests.get(url, params=params, timeout=30)
    response.raise_for_status()
    data = response.json()
    
    # Parse into a clean DataFrame
    df = pd.DataFrame(data["prices"], columns=["timestamp", "price"])
    df["date"] = pd.to_datetime(df["timestamp"], unit="ms")
    df.set_index("date", inplace=True)
    df.drop(columns=["timestamp"], inplace=True)
    
    # Add volume data
    volumes = pd.DataFrame(data["total_volumes"], columns=["timestamp", "volume"])
    volumes["date"] = pd.to_datetime(volumes["timestamp"], unit="ms")
    volumes.set_index("date", inplace=True)
    df["volume"] = volumes["volume"]
    
    return df


def fetch_coindesk_bpi():
    """Fetch Bitcoin Price Index from CoinDesk API."""
    url = "https://api.coindesk.com/v1/bpi/historical/close.json"
    params = {"start": "2024-01-01", "end": "2024-12-31"}
    
    response = requests.get(url, params=params, timeout=10)
    response.raise_for_status()
    data = response.json()
    
    df = pd.DataFrame(
        list(data["bpi"].items()),
        columns=["date", "price"]
    )
    df["date"] = pd.to_datetime(df["date"])
    df.set_index("date", inplace=True)
    return df


# Pull full Bitcoin history
btc_history = fetch_price_history("bitcoin")
print(f"Bitcoin price history: {len(btc_history)} daily data points")
print(f"Date range: {btc_history.index[0].date()} to {btc_history.index[-1].date()}")
print(f"All-time high: ${btc_history['price'].max():,.0f}")
print(f"Current: ${btc_history['price'].iloc[-1]:,.0f}")

# Quick backtest metric: simple moving average crossover signals
btc_history["sma_50"] = btc_history["price"].rolling(50).mean()
btc_history["sma_200"] = btc_history["price"].rolling(200).mean()
btc_history["signal"] = (btc_history["sma_50"] > btc_history["sma_200"]).astype(int)
golden_crosses = btc_history["signal"].diff().eq(1).sum()
print(f"\nGolden crosses (50/200 SMA): {golden_crosses}")

const WebSocket = require('ws');

class CoinCapStream {
  constructor(assets = ['bitcoin', 'ethereum']) {
    this.assets = assets;
    this.ws = null;
    this.prices = {};
    this.callbacks = [];
  }

  connect() {
    const assetQuery = this.assets.join(',');
    this.ws = new WebSocket(`wss://ws.coincap.io/prices?assets=${assetQuery}`);

    this.ws.on('open', () => {
      console.log(`Connected — streaming ${this.assets.length} assets`);
    });

    this.ws.on('message', (data) => {
      const prices = JSON.parse(data);
      const timestamp = Date.now();

      for (const [asset, price] of Object.entries(prices)) {
        const prev = this.prices[asset];
        const current = parseFloat(price);
        const change = prev ? ((current - prev) / prev * 100).toFixed(4) : '0.0000';
        
        this.prices[asset] = current;
        
        // Notify callbacks
        this.callbacks.forEach(cb => cb({
          asset,
          price: current,
          change: parseFloat(change),
          timestamp
        }));
      }
    });

    this.ws.on('error', (err) => {
      console.error('WebSocket error:', err.message);
      setTimeout(() => this.connect(), 5000); // Reconnect after 5s
    });

    this.ws.on('close', () => {
      console.log('Connection closed, reconnecting...');
      setTimeout(() => this.connect(), 3000);
    });
  }

  onPrice(callback) {
    this.callbacks.push(callback);
  }

  disconnect() {
    if (this.ws) this.ws.close();
  }
}

// Usage: stream BTC and ETH prices
const stream = new CoinCapStream(['bitcoin', 'ethereum', 'solana']);

stream.onPrice(({ asset, price, change, timestamp }) => {
  const time = new Date(timestamp).toISOString().substr(11, 8);
  const arrow = change > 0 ? '↑' : change < 0 ? '↓' : '→';
  console.log(`[${time}] ${asset}: $${price.toLocaleString()} ${arrow} ${change}%`);
  
  // Example: trigger alert on significant move
  if (Math.abs(change) > 0.5) {
    console.log(`  ⚠ Large move detected on ${asset}: ${change}%`);
  }
});

stream.connect();

import requests
import time
from dataclasses import dataclass

@dataclass
class PriceAlert:
    coin: str
    condition: str  # 'above' or 'below'
    target: float
    triggered: bool = False

class PriceMonitor:
    """Monitor crypto prices and trigger alerts using REST polling."""
    
    API_URL = "https://api.coingecko.com/api/v3/simple/price"
    
    def __init__(self, coins):
        self.coins = coins
        self.alerts = []
    
    def add_alert(self, coin, condition, target):
        self.alerts.append(PriceAlert(coin, condition, target))
        print(f"Alert set: {coin} {condition} ${target:,.2f}")
    
    def fetch_prices(self):
        params = {
            "ids": ",".join(self.coins),
            "vs_currencies": "usd"
        }
        try:
            resp = requests.get(self.API_URL, params=params, timeout=10)
            resp.raise_for_status()
            return {k: v["usd"] for k, v in resp.json().items()}
        except requests.exceptions.RequestException as e:
            print(f"Fetch error: {e}")
            return None
    
    def check_alerts(self, prices):
        triggered = []
        for alert in self.alerts:
            if alert.triggered or alert.coin not in prices:
                continue
            price = prices[alert.coin]
            hit = (
                (alert.condition == "above" and price >= alert.target) or
                (alert.condition == "below" and price <= alert.target)
            )
            if hit:
                alert.triggered = True
                triggered.append((alert, price))
        return triggered
    
    def run(self, interval=30):
        print(f"Monitoring {len(self.coins)} coins, {len(self.alerts)} alerts...")
        while True:
            prices = self.fetch_prices()
            if prices:
                for coin, price in prices.items():
                    print(f"  {coin}: ${price:,.2f}")
                
                for alert, price in self.check_alerts(prices):
                    print(f"  🚨 ALERT: {alert.coin} is {alert.condition} "
                          f"${alert.target:,.2f} (current: ${price:,.2f})")
            
            time.sleep(interval)


# Setup and run
monitor = PriceMonitor(["bitcoin", "ethereum", "solana"])
monitor.add_alert("bitcoin", "above", 110000)
monitor.add_alert("bitcoin", "below", 90000)
monitor.add_alert("ethereum", "above", 5000)
monitor.run(interval=30)