"""
Utilitaire de gestion des patterns en ligne de commande
========================================================
"""

import sys
import codecs

# Forcer UTF-8 pour Windows
if sys.platform == 'win32':
    if sys.stdout.encoding != 'utf-8':
        sys.stdout = codecs.getwriter('utf-8')(sys.stdout.buffer, 'strict')
    if sys.stderr.encoding != 'utf-8':
        sys.stderr = codecs.getwriter('utf-8')(sys.stderr.buffer, 'strict')

from pattern_manager import get_pattern_manager



def print_help():
    """Affiche l'aide"""
    print(__doc__)


def cmd_list(pm):
    """Liste tous les patterns"""
    print("\n LISTE DES PATTERNS\n")
    print(f"{'Pattern':25s} {'Status':8s} {'WR':6s} {'Trades':7s} {'Score':6s} {'Description'}")
    print("="*100)
    
    for name in sorted(pm.patterns.keys()):
        config = pm.patterns[name]
        
        if name in pm.blacklisted_patterns:
            status = "[BLACKLIST] BL"
        elif config.enabled:
            status = "[OK] ON"
        else:
            status = "[OFF] OFF"
        
        wr = f"{config.win_rate:.1f}%" if config.total_trades > 0 else "N/A"
        trades = str(config.total_trades)
        score = str(config.min_score)
        
        print(f"{name:25s} {status:8s} {wr:6s} {trades:7s} {score:6s} {config.description[:40]}")
    
    print("\n" + "="*100)
    print(f"Total: {len(pm.patterns)} | Actifs: {len(pm.get_enabled_patterns())} | "
          f"Blacklistés: {len(pm.blacklisted_patterns)}")


def cmd_stats(pm, pattern_name):
    """Affiche les stats détaillées d'un pattern"""
    if pattern_name not in pm.patterns:
        print(f"[ERR] Pattern '{pattern_name}' inconnu")
        return
    
    config = pm.patterns[pattern_name]
    stats = config.to_dict()
    
    print(f"\n STATISTIQUES - {pattern_name}")
    print("="*70)
    print(f"Description: {config.description}")
    print(f"\nSTATUS:")
    print(f"  Activé: {'[OK] Oui' if config.enabled else '[OFF] Non'}")
    print(f"  Blacklisté: {'[BLACKLIST] Oui' if pattern_name in pm.blacklisted_patterns else '[OK] Non'}")
    print(f"  Score IA minimum: {config.min_score}")
    print(f"  Win rate minimum: {config.win_rate_threshold}%")
    
    print(f"\nPERFORMANCE:")
    print(f"  Signaux générés: {config.total_signals}")
    print(f"  Trades executés: {config.total_trades}")
    print(f"  Wins: {config.wins}")
    print(f"  Losses: {config.losses}")
    print(f"  Win Rate: {config.win_rate:.1f}%")
    print(f"  P&L total: {config.total_pnl:+.2f}%")
    print(f"  P&L moyen: {config.avg_pnl:+.3f}%")
    
    if config.last_used:
        print(f"  Dernière utilisation: {config.last_used.strftime('%Y-%m-%d %H:%M:%S')}")
    
    print(f"\nÉVALUATION:")
    if config.is_profitable:
        print("  [OK] PROFITABLE - Performance acceptable")
    elif config.needs_review:
        print("  [WARN] RÉVISION NÉCESSAIRE - Performance insuffisante")
    elif config.total_trades < 5:
        print("   DONNÉES INSUFFISANTES - Besoin de plus de trades")
    else:
        print("  [OFF] NON PROFITABLE - Performance faible")
    
    print("="*70)


def cmd_enable(pm, pattern_name):
    """Active un pattern"""
    if pm.enable_pattern(pattern_name):
        print(f"[OK] Pattern '{pattern_name}' activé avec succès")
    else:
        print(f"[ERR] Pattern '{pattern_name}' inconnu")


def cmd_disable(pm, pattern_name):
    """Désactive un pattern"""
    if pm.disable_pattern(pattern_name):
        print(f"[OFF] Pattern '{pattern_name}' désactivé avec succès")
    else:
        print(f"[ERR] Pattern '{pattern_name}' inconnu")


def cmd_blacklist(pm, pattern_name):
    """Blackliste un pattern"""
    if pm.blacklist_pattern(pattern_name):
        print(f"[BLACKLIST] Pattern '{pattern_name}' blacklisté avec succès")
    else:
        print(f"[ERR] Pattern '{pattern_name}' inconnu")


def cmd_unblacklist(pm, pattern_name):
    """Retire un pattern de la blacklist"""
    if pattern_name in pm.blacklisted_patterns:
        pm.blacklisted_patterns.remove(pattern_name)
        pm.save_config()
        print(f"[OK] Pattern '{pattern_name}' retiré de la blacklist")
    else:
        print(f"[ERR] Pattern '{pattern_name}' n'est pas blacklisté")


