#!/usr/bin/env python3
"""
Dashboard de comparaison en temps réel
STATIQUE vs DYNAMIQUE (ATR)
"""
import json
import time
import os
from pathlib import Path
from datetime import datetime


def clear_screen():
    """Clear terminal"""
    os.system('clear' if os.name == 'posix' else 'cls')


def format_duration(seconds):
    """Format duration nicely"""
    if seconds < 60:
        return f"{int(seconds)}s"
    elif seconds < 3600:
        return f"{int(seconds/60)}m {int(seconds%60)}s"
    else:
        h = int(seconds/3600)
        m = int((seconds%3600)/60)
        return f"{h}h {m}m"


def load_results(filename):
    """Charge résultats"""
    if not Path(filename).exists():
        return []
    with open(filename) as f:
        return json.load(f)


def display_optimizer_stats(results, name, color_code):
    """Affiche stats d'un optimizer"""
    if not results:
        print(f"{color_code}⏳ {name}: En attente des premiers résultats...\033[0m")
        return None

    profitable = [r for r in results if r['results']['total_pnl_pct'] > 0
                  and r['results']['profit_factor'] > 1.0]

    print(f"{color_code}{'='*80}\033[0m")
    print(f"{color_code}📊 {name}\033[0m")
    print(f"{color_code}{'='*80}\033[0m")
    print(f"Tests: {len(results)} | Profitables: {len(profitable)} ({len(profitable)/len(results)*100:.1f}%)")

    if profitable:
        # Trier par PnL
        profitable.sort(key=lambda x: x['results']['total_pnl_pct'], reverse=True)

        best = profitable[0]
        print(f"\n🏆 MEILLEUR:")
        print(f"   PnL: {best['results']['total_pnl_pct']:>+8.2f}%")
        print(f"   Profit Factor: {best['results']['profit_factor']:>8.2f}")
        print(f"   Trades: {best['results']['total_trades']:>8}")
        print(f"   Trailing: {int(best['params']['trailing_pct']*100):>8}%")
        print(f"   Leverage: {best['params']['leverage']:>8}x")

        # Moyennes
        avg_pnl = sum(r['results']['total_pnl_pct'] for r in profitable) / len(profitable)
        avg_pf = sum(r['results']['profit_factor'] for r in profitable) / len(profitable)

        print(f"\n📈 MOYENNES:")
        print(f"   PnL moyen: {avg_pnl:>+8.2f}%")
        print(f"   PF moyen: {avg_pf:>8.2f}")

        # Top 3
        print(f"\n🔝 TOP 3:")
        for i, r in enumerate(profitable[:3], 1):
            res = r['results']
            p = r['params']
            print(f"   {i}. PnL: {res['total_pnl_pct']:>+7.2f}% | "
                  f"PF: {res['profit_factor']:>5.2f} | "
                  f"Trades: {res['total_trades']:>3} | "
                  f"Trail: {int(p['trailing_pct']*100):>2}%")

        # Dernière màj
        latest = max(results, key=lambda x: x['timestamp'])
        latest_time = datetime.fromisoformat(latest['timestamp'])
        time_ago = (datetime.now() - latest_time).total_seconds()
        print(f"\n⏰ Dernier test: il y a {format_duration(time_ago)}")

        return {
            'total_tests': len(results),
            'profitable_count': len(profitable),
            'profitable_pct': len(profitable)/len(results)*100,
            'best_pnl': best['results']['total_pnl_pct'],
            'avg_pnl': avg_pnl,
            'avg_pf': avg_pf,
        }
    else:
        print("\n⚠️  Aucune config profitable encore")
        return None


