#!/usr/bin/env python3
"""
Test rapide pour vérifier les leverages sur quelques tokens
"""

import sys
import logging
from hyperliquid_leverages_cache import get_max_leverage

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

def test_leverage_calculation():
    """Test rapide des calculs de leverage"""

    print("=" * 60)
    print("TEST RAPIDE DES LEVERAGES")
    print("=" * 60)

    # Import des fonctions nécessaires
    from simple_trading_system.pragmatic_signals import PragmaticSignalGenerator
    from hyperliquid_client import HyperliquidClient
    from trading_config import LEVERAGE_SAFETY_FACTOR, MAX_LEVERAGE

    # Test sur quelques tokens principaux
    test_tokens = ['BTC', 'ETH', 'SOL', 'DOGE', 'AAVE', 'UNI']

    print(f"Configuration actuelle:")
    print(f"- Leverage max global: {MAX_LEVERAGE}x")
    print(f"- Facteur de sécurité: {LEVERAGE_SAFETY_FACTOR} ({int(LEVERAGE_SAFETY_FACTOR*100)}%)")
    print()

    print("Leverages max disponibles:")
    print("Token | Max HL | Max Config | Description")
    print("-" * 45)

    for token in test_tokens:
        max_hl = get_max_leverage(token)
        max_config = min(max_hl, MAX_LEVERAGE)
        safe_max = int(max_config * LEVERAGE_SAFETY_FACTOR)

        print(f"{token:5} | {max_hl:6}x | {safe_max:8}x | Théorique max utilisé")

    print("\n" + "=" * 60)
    print("TEST DE CALCULS AVEC DIFFÉRENTS SCENARIOS")
    print("=" * 60)

    # Simuler différents cas
    scenarios = [
        {'symbol': 'BTC', 'strength': 0.9, 'volatility': 3.0, 'desc': 'Signal très fort, volatilité normale'},
        {'symbol': 'BTC', 'strength': 0.75, 'volatility': 2.0, 'desc': 'Signal fort, volatilité faible'},
        {'symbol': 'ETH', 'strength': 0.85, 'volatility': 5.0, 'desc': 'Signal très fort, volatilité élevée'},
        {'symbol': 'SOL', 'strength': 0.7, 'volatility': 7.0, 'desc': 'Signal moyen, volatilité très élevée'},
        {'symbol': 'DOGE', 'strength': 0.6, 'volatility': 8.0, 'desc': 'Signal faible, volatilité extrême'},
    ]

    # Fonction de calcul intelligente (copie simplifiée)
    def calculate_smart_leverage_test(strength: float, volatility: float, symbol: str) -> int:
        max_leverage_for_symbol = get_max_leverage(symbol)
        safe_max = int(min(max_leverage_for_symbol, MAX_LEVERAGE) * LEVERAGE_SAFETY_FACTOR)

        # Calcul du leverage basé sur la force du signal
        if strength >= 0.85:
            base_leverage = int(safe_max * 1.0)   # 100% du max sécurisé
        elif strength >= 0.75:
            base_leverage = int(safe_max * 0.9)   # 90% du max sécurisé
        elif strength >= 0.65:
            base_leverage = int(safe_max * 0.75)  # 75% du max sécurisé
        elif strength >= 0.55:
            base_leverage = int(safe_max * 0.6)   # 60% du max sécurisé
        else:
            base_leverage = int(safe_max * 0.5)   # 50% du max sécurisé

        # Ajuster selon la volatilité
        if volatility > 8:  # Très haute volatilité
            leverage = max(5, int(base_leverage * 0.65))
        elif volatility > 5:  # Haute volatilité
            leverage = max(8, int(base_leverage * 0.85))
        elif volatility < 2:  # Faible volatilité
            leverage = min(max_leverage_for_symbol, int(base_leverage * 1.3))
        else:  # Volatilité normale
            leverage = base_leverage

        return max(2, min(leverage, max_leverage_for_symbol))

    print("Calculs intelligents:")
    print("Token | Force | Vol | Max | Calc | % Max | Description")
    print("-" * 65)

    for scenario in scenarios:
        symbol = scenario['symbol']
        strength = scenario['strength']
        volatility = scenario['volatility']
        desc = scenario['desc']

        max_possible = get_max_leverage(symbol)
        calculated = calculate_smart_leverage_test(strength, volatility, symbol)
        percentage = (calculated / max_possible) * 100

        print(f"{symbol:5} | {strength:5.2f} | {volatility:3.0f} | {max_possible:3}x | {calculated:4}x | {percentage:5.1f}% | {desc}")

    print("\n" + "=" * 60)
    print("ANALYSE DES POSITIONS ACTUELLES")
    print("=" * 60)

    # Analyser les logs récents pour voir les leverages utilisés
    import subprocess
    try:
        result = subprocess.run(['journalctl', '-u', 'crypto-trader.service', '--no-pager', '-n', '20'],
                              capture_output=True, text=True)
        logs = result.stdout

        # Extraire les informations de leverage des logs
        lines = logs.split('\n')
        positions_found = []

        for line in lines:
            if 'Leverage:' in line and ('LONG' in line or 'SHORT' in line):
                # Extraire les infos avec regex ou parsing simple
                try:
                    parts = line.split('|')
                    if len(parts) >= 4:
                        symbol_part = parts[0].split()[-1].strip()
                        leverage_part = [p for p in parts if 'Leverage:' in p][0]
                        leverage_value = leverage_part.split('Leverage:')[1].strip().replace('x', '')
                        positions_found.append((symbol_part, leverage_value))
                except:
                    continue

        if positions_found:
            print("Positions actuelles détectées dans les logs:")
            print("Symbol | Leverage utilisé | Max disponible | % utilisé")
            print("-" * 50)

            for symbol, leverage_str in positions_found[-5:]:  # Dernières 5
                try:
                    leverage_used = int(leverage_str.strip())
                    max_available = get_max_leverage(symbol)
                    percentage = (leverage_used / max_available) * 100
                    print(f"{symbol:6} | {leverage_used:12}x | {max_available:13}x | {percentage:7.1f}%")
                except:
                    continue
        else:
            print("Aucune position détectée dans les logs récents")

    except Exception as e:
        print(f"Erreur lors de l'analyse des logs: {e}")

    print("\n" + "=" * 60)
    print("✅ TEST RAPIDE TERMINÉ")
    print("=" * 60)

if __name__ == "__main__":
    test_leverage_calculation()