#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Analyse complète de TOUS les patterns de trading pour optimisation systématique.
Objectif: Identifier les patterns qui fonctionnent bien vs ceux qui nécessitent des optimisations.
"""

import json
import re
from datetime import datetime
from collections import defaultdict
from typing import Dict, List, Tuple

# ═══════════════════════════════════════════════════════════════════════════
# CONFIGURATION
# ═══════════════════════════════════════════════════════════════════════════

LOG_FILE = "trading_bot.log"
TRADE_HISTORY_FILE = "trade_history_backup_20260118_185741.json"

# Liste complète des 21 patterns identifiés dans le code
ALL_PATTERNS = [
    "STRONG_UPTREND",
    "EARLY_BREAKOUT",
    "CONSOLIDATION_BREAKOUT",
    "EMA_BULLISH",
    "CROSSOVER_IMMINENT",
    "SQUEEZE_BREAKOUT",
    "VOLUME_REVERSAL",
    "RSI_REVERSAL",
    "END_OF_CYCLE",
    "ACTIVE_CRASH",
    "RSI_TRAP",
    "STRONG_DOWNTREND",
    "HIGH_SCORE_OVERRIDE",
    "IMMEDIATE_DIP",
    "CORRECTION_BUY",
    "CREUX_TOO_DEEP",
    "CREUX_REBOUND",
    "CREUX_WAITING",
    "PULLBACK",
    "FALLING_KNIFE_BLOCKED",
    "NEUTRAL"
]

# ═══════════════════════════════════════════════════════════════════════════
# ANALYSE DES LOGS
# ═══════════════════════════════════════════════════════════════════════════

def load_logs() -> List[str]:
    """Charge tous les logs du bot."""
    try:
        with open(LOG_FILE, 'r', encoding='utf-8') as f:
            logs = f.readlines()
        print(f"✅ {len(logs)} lignes de logs chargées")
        return logs
    except Exception as e:
        print(f"❌ Erreur lecture logs: {e}")
        return []

def extract_signals_by_pattern(logs: List[str]) -> Dict[str, List[Dict]]:
    """
    Extrait tous les signaux générés par pattern.
    Format log: 🤖 Signal IA: SYMBOL - Score=XX Pattern=PATTERN
    """
    signals = defaultdict(list)
    
    pattern_signal = re.compile(r'Signal IA: (\w+) - Score=([\d.]+) Pattern=(\w+)')
    
    for line in logs:
        match = pattern_signal.search(line)
        if match:
            symbol = match.group(1)
            score = float(match.group(2))
            pattern = match.group(3)
            
            signals[pattern].append({
                'symbol': symbol,
                'score': score,
                'line': line.strip()
            })
    
    return signals

def extract_pattern_detections(logs: List[str]) -> Dict[str, List[Dict]]:
    """
    Extrait les détections de patterns avec leurs indicateurs techniques.
    Format: 🎯 SYMBOL: Pattern=PATTERN Status=STATUS EMA_diff=XX% Mom3=XX% RSI=XX
    """
    detections = defaultdict(list)
    
    # Regex pour les détections de patterns
    pattern_regex = re.compile(
        r'🎯 (\w+): .*Pattern=(\w+) Status=(\w+) EMA_diff=([-\d.]+)% Mom3=([-\d.]+)% RSI=([\d.]+)'
    )
    
    for line in logs:
        match = pattern_regex.search(line)
        if match:
            symbol = match.group(1)
            pattern = match.group(2)
            status = match.group(3)
            ema_diff = float(match.group(4))
            mom3 = float(match.group(5))
            rsi = float(match.group(6))
            
            detections[pattern].append({
                'symbol': symbol,
                'status': status,
                'ema_diff': ema_diff,
                'momentum_3': mom3,
                'rsi': rsi
            })
    
    return detections

def extract_blocking_patterns(logs: List[str]) -> Dict[str, List[str]]:
    """
    Extrait les patterns qui ont BLOQUÉ des achats (sécurité).
    Format: ⚠️ SYMBOL: PATTERN BLOQUÉ - raison
    """
    blocks = defaultdict(list)
    
    blocking_patterns = [
        "END_OF_CYCLE",
        "ACTIVE_CRASH",
        "RSI_TRAP",
        "STRONG_DOWNTREND",
        "FALLING_KNIFE_BLOCKED"
    ]
    
    for pattern in blocking_patterns:
        pattern_regex = re.compile(f'{pattern}.*BLOQUÉ', re.IGNORECASE)
        for line in logs:
            if pattern_regex.search(line):
                blocks[pattern].append(line.strip())
    
    return blocks

def load_trade_history() -> List[Dict]:
    """Charge l'historique des trades."""
    try:
        with open(TRADE_HISTORY_FILE, 'r', encoding='utf-8') as f:
            trades = json.load(f)
        print(f"✅ {len(trades)} trades chargés depuis JSON")
        return trades
    except Exception as e:
        print(f"⚠️  Pas d'historique JSON: {e}")
        return []

