#!/usr/bin/env python3
"""
Price Feed - Récupère les données de prix en temps réel depuis Binance
"""

import requests
import pandas as pd
from datetime import datetime
import logging
from typing import Optional

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class BinancePriceFeed:
    """Récupère les données OHLCV depuis Binance"""

    def __init__(self):
        self.base_url = "https://api.binance.com/api/v3"

    def get_klines(self, symbol: str = "BTCUSDT", interval: str = "1m", limit: int = 100) -> Optional[pd.DataFrame]:
        """
        Récupère les klines (chandelier) depuis Binance

        Args:
            symbol: Paire de trading (ex: BTCUSDT)
            interval: Timeframe (1m, 5m, 15m, 1h, etc.)
            limit: Nombre de bougies (max 1000)

        Returns:
            DataFrame avec colonnes: timestamp, open, high, low, close, volume
        """
        try:
            url = f"{self.base_url}/klines"
            params = {
                'symbol': symbol,
                'interval': interval,
                'limit': limit
            }

            response = requests.get(url, params=params, timeout=10)
            response.raise_for_status()

            data = response.json()

            # Convertir en DataFrame
            df = pd.DataFrame(data, columns=[
                'timestamp', 'open', 'high', 'low', 'close', 'volume',
                'close_time', 'quote_volume', 'trades', 'taker_buy_base',
                'taker_buy_quote', 'ignore'
            ])

            # Garder seulement les colonnes importantes
            df = df[['timestamp', 'open', 'high', 'low', 'close', 'volume']]

            # Convertir les types
            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            df['open'] = df['open'].astype(float)
            df['high'] = df['high'].astype(float)
            df['low'] = df['low'].astype(float)
            df['close'] = df['close'].astype(float)
            df['volume'] = df['volume'].astype(float)

            return df

        except Exception as e:
            logger.error(f"❌ Erreur récupération klines: {e}")
            return None

    def get_current_price(self, symbol: str = "BTCUSDT") -> Optional[float]:
        """Récupère le prix actuel"""
        try:
            url = f"{self.base_url}/ticker/price"
            params = {'symbol': symbol}

            response = requests.get(url, params=params, timeout=5)
            response.raise_for_status()

            data = response.json()
            return float(data['price'])

        except Exception as e:
            logger.error(f"❌ Erreur récupération prix: {e}")
            return None


if __name__ == '__main__':
    logger.info("="*80)
    logger.info("🧪 TEST PRICE FEED")
    logger.info("="*80)

    feed = BinancePriceFeed()

    # Test prix actuel
    logger.info("\n📊 Prix actuel BTC:")
    price = feed.get_current_price("BTCUSDT")
    if price:
        logger.info(f"   BTC: ${price:,.2f}")

    # Test klines 1m
    logger.info("\n📊 Klines 1m (dernières 10):")
    df_1m = feed.get_klines("BTCUSDT", "1m", 10)
    if df_1m is not None:
        logger.info(f"   Récupéré: {len(df_1m)} bougies")
        logger.info(f"\n{df_1m[['timestamp', 'close', 'volume']].tail()}")

    # Test klines 5m
    logger.info("\n📊 Klines 5m (dernières 20):")
    df_5m = feed.get_klines("BTCUSDT", "5m", 20)
    if df_5m is not None:
        logger.info(f"   Récupéré: {len(df_5m)} bougies")
        logger.info(f"   Prix: ${df_5m['close'].iloc[-1]:,.2f}")
        logger.info(f"   Volatilité 5 bougies: {((df_5m['high'].tail(5).max() - df_5m['low'].tail(5).min()) / df_5m['close'].iloc[-1] * 100):.2f}%")

    logger.info("\n" + "="*80)
    logger.info("✅ Test terminé")
    logger.info("="*80)