#!/usr/bin/env python3
"""
Script de lancement du système de monitoring des sauvegardes
Usage: python run.py [command]
Commands:
    monitor - Lance le monitoring en continu
    test - Test les connexions et affiche les infos
    analyze - Analyse les emails une fois et affiche le résultat
    inspect - Analyse détaillée avec tous les détails des emails
    cleanup - Nettoie la base de données
"""

import sys
import os
from datetime import datetime

def test_system():
    """Test le système et affiche les informations"""
    print("=== TEST DU SYSTÈME DE MONITORING ===")
    print(f"Date/Heure: {datetime.now()}")
    print("-" * 40)
    
    # Importer les modules
    try:
        from config import EMAIL_CONFIG, GRAPH_CONFIG
        print("✓ Configuration chargée")
        print(f"  - Mode: {'TEST' if EMAIL_CONFIG['is_test_mode'] else 'PRODUCTION'}")
        print(f"  - Boîte surveillée: {EMAIL_CONFIG['monitored_mailbox']}")
        print(f"  - Destinataire alertes: {EMAIL_CONFIG['alert_recipient_test' if EMAIL_CONFIG['is_test_mode'] else 'alert_recipient_prod']}")
    except Exception as e:
        print(f"✗ Erreur configuration: {e}")
        return False
    
    # Test authentification
    try:
        from auth import graph_auth
        print("\nTest de l'authentification Microsoft Graph...")
        if graph_auth.test_connection():
            print("✓ Authentification réussie")
        else:
            print("✗ Échec de l'authentification")
            return False
    except Exception as e:
        print(f"✗ Erreur authentification: {e}")
        return False
    
    # Test lecture emails
    try:
        from mail_reader import MailReader
        reader = MailReader()
        print("\nTest d'accès à la boîte mail...")
        if reader.test_mailbox_access():
            print("✓ Accès à la boîte mail réussi")
            
            # Récupérer quelques emails récents
            emails = reader.get_recent_emails(hours=24)
            print(f"  - {len(emails)} emails trouvés dans les dernières 24h")
            
            if emails and len(emails) > 0:
                print(f"  - Dernier email: {emails[0].get('subject', 'N/A')}")
        else:
            print("✗ Échec d'accès à la boîte mail")
            return False
    except Exception as e:
        print(f"✗ Erreur lecture emails: {e}")
        return False
    
    # Test base de données
    try:
        from database import BackupDatabase
        db = BackupDatabase()
        stats = db.get_statistics(days=7)
        print("\n✓ Base de données initialisée")
        print(f"  - Total sauvegardes (7j): {stats.get('total', 0)}")
        print(f"  - Taux de succès: {stats.get('success_rate', 0):.1f}%")
    except Exception as e:
        print(f"✗ Erreur base de données: {e}")
        return False
    
    print("\n" + "=" * 40)
    print("TOUS LES TESTS RÉUSSIS !")
    print("Le système est prêt à fonctionner.")
    print("\nPour démarrer le monitoring: python run.py monitor")
    return True

def run_analysis_once():
    """Exécute une analyse unique des emails"""
    print("=== ANALYSE UNIQUE DES EMAILS ===")
    
    try:
        from mail_reader import MailReader
        from mail_analyzer import BackupAnalyzer
        from database import BackupDatabase
        
        reader = MailReader()
        analyzer = BackupAnalyzer()
        db = BackupDatabase()
        
        # Récupérer les emails des dernières 48h
        print("Récupération des emails...")
        emails = reader.get_recent_emails(hours=48)
        print(f"Trouvé {len(emails)} emails")
        
        # Analyser chaque email
        print("\nAnalyse des sauvegardes:")
        print("-" * 40)
        
        success_count = 0
        failure_count = 0
        
        for email in emails:
            info = analyzer.extract_backup_info(email)
            if info:
                status_icon = "✓" if info['status'] == 'success' else "✗"
                print(f"{status_icon} {info['backup_name']}")
                print(f"  Type: {info['backup_type']}")
                print(f"  Statut: {info['status']}")
                print(f"  Date: {info['received_date']}")
                print(f"  Taille: {info['size']}")
                print()
                
                # Compter les statuts
                if info['status'] == 'success':
                    success_count += 1
                elif info['status'] == 'failure':
                    failure_count += 1
                
                # Sauvegarder dans la DB
                db.insert_backup_record(info)
        
        # Vérifier les manquants
        print("\nVérification des sauvegardes manquantes:")
        print("-" * 40)
        missing = db.check_missing_backups()
        if missing:
            for name, info in missing.items():
                print(f"⚠ {name}")
                print(f"  Dernière vue il y a {info['hours_ago']}h")
        else:
            print("Aucune sauvegarde manquante")
        
        # Résumé
        print("\n" + "=" * 40)
        print("RÉSUMÉ:")
        print(f"  Succès: {success_count}")
        print(f"  Échecs: {failure_count}")
        print(f"  Manquantes: {len(missing)}")
        
    except Exception as e:
        print(f"Erreur pendant l'analyse: {e}")
        import traceback
        traceback.print_exc()