def calculate_global_stats(trades: List[Dict]) -> Dict:
    """Calcule les statistiques globales."""
    if not trades:
        return {}
    
    wins = sum(1 for t in trades if t.get('pnl', 0) > 0)
    losses = sum(1 for t in trades if t.get('pnl', 0) < 0)
    total = wins + losses
    
    win_rate = (wins / total * 100) if total > 0 else 0
    total_pnl = sum(t.get('pnl', 0) for t in trades)
    
    avg_win = sum(t.get('pnl', 0) for t in trades if t.get('pnl', 0) > 0) / wins if wins > 0 else 0
    avg_loss = sum(t.get('pnl', 0) for t in trades if t.get('pnl', 0) < 0) / losses if losses > 0 else 0
    
    return {
        'total_trades': total,
        'wins': wins,
        'losses': losses,
        'win_rate': win_rate,
        'total_pnl': total_pnl,
        'avg_win': avg_win,
        'avg_loss': avg_loss
    }

# ═══════════════════════════════════════════════════════════════════════════
# RAPPORT D'ANALYSE
# ═══════════════════════════════════════════════════════════════════════════

def print_pattern_analysis(signals: Dict, detections: Dict, blocks: Dict):
    """Affiche l'analyse détaillée de tous les patterns."""
    
    print("\n" + "═" * 80)
    print("  📊 ANALYSE COMPLÈTE - TOUS LES PATTERNS DE TRADING")
    print("═" * 80)
    
    # 1. PATTERNS ACTIFS (générateurs de signaux)
    print("\n┌─────────────────────────────────────────────────────────────────┐")
    print("│ 🟢 PATTERNS ACTIFS (Génération de signaux d'achat)             │")
    print("└─────────────────────────────────────────────────────────────────┘\n")
    
    active_patterns = sorted(signals.items(), key=lambda x: len(x[1]), reverse=True)
    
    for pattern, signal_list in active_patterns:
        if len(signal_list) == 0:
            continue
            
        print(f"🎯 {pattern}")
        print(f"   • Signaux générés: {len(signal_list)}")
        
        # Statistiques des scores
        scores = [s['score'] for s in signal_list]
        avg_score = sum(scores) / len(scores)
        min_score = min(scores)
        max_score = max(scores)
        
        print(f"   • Score moyen: {avg_score:.1f} (min: {min_score:.1f}, max: {max_score:.1f})")
        
        # Indicateurs techniques moyens (si disponibles)
        if pattern in detections and detections[pattern]:
            det = detections[pattern]
            avg_rsi = sum(d['rsi'] for d in det) / len(det)
            avg_ema = sum(d['ema_diff'] for d in det) / len(det)
            avg_mom = sum(d['momentum_3'] for d in det) / len(det)
            
            print(f"   • Indicateurs moyens:")
            print(f"      - RSI: {avg_rsi:.1f}")
            print(f"      - EMA diff: {avg_ema:+.2f}%")
            print(f"      - Momentum 3: {avg_mom:+.2f}%")
        
        # Symboles les plus fréquents
        symbols = [s['symbol'] for s in signal_list]
        from collections import Counter
        top_symbols = Counter(symbols).most_common(3)
        if top_symbols:
            top_str = ", ".join([f"{sym} ({cnt}x)" for sym, cnt in top_symbols])
            print(f"   • Symboles fréquents: {top_str}")
        
        print()
    
    # 2. PATTERNS DE BLOCAGE (sécurité)
    print("┌─────────────────────────────────────────────────────────────────┐")
    print("│ 🔴 PATTERNS DE BLOCAGE (Sécurité - empêchent les achats)       │")
    print("└─────────────────────────────────────────────────────────────────┘\n")
    
    blocking_patterns = sorted(blocks.items(), key=lambda x: len(x[1]), reverse=True)
    
    for pattern, block_list in blocking_patterns:
        if len(block_list) == 0:
            continue
            
        print(f"🚫 {pattern}")
        print(f"   • Blocages effectués: {len(block_list)}")
        
        # Exemples de raisons de blocage
        if block_list:
            print(f"   • Exemple: {block_list[0][:100]}...")
        
        print()
    
    # 3. PATTERNS INACTIFS
    print("┌─────────────────────────────────────────────────────────────────┐")
    print("│ ⚪ PATTERNS INACTIFS (Non détectés récemment)                   │")
    print("└─────────────────────────────────────────────────────────────────┘\n")
    
    active_pattern_names = set(signals.keys()) | set(blocks.keys())
    inactive = [p for p in ALL_PATTERNS if p not in active_pattern_names and p != "NEUTRAL"]
    
    if inactive:
        for pattern in inactive:
            print(f"   • {pattern}")
    else:
        print("   ✅ Tous les patterns sont actifs!")
    
    print()