def display_comparison(static_stats, dynamic_stats):
    """Affiche comparaison directe"""
    if not static_stats or not dynamic_stats:
        return

    print(f"\n{'='*80}")
    print("⚔️  HEAD TO HEAD COMPARISON")
    print(f"{'='*80}")

    # Tests effectués
    print(f"\n📊 Volume:")
    print(f"   Statique: {static_stats['total_tests']:>3} tests")
    print(f"   Dynamic:  {dynamic_stats['total_tests']:>3} tests")

    # Taux de réussite
    print(f"\n💎 Taux de réussite:")
    print(f"   Statique: {static_stats['profitable_pct']:>5.1f}%")
    print(f"   Dynamic:  {dynamic_stats['profitable_pct']:>5.1f}%")
    diff = dynamic_stats['profitable_pct'] - static_stats['profitable_pct']
    winner = "✅ DYNAMIC" if diff > 0 else "✅ STATIQUE" if diff < 0 else "🤝 ÉGALITÉ"
    print(f"   → {winner} ({diff:+.1f}%)")

    # Meilleur PnL
    print(f"\n🏆 Meilleur PnL:")
    print(f"   Statique: {static_stats['best_pnl']:>+7.2f}%")
    print(f"   Dynamic:  {dynamic_stats['best_pnl']:>+7.2f}%")
    diff = dynamic_stats['best_pnl'] - static_stats['best_pnl']
    winner = "✅ DYNAMIC" if diff > 0 else "✅ STATIQUE" if diff < 0 else "🤝 ÉGALITÉ"
    print(f"   → {winner} ({diff:+.2f}%)")

    # PnL moyen
    print(f"\n📈 PnL moyen (profitables):")
    print(f"   Statique: {static_stats['avg_pnl']:>+7.2f}%")
    print(f"   Dynamic:  {dynamic_stats['avg_pnl']:>+7.2f}%")
    diff = dynamic_stats['avg_pnl'] - static_stats['avg_pnl']
    winner = "✅ DYNAMIC" if diff > 0 else "✅ STATIQUE" if diff < 0 else "🤝 ÉGALITÉ"
    print(f"   → {winner} ({diff:+.2f}%)")

    # Profit Factor
    print(f"\n💪 Profit Factor moyen:")
    print(f"   Statique: {static_stats['avg_pf']:>7.2f}")
    print(f"   Dynamic:  {dynamic_stats['avg_pf']:>7.2f}")
    diff = dynamic_stats['avg_pf'] - static_stats['avg_pf']
    winner = "✅ DYNAMIC" if diff > 0 else "✅ STATIQUE" if diff < 0 else "🤝 ÉGALITÉ"
    print(f"   → {winner} ({diff:+.2f})")

    # Score final
    print(f"\n{'='*80}")
    print("🎯 SCORE FINAL")
    print(f"{'='*80}")

    static_wins = 0
    dynamic_wins = 0

    if dynamic_stats['profitable_pct'] > static_stats['profitable_pct']:
        dynamic_wins += 1
    elif dynamic_stats['profitable_pct'] < static_stats['profitable_pct']:
        static_wins += 1

    if dynamic_stats['best_pnl'] > static_stats['best_pnl']:
        dynamic_wins += 1
    elif dynamic_stats['best_pnl'] < static_stats['best_pnl']:
        static_wins += 1

    if dynamic_stats['avg_pnl'] > static_stats['avg_pnl']:
        dynamic_wins += 1
    elif dynamic_stats['avg_pnl'] < static_stats['avg_pnl']:
        static_wins += 1

    if dynamic_stats['avg_pf'] > static_stats['avg_pf']:
        dynamic_wins += 1
    elif dynamic_stats['avg_pf'] < static_stats['avg_pf']:
        static_wins += 1

    print(f"Statique: {static_wins} / 4")
    print(f"Dynamic:  {dynamic_wins} / 4")

    if dynamic_wins > static_wins:
        print(f"\n🎉 GAGNANT: DYNAMIC (adaptation ATR) avec {dynamic_wins}-{static_wins}")
    elif static_wins > dynamic_wins:
        print(f"\n🎉 GAGNANT: STATIQUE (params fixes) avec {static_wins}-{dynamic_wins}")
    else:
        print(f"\n🤝 ÉGALITÉ {static_wins}-{dynamic_wins}")


def display_battle():
    """Affiche le dashboard complet"""
    clear_screen()

    print("="*80)
    print("⚔️  BATTLE: STATIQUE vs DYNAMIQUE")
    print("="*80)
    print(f"⏰ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print("="*80)

    # Charger résultats
    static_results = load_results('smart_optimizer_results.json')
    dynamic_results = load_results('smart_optimizer_dynamic_results.json')

    # Afficher stats
    print("\n")
    static_stats = display_optimizer_stats(static_results, "STATIQUE (Params Fixes)", "\033[94m")  # Blue

    print("\n")
    dynamic_stats = display_optimizer_stats(dynamic_results, "DYNAMIC (Adaptation ATR)", "\033[92m")  # Green

    # Comparaison
    if static_stats and dynamic_stats:
        display_comparison(static_stats, dynamic_stats)

    print(f"\n{'='*80}")
    print("⏳ Rafraîchissement dans 10s... (Ctrl+C pour quitter)")
    print("="*80)


if __name__ == '__main__':
    print("\n🚀 Démarrage du Battle Monitor...\n")

    try:
        while True:
            display_battle()
            time.sleep(10)
    except KeyboardInterrupt:
        clear_screen()
        print("\n👋 Battle Monitor arrêté.\n")

        # Afficher résumé final
        static_results = load_results('smart_optimizer_results.json')
        dynamic_results = load_results('smart_optimizer_dynamic_results.json')

        if static_results and dynamic_results:
            static_profitable = [r for r in static_results if r['results']['total_pnl_pct'] > 0
                               and r['results']['profit_factor'] > 1.0]
            dynamic_profitable = [r for r in dynamic_results if r['results']['total_pnl_pct'] > 0
                                and r['results']['profit_factor'] > 1.0]

            print("="*80)
            print("📊 RÉSUMÉ FINAL")
            print("="*80)
            print(f"\nStatique: {len(static_results)} tests | {len(static_profitable)} profitables")
            print(f"Dynamic:  {len(dynamic_results)} tests | {len(dynamic_profitable)} profitables")

            if static_profitable:
                best_static = max(static_profitable, key=lambda x: x['results']['total_pnl_pct'])
                print(f"\n🏆 Meilleur Statique: {best_static['results']['total_pnl_pct']:+.2f}%")

            if dynamic_profitable:
                best_dynamic = max(dynamic_profitable, key=lambda x: x['results']['total_pnl_pct'])
                print(f"🏆 Meilleur Dynamic:  {best_dynamic['results']['total_pnl_pct']:+.2f}%")

            print("="*80)
            print("\n💾 Résultats complets:")
            print("   - smart_optimizer_results.json")
            print("   - smart_optimizer_dynamic_results.json\n")