def run_detailed_inspection():
    """Exécute une analyse détaillée avec TOUS les détails des emails"""
    print("=== INSPECTION DÉTAILLÉE DES EMAILS ===")
    print("Cette analyse affiche TOUS les détails pour debug manuel\n")
    
    try:
        from mail_reader import MailReader
        from mail_analyzer import BackupAnalyzer
        from database import BackupDatabase
        from datetime import datetime, timezone
        
        reader = MailReader()
        analyzer = BackupAnalyzer()
        db = BackupDatabase()
        
        # Récupérer les emails des dernières 48h
        print("Récupération des emails des dernières 48h...")
        emails = reader.get_recent_emails(hours=48)
        print(f"✓ {len(emails)} emails trouvés\n")
        print("=" * 80)
        
        success_count = 0
        failure_count = 0
        unknown_count = 0
        
        for idx, email in enumerate(emails, 1):
            info = analyzer.extract_backup_info(email)
            if info:
                # Icône selon le statut
                if info['status'] == 'success':
                    status_icon = "✓"
                    success_count += 1
                elif info['status'] == 'failure':
                    status_icon = "✗"
                    failure_count += 1
                else:
                    status_icon = "?"
                    unknown_count += 1
                
                # Formater la date de réception
                try:
                    received_dt = datetime.fromisoformat(info['received_date'].replace('Z', '+00:00'))
                    date_formatted = received_dt.strftime('%d/%m/%Y à %H:%M:%S')
                    age_hours = (datetime.now(timezone.utc) - received_dt).total_seconds() / 3600
                    age_str = f"il y a {age_hours:.1f}h"
                except:
                    date_formatted = info['received_date']
                    age_str = ""
                
                # Affichage détaillé
                print(f"\n📧 EMAIL #{idx} - {status_icon} {info['status'].upper()}")
                print("─" * 80)
                print(f"📌 NOM DÉTECTÉ    : {info['backup_name']}")
                print(f"🏷️  TYPE          : {info['backup_type']}")
                print(f"📊 STATUT         : {info['status']}")
                print(f"📅 DATE RÉCEPTION : {date_formatted} ({age_str})")
                print(f"✉️  SUJET COMPLET  : {info['subject']}")
                
                if info['size']:
                    print(f"💾 TAILLE         : {info['size']}")
                
                if info['duration']:
                    print(f"⏱️  DURÉE          : {info['duration']}")
                
                if info['start_time']:
                    print(f"🟢 DÉBUT          : {info['start_time']}")
                
                if info['end_time']:
                    print(f"🔴 FIN            : {info['end_time']}")
                
                if info.get('details') and info['details']:
                    print(f"📝 DÉTAILS        :")
                    for key, value in info['details'].items():
                        print(f"   - {key}: {value}")
                
                print(f"🆔 ID EMAIL       : {info['id']}")
                
                # Sauvegarder dans la DB
                db.insert_backup_record(info)
        
        # Statistiques finales
        print("\n" + "=" * 80)
        print("📊 STATISTIQUES DÉTAILLÉES")
        print("=" * 80)
        print(f"✓ Succès  : {success_count} ({success_count/len(emails)*100:.1f}%)")
        print(f"✗ Échecs  : {failure_count} ({failure_count/len(emails)*100:.1f}%)")
        print(f"? Inconnu : {unknown_count} ({unknown_count/len(emails)*100:.1f}%)")
        print(f"📧 TOTAL   : {len(emails)}")
        
        # Vérifier les manquants
        print("\n" + "=" * 80)
        print("⚠️  SAUVEGARDES MANQUANTES (>48h sans nouvelles)")
        print("=" * 80)
        missing = db.check_missing_backups()
        if missing:
            for name, info in missing.items():
                print(f"\n⚠️  {name}")
                print(f"   Type         : {info['type']}")
                print(f"   Dernière vue : {info['last_seen']}")
                print(f"   Il y a       : {info['hours_ago']} heures")
                print(f"   Dernier état : {info['last_status']}")
        else:
            print("✓ Aucune sauvegarde manquante")
        
        # Regrouper les échecs par nom
        print("\n" + "=" * 80)
        print("🔍 ANALYSE DES ÉCHECS PAR SAUVEGARDE")
        print("=" * 80)
        
        failures_by_name = {}
        for email in emails:
            info = analyzer.extract_backup_info(email)
            if info and info['status'] == 'failure':
                name = info['backup_name']
                if name not in failures_by_name:
                    failures_by_name[name] = []
                failures_by_name[name].append(info)
        
        if failures_by_name:
            for name, failures in failures_by_name.items():
                print(f"\n❌ {name} - {len(failures)} échec(s)")
                for fail in failures[:3]:  # Afficher max 3
                    try:
                        dt = datetime.fromisoformat(fail['received_date'].replace('Z', '+00:00'))
                        print(f"   - {dt.strftime('%d/%m/%Y %H:%M')} : {fail['subject'][:60]}...")
                    except:
                        print(f"   - {fail['received_date']} : {fail['subject'][:60]}...")
        else:
            print("✓ Aucun échec détecté")
        
        print("\n" + "=" * 80)
        print("💡 CONSEIL: Cherchez les emails dans votre boîte avec ces sujets")
        print("           pour voir le contenu complet et comprendre les erreurs")
        print("=" * 80)
        
    except Exception as e:
        print(f"❌ Erreur pendant l'inspection: {e}")
        import traceback
        traceback.print_exc()