def print_recommendations(signals: Dict, detections: Dict, blocks: Dict):
    """Génère des recommandations d'optimisation."""
    
    print("\n" + "═" * 80)
    print("  💡 RECOMMANDATIONS D'OPTIMISATION")
    print("═" * 80 + "\n")
    
    recommendations = []
    
    # Analyse HIGH_SCORE_OVERRIDE
    if "HIGH_SCORE_OVERRIDE" in signals:
        high_score_signals = signals["HIGH_SCORE_OVERRIDE"]
        if high_score_signals:
            avg_score = sum(s['score'] for s in high_score_signals) / len(high_score_signals)
            recommendations.append({
                'pattern': 'HIGH_SCORE_OVERRIDE',
                'priority': 'HAUTE',
                'issue': f'{len(high_score_signals)} signaux générés (score moyen: {avg_score:.1f})',
                'risk': 'Peut bypasser les checks de sécurité (RSI trap, downtrend)',
                'action': 'Ajouter validation minimum RSI > 35 et momentum > -0.5% même pour scores élevés'
            })
    
    # Analyse PULLBACK
    if "PULLBACK" in signals and "PULLBACK" in detections:
        pullback_det = detections["PULLBACK"]
        if pullback_det:
            low_rsi = [d for d in pullback_det if d['rsi'] < 40]
            if len(low_rsi) > len(pullback_det) * 0.3:
                recommendations.append({
                    'pattern': 'PULLBACK',
                    'priority': 'MOYENNE',
                    'issue': f'{len(low_rsi)}/{len(pullback_det)} détections avec RSI < 40',
                    'risk': 'Achat trop tôt dans la correction (falling knife)',
                    'action': 'Ajouter confirmation rebond: momentum_3 > 0.2% OU RSI > 45'
                })
    
    # Analyse EMA_BULLISH
    if "EMA_BULLISH" in signals and "EMA_BULLISH" in detections:
        ema_det = detections["EMA_BULLISH"]
        if ema_det:
            weak_mom = [d for d in ema_det if abs(d['momentum_3']) < 0.1]
            if len(weak_mom) > len(ema_det) * 0.4:
                recommendations.append({
                    'pattern': 'EMA_BULLISH',
                    'priority': 'MOYENNE',
                    'issue': f'{len(weak_mom)}/{len(ema_det)} détections avec momentum faible',
                    'risk': 'Tendance haussière mais sans momentum (consolidation)',
                    'action': 'Exiger momentum_3 > 0.15% OU volume > moyenne pour confirmer force'
                })
    
    # Analyse EARLY_BREAKOUT (déjà optimisé)
    if "EARLY_BREAKOUT" in signals:
        recommendations.append({
            'pattern': 'EARLY_BREAKOUT',
            'priority': 'INFO',
            'issue': '✅ Déjà optimisé (21/01/2026)',
            'risk': 'Critères stricts appliqués (RSI >65, momentum >0.5%)',
            'action': 'Monitorer performances - attendu: Win Rate +5%'
        })
    
    # Affichage des recommandations
    for i, rec in enumerate(recommendations, 1):
        color = {
            'HAUTE': '🔴',
            'MOYENNE': '🟡',
            'BASSE': '🟢',
            'INFO': 'ℹ️'
        }.get(rec['priority'], '•')
        
        print(f"{color} RECOMMANDATION #{i} - {rec['pattern']} (Priorité: {rec['priority']})")
        print(f"   📌 Problème: {rec['issue']}")
        print(f"   ⚠️  Risque: {rec['risk']}")
        print(f"   ✅ Action: {rec['action']}")
        print()

