#!/usr/bin/env python3
"""
Script de test pour vérifier la récupération des leverages depuis Hyperliquid
"""

import json
import logging
from hyperliquid_client import HyperliquidClient

# Configuration du logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

def test_leverage_retrieval():
    """Test la récupération des leverages depuis Hyperliquid"""

    logger.info("=" * 60)
    logger.info("TEST RÉCUPÉRATION LEVERAGES HYPERLIQUID")
    logger.info("=" * 60)

    try:
        # Initialiser le client
        logger.info("\n1. Initialisation du client Hyperliquid...")
        client = HyperliquidClient()
        logger.info("✅ Client initialisé")

        # Test 1: Récupération des meta info
        logger.info("\n2. Récupération des meta informations...")
        meta_info = client.get_meta_info()

        if meta_info:
            logger.info(f"✅ Meta info récupérées")
            logger.info(f"   Nombre de tokens: {len(meta_info.get('universe', []))}")

            # Afficher quelques exemples
            logger.info("\n3. Exemples de leverages maximum par token:")
            universe = meta_info.get('universe', [])

            # Tokens d'intérêt
            tokens_of_interest = ['BTC', 'ETH', 'SOL', 'BNB', 'ARB', 'DOGE', 'INJ', 'LTC', 'OP', 'COMP']

            for token_info in universe:
                name = token_info.get('name', '')
                if name in tokens_of_interest:
                    max_leverage = token_info.get('maxLeverage', 'N/A')
                    logger.info(f"   {name:6} -> Max Leverage: {max_leverage}x")
        else:
            logger.error("❌ Impossible de récupérer les meta info")

        # Test 2: Utilisation de get_available_leverages
        logger.info("\n4. Test de get_available_leverages()...")
        leverages = client.get_available_leverages()

        if leverages:
            logger.info(f"✅ Leverages récupérés pour {len(leverages)} tokens")
            logger.info("\n5. Leverages disponibles pour les positions actuelles:")

            # Afficher les leverages pour les tokens d'intérêt
            for token in tokens_of_interest:
                if token in leverages:
                    logger.info(f"   {token:6} -> {leverages[token]:2}x (max disponible)")
        else:
            logger.error("❌ Impossible de récupérer les leverages")

        # Test 3: Vérifier les positions actuelles et leurs leverages
        logger.info("\n6. Vérification des leverages des positions actuelles...")
        positions = client.get_positions()

        if positions:
            logger.info(f"✅ {len(positions)} positions actives trouvées")
            logger.info("\n7. Leverages utilisés vs maximum disponible:")

            for pos in positions:
                symbol = pos.get('symbol', '').replace('-PERP', '')
                size = pos.get('size', 0)
                side = pos.get('side', '')

                # Leverage actuel
                leverage_data = pos.get('leverage', {})
                if isinstance(leverage_data, dict):
                    current_leverage = leverage_data.get('value', 'N/A')
                else:
                    current_leverage = leverage_data if leverage_data else 'N/A'

                # Leverage maximum disponible
                max_available = leverages.get(symbol, 'N/A')

                logger.info(f"   {symbol:6} {side:5} -> Utilisé: {current_leverage}x / Max: {max_available}x")

                # Debug: afficher la structure complète du leverage
                if pos.get('raw_position_data'):
                    raw_data = pos['raw_position_data']
                    logger.debug(f"   Debug raw data pour {symbol}: leverage={raw_data.get('leverage', 'non trouvé')}")
        else:
            logger.warning("⚠️  Aucune position active trouvée")

        # Test 4: Analyser la structure des données
        logger.info("\n8. Analyse de la structure des données de leverage...")
        if positions and len(positions) > 0:
            first_pos = positions[0]
            logger.info(f"Structure d'une position (exemple {first_pos.get('symbol', 'N/A')}):")

            # Afficher les clés disponibles
            logger.info(f"   Clés disponibles: {list(first_pos.keys())}")

            # Analyser le champ leverage
            if 'leverage' in first_pos:
                leverage_field = first_pos['leverage']
                logger.info(f"   Type du champ leverage: {type(leverage_field)}")
                logger.info(f"   Contenu leverage: {leverage_field}")

            # Analyser les données brutes si disponibles
            if 'raw_position_data' in first_pos:
                raw = first_pos['raw_position_data']
                if 'leverage' in raw:
                    logger.info(f"   Leverage dans raw_position_data: {raw['leverage']}")

        logger.info("\n" + "=" * 60)
        logger.info("TEST TERMINÉ")
        logger.info("=" * 60)

    except Exception as e:
        logger.error(f"❌ Erreur lors du test: {e}", exc_info=True)

if __name__ == "__main__":
    test_leverage_retrieval()