def cleanup_database():
    """Nettoie la base de données"""
    print("=== NETTOYAGE DE LA BASE DE DONNÉES ===")
    
    try:
        from database import BackupDatabase
        db = BackupDatabase()
        
        # Afficher les stats avant
        stats_before = db.get_statistics(days=90)
        print(f"Enregistrements actuels (90j): {stats_before.get('total', 0)}")
        
        # Nettoyer
        deleted = db.cleanup_old_records(days=90)
        print(f"Supprimé {deleted} enregistrements de plus de 90 jours")
        
        # Stats après
        stats_after = db.get_statistics(days=90)
        print(f"Enregistrements restants: {stats_after.get('total', 0)}")
        
    except Exception as e:
        print(f"Erreur pendant le nettoyage: {e}")

def run_monitor():
    """Lance le monitoring en continu"""
    print("=== DÉMARRAGE DU MONITORING EN CONTINU ===")
    print("Appuyez sur Ctrl+C pour arrêter")
    print("-" * 40)
    
    try:
        from monitor import main
        main()
    except KeyboardInterrupt:
        print("\nArrêt demandé par l'utilisateur")
    except Exception as e:
        print(f"Erreur: {e}")
        import traceback
        traceback.print_exc()

def print_usage():
    """Affiche l'aide"""
    print("Usage: python run.py [command]")
    print("\nCommandes disponibles:")
    print("  monitor  - Lance le monitoring en continu")
    print("  test     - Test les connexions et affiche les infos")
    print("  analyze  - Analyse les emails une fois et affiche le résultat")
    print("  inspect  - 🔍 Analyse DÉTAILLÉE avec TOUS les détails (NOUVEAU!)")
    print("  cleanup  - Nettoie la base de données")
    print("  help     - Affiche cette aide")
    print("\n💡 Utilisez 'inspect' pour voir tous les détails des emails !")

def main():
    """Point d'entrée principal"""
    if len(sys.argv) < 2:
        print_usage()
        sys.exit(0)
    
    command = sys.argv[1].lower()
    
    if command == 'monitor':
        run_monitor()
    elif command == 'test':
        if test_system():
            sys.exit(0)
        else:
            sys.exit(1)
    elif command == 'analyze':
        run_analysis_once()
    elif command == 'inspect':
        run_detailed_inspection()
    elif command == 'cleanup':
        cleanup_database()
    elif command == 'help':
        print_usage()
    else:
        print(f"Commande inconnue: {command}")
        print_usage()
        sys.exit(1)

if __name__ == "__main__":
    main()