def cmd_score(pm, pattern_name, new_score):
    """Change le score IA minimum d'un pattern"""
    try:
        score = int(new_score)
        if score < 0 or score > 100:
            print("[ERR] Le score doit être entre 0 et 100")
            return
        
        if pm.update_min_score(pattern_name, score):
            print(f"[OK] Score minimum de '{pattern_name}' mis à jour: {score}")
        else:
            print(f"[ERR] Pattern '{pattern_name}' inconnu")
    except ValueError:
        print("[ERR] Score invalide (doit être un nombre entier)")


def cmd_optimize(pm):
    """Optimise automatiquement les patterns"""
    print("\n[OPTIM] OPTIMISATION AUTOMATIQUE DES PATTERNS...\n")
    
    optimizations = pm.optimize_patterns()
    
    if optimizations['disabled']:
        print(f"[OFF] Patterns désactivés ({len(optimizations['disabled'])}):")
        for p in optimizations['disabled']:
            print(f"  - {p}")
    
    if optimizations['blacklisted']:
        print(f"\n[BLACKLIST] Patterns blacklistés ({len(optimizations['blacklisted'])}):")
        for p in optimizations['blacklisted']:
            print(f"  - {p}")
    
    if optimizations['score_increased']:
        print(f"\n Scores augmentés ({len(optimizations['score_increased'])}):")
        for p in optimizations['score_increased']:
            print(f"  - {p}")
    
    if optimizations['score_decreased']:
        print(f"\n Scores baissés ({len(optimizations['score_decreased'])}):")
        for p in optimizations['score_decreased']:
            print(f"  - {p}")
    
    if not any(optimizations.values()):
        print("[OK] Aucune optimisation nécessaire - Tous les patterns sont OK")
    else:
        total = sum(len(v) for v in optimizations.values())
        print(f"\n[OK] Optimisation terminée - {total} patterns modifiés")


def cmd_report(pm):
    """Affiche le rapport de performance"""
    print(pm.get_performance_report())


def cmd_reset(pm, pattern_name):
    """Reset les statistiques d'un pattern"""
    if pattern_name not in pm.patterns:
        print(f"[ERR] Pattern '{pattern_name}' inconnu")
        return
    
    confirm = input(f"[WARN] Confirmer le reset des stats de '{pattern_name}' ? (oui/non): ")
    if confirm.lower() not in ['oui', 'yes', 'o', 'y']:
        print("[ERR] Annulé")
        return
    
    config = pm.patterns[pattern_name]
    config.total_signals = 0
    config.total_trades = 0
    config.wins = 0
    config.losses = 0
    config.total_pnl = 0.0
    config.last_used = None
    pm.save_config()
    
    print(f"[OK] Statistiques de '{pattern_name}' réinitialisées")


def main():
    if len(sys.argv) < 2:
        print_help()
        return
    
    pm = get_pattern_manager()
    command = sys.argv[1].lower()
    
    try:
        if command == 'list':
            cmd_list(pm)
        
        elif command == 'stats':
            if len(sys.argv) < 3:
                print("[ERR] Usage: python manage_patterns.py stats PATTERN_NAME")
                return
            cmd_stats(pm, sys.argv[2])
        
        elif command == 'enable':
            if len(sys.argv) < 3:
                print("[ERR] Usage: python manage_patterns.py enable PATTERN_NAME")
                return
            cmd_enable(pm, sys.argv[2])
        
        elif command == 'disable':
            if len(sys.argv) < 3:
                print("[ERR] Usage: python manage_patterns.py disable PATTERN_NAME")
                return
            cmd_disable(pm, sys.argv[2])
        
        elif command == 'blacklist':
            if len(sys.argv) < 3:
                print("[ERR] Usage: python manage_patterns.py blacklist PATTERN_NAME")
                return
            cmd_blacklist(pm, sys.argv[2])
        
        elif command == 'unblacklist':
            if len(sys.argv) < 3:
                print("[ERR] Usage: python manage_patterns.py unblacklist PATTERN_NAME")
                return
            cmd_unblacklist(pm, sys.argv[2])
        
        elif command == 'score':
            if len(sys.argv) < 4:
                print("[ERR] Usage: python manage_patterns.py score PATTERN_NAME NEW_SCORE")
                return
            cmd_score(pm, sys.argv[2], sys.argv[3])
        
        elif command == 'optimize':
            cmd_optimize(pm)
        
        elif command == 'report':
            cmd_report(pm)
        
        elif command == 'reset':
            if len(sys.argv) < 3:
                print("[ERR] Usage: python manage_patterns.py reset PATTERN_NAME")
                return
            cmd_reset(pm, sys.argv[2])
        
        else:
            print(f"[ERR] Commande inconnue: {command}")
            print_help()
    
    except Exception as e:
        print(f"\n[ERR] ERREUR: {e}")
        import traceback
        traceback.print_exc()


if __name__ == "__main__":
    main()