# ═══════════════════════════════════════════════════════════════════════════
# MAIN
# ═══════════════════════════════════════════════════════════════════════════

def main():
    print("\n🚀 Démarrage de l'analyse complète des patterns...\n")
    
    # 1. Charger les données
    logs = load_logs()
    if not logs:
        print("❌ Impossible de charger les logs")
        return
    
    trades = load_trade_history()
    
    # 2. Statistiques globales
    if trades:
        stats = calculate_global_stats(trades)
        print("\n┌─────────────────────────────────────────────────────────────────┐")
        print("│ 📈 STATISTIQUES GLOBALES (Baseline)                            │")
        print("└─────────────────────────────────────────────────────────────────┘")
        print(f"\n   • Total trades: {stats['total_trades']}")
        print(f"   • Wins: {stats['wins']} ({stats['win_rate']:.1f}%)")
        print(f"   • Losses: {stats['losses']}")
        print(f"   • P&L Total: {stats['total_pnl']:+.2f}€")
        print(f"   • Gain moyen (win): {stats['avg_win']:+.2f}€")
        print(f"   • Perte moyenne (loss): {stats['avg_loss']:+.2f}€")
        print()
    
    # 3. Extraction des patterns
    print("📊 Extraction des patterns depuis les logs...")
    signals = extract_signals_by_pattern(logs)
    detections = extract_pattern_detections(logs)
    blocks = extract_blocking_patterns(logs)
    
    print(f"   ✅ {sum(len(v) for v in signals.values())} signaux extraits")
    print(f"   ✅ {sum(len(v) for v in detections.values())} détections analysées")
    print(f"   ✅ {sum(len(v) for v in blocks.values())} blocages recensés")
    
    # 4. Analyse complète
    print_pattern_analysis(signals, detections, blocks)
    
    # 5. Recommandations
    print_recommendations(signals, detections, blocks)
    
    # 6. Résumé final
    print("═" * 80)
    print("  ✅ ANALYSE TERMINÉE")
    print("═" * 80)
    print("\n💡 Prochaines étapes:")
    print("   1. Implémenter les optimisations recommandées (priorité HAUTE)")
    print("   2. Tester sur données historiques (backtesting)")
    print("   3. Monitorer Win Rate après changements")
    print("   4. Itérer sur patterns priorité MOYENNE\n")

if __name__ == "__main__":
    main()