main.py

import os
import sys
import subprocess
import time
from pathlib import Path

# Couleurs pour l'affichage terminal
class Colors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKCYAN = '\033[96m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'


def print_header(text):
    """Affiche un en-tête formaté"""
    print("\n" + "=" * 80)
    print(f"{Colors.HEADER}{Colors.BOLD}{text.center(80)}{Colors.ENDC}")
    print("=" * 80 + "\n")


def print_success(text):
    """Affiche un message de succès"""
    print(f"{Colors.OKGREEN}✓ {text}{Colors.ENDC}")


def print_info(text):
    """Affiche un message d'information"""
    print(f"{Colors.OKCYAN}ℹ {text}{Colors.ENDC}")


def print_warning(text):
    """Affiche un avertissement"""
    print(f"{Colors.WARNING}⚠ {text}{Colors.ENDC}")


def print_error(text):
    """Affiche une erreur"""
    print(f"{Colors.FAIL}✗ {text}{Colors.ENDC}")


def run_command(cmd, cwd=None, description=""):
    """Exécute une commande et retourne le code de sortie"""
    if description:
        print_info(f"{description}...")
    
    try:
        result = subprocess.run(
            cmd,
            cwd=cwd,
            shell=True,
            check=False,
            capture_output=False
        )
        
        if result.returncode == 0:
            print_success(f"Terminé: {description if description else 'Commande'}")
            return True
        else:
            print_error(f"Échec: {description if description else 'Commande'} (code: {result.returncode})")
            return False
    except Exception as e:
        print_error(f"Erreur lors de l'exécution: {e}")
        return False


def check_python_environment():
    """Vérifie l'environnement Python"""
    print_header("VÉRIFICATION DE L'ENVIRONNEMENT")
    
    print_info(f"Python: {sys.version}")
    print_info(f"Répertoire de travail: {os.getcwd()}")
    
    # Vérifier les modules requis
    required_modules = ['numpy', 'pandas', 'matplotlib', 'seaborn', 'scipy']
    missing = []
    
    for module in required_modules:
        try:
            __import__(module)
            print_success(f"Module {module} installé")
        except ImportError:
            print_error(f"Module {module} manquant")
            missing.append(module)
    
    if missing:
        print_warning(f"Modules manquants: {', '.join(missing)}")
        print_info("Installez-les avec: pip install " + " ".join(missing))
        return False
    
    return True


def generate_instances():
    """Génère les instances DIMACS si nécessaire"""
    print_header("GÉNÉRATION DES INSTANCES")
    
    instances_dir = Path("Benchmarks/Local/instances_dimacs")
    
    if instances_dir.exists():
        sat_files = list(instances_dir.glob("SAT/*.cnf"))
        threesat_files = list(instances_dir.glob("3SAT/*.cnf"))
        subsetsum_files = list(instances_dir.glob("SUBSETSUM/*.txt"))
        
        print_info(f"Instances SAT trouvées: {len(sat_files)}")
        print_info(f"Instances 3-SAT trouvées: {len(threesat_files)}")
        print_info(f"Instances SUBSETSUM trouvées: {len(subsetsum_files)}")
        
        if sat_files and threesat_files and subsetsum_files:
            print_success("Les instances existent déjà")
            response = input("\nRégénérer les instances ? (o/N): ").strip().lower()
            if response != 'o':
                return True
    
    print_info("Génération des nouvelles instances...")
    return run_command(
        f"{sys.executable} Benchmarks/Local/generation_instances.py",
        description="Génération des instances DIMACS"
    )


def run_local_benchmarks():
    """Exécute les benchmarks locaux"""
    print_header("BENCHMARKS LOCAUX")
    
    print_info("Exécution des benchmarks sur les instances générées localement")
    print_info("Cela peut prendre plusieurs minutes...")
    
    success = run_command(
        f"{sys.executable} Benchmarks/Local/benchmark_experiments.py",
        cwd="Benchmarks/Local",
        description="Benchmarks locaux (SAT, 3-SAT, SUBSETSUM)"
    )
    
    if success:
        # Vérifier les fichiers de résultats
        results_dir = Path("Benchmarks/Local/resultats")
        if results_dir.exists():
            excel_files = list(results_dir.glob("*.xlsx"))
            print_success(f"Fichiers de résultats générés: {len(excel_files)}")
            for f in excel_files:
                print(f"  - {f.name}")
    
    return success


def run_library_benchmarks():
    """Exécute les benchmarks sur les bibliothèques standards"""
    print_header("BENCHMARKS BIBLIOTHÈQUES STANDARDS")
    
    print_info("Téléchargement et test des instances SATLIB et FSU")
    print_warning("ATTENTION: Cela peut prendre BEAUCOUP de temps (30+ minutes)")
    print_warning("Les instances 3-SAT avec 20 variables peuvent prendre plusieurs secondes chacune")
    
    response = input("\nVoulez-vous exécuter les benchmarks des bibliothèques ? (o/N): ").strip().lower()
    
    if response != 'o':
        print_info("Benchmarks bibliothèques ignorés")
        return True
    
    success = run_command(
        f"echo '' | {sys.executable} Benchmarks/Libs/satlib_benchmarks.py",
        cwd="Benchmarks/Libs",
        description="Benchmarks bibliothèques (SATLIB, FSU)"
    )
    
    if success:
        results_dir = Path("Benchmarks/Libs/resultats")
        if results_dir.exists():
            excel_files = list(results_dir.glob("*.xlsx"))
            print_success(f"Fichiers de résultats générés: {len(excel_files)}")
            for f in excel_files:
                print(f"  - {f.name}")
    
    return success


def show_results_summary():
    """Affiche un résumé des résultats"""
    print_header("RÉSUMÉ DES RÉSULTATS")
    
    try:
        import pandas as pd
        
        results_dir = Path("Benchmarks/Local/resultats")
        
        if not results_dir.exists():
            print_warning("Aucun résultat trouvé. Exécutez d'abord les benchmarks.")
            return
        
        for problem in ["SAT", "3SAT", "SUBSETSUM"]:
            excel_file = results_dir / f"{problem}_benchmark.xlsx"
            
            if excel_file.exists():
                print(f"\n{Colors.BOLD}{problem}:{Colors.ENDC}")
                df = pd.read_excel(excel_file, sheet_name="Données brutes")
                
                print(f"  Instances testées: {len(df)}")
                
                if 'solution_trouvee' in df.columns:
                    solutions = df['solution_trouvee'].sum()
                    taux = (solutions / len(df) * 100) if len(df) > 0 else 0
                    print(f"  Solutions trouvées: {solutions}/{len(df)} ({taux:.1f}%)")
                
                if 'resol_temps_ms' in df.columns:
                    df_resol = df[df['resol_temps_ms'].notna()]
                    if len(df_resol) > 0:
                        print(f"  Temps moyen: {df_resol['resol_temps_ms'].mean():.3f} ms")
                        print(f"  Temps max: {df_resol['resol_temps_ms'].max():.3f} ms")
                
                if 'resol_memoire_kb' in df.columns:
                    df_resol = df[df['resol_memoire_kb'].notna()]
                    if len(df_resol) > 0:
                        print(f"  Mémoire moyenne: {df_resol['resol_memoire_kb'].mean():.2f} KB")
        
        print_success("\nRésultats disponibles dans: Benchmarks/Local/resultats/")
        
    except ImportError:
        print_warning("Pandas non disponible. Impossible d'afficher le résumé.")
    except Exception as e:
        print_error(f"Erreur lors de l'affichage des résultats: {e}")


def open_analysis_notebook():
    """Propose d'ouvrir le notebook d'analyse"""
    print_header("ANALYSE EMPIRIQUE")
    
    notebook_path = Path("analyse_empirique_complete.ipynb")
    
    if not notebook_path.exists():
        print_error("Le notebook d'analyse n'existe pas")
        return
    
    print_info("Le notebook d'analyse empirique contient:")
    print("  • Graphiques de complexité temporelle")
    print("  • Comparaison vérification vs résolution")
    print("  • Analyse de la croissance exponentielle O(2^n)")
    print("  • Statistiques détaillées")
    print("  • Taux de satisfiabilité")
    
    print(f"\n{Colors.BOLD}Pour visualiser les analyses:{Colors.ENDC}")
    print(f"  1. Ouvrez {Colors.OKCYAN}analyse_empirique_complete.ipynb{Colors.ENDC} dans VS Code")
    print(f"  2. Exécutez toutes les cellules (Ctrl+Shift+P → 'Run All')")
    print(f"  3. Les graphiques s'afficheront directement dans le notebook")


def test_algorithms():
    """Teste les algorithmes sur des exemples simples"""
    print_header("TEST DES ALGORITHMES")
    
    print_info("Test rapide des algorithmes de résolution et vérification...")
    
    tests = [
        ("SAT - Résolution", f"{sys.executable} trouve_sol_SAT.py"),
        ("3-SAT - Résolution", f"{sys.executable} trouve_sol_3SAT.py"),
        ("SUBSETSUM - Résolution", f"{sys.executable} trouve_sol_subsetsum.py"),
    ]
    
    print_warning("Note: Ces scripts attendent probablement des fichiers d'entrée.")
    print_info("Ignoré pour l'instant - utilisez les benchmarks à la place.\n")


def main_menu():
    """Menu principal interactif"""
    print_header("PROJET COMPLEXITÉ - MENU PRINCIPAL")
    
    print(f"{Colors.BOLD}Que voulez-vous faire ?{Colors.ENDC}\n")
    print("  1. Tout exécuter (instances + benchmarks locaux)")
    print("  2. Générer uniquement les instances")
    print("  3. Exécuter uniquement les benchmarks locaux")
    print("  4. Exécuter les benchmarks bibliothèques (SATLIB, FSU)")
    print("  5. Afficher le résumé des résultats")
    print("  6. Informations sur l'analyse empirique")
    print("  0. Quitter")
    
    choice = input(f"\n{Colors.BOLD}Votre choix: {Colors.ENDC}").strip()
    
    return choice


def run_full_project():
    """Exécute le projet complet"""
    print_header("EXÉCUTION COMPLÈTE DU PROJET")
    
    start_time = time.time()
    
    # Vérifier l'environnement
    if not check_python_environment():
        print_error("Environnement incomplet. Installez les dépendances manquantes.")
        return False
    
    # Générer les instances
    if not generate_instances():
        print_error("Échec de la génération des instances")
        return False
    
    # Benchmarks locaux
    if not run_local_benchmarks():
        print_error("Échec des benchmarks locaux")
        return False
    
    # Afficher les résultats
    show_results_summary()
    
    # Informations sur l'analyse
    open_analysis_notebook()
    
    elapsed = time.time() - start_time
    print_header("PROJET TERMINÉ")
    print_success(f"Temps total d'exécution: {elapsed:.2f} secondes ({elapsed/60:.1f} minutes)")
    
    return True


def main():
    """Point d'entrée principal"""
    
    # Vérifier qu'on est dans le bon répertoire
    if not Path("structures.py").exists():
        print_error("Ce script doit être exécuté depuis la racine du projet ComplexityProject")
        sys.exit(1)
    
    # Mode interactif ou automatique
    if len(sys.argv) > 1 and sys.argv[1] == "--auto":
        # Mode automatique
        run_full_project()
    else:
        # Mode interactif
        while True:
            choice = main_menu()
            
            if choice == "1":
                run_full_project()
            elif choice == "2":
                check_python_environment()
                generate_instances()
            elif choice == "3":
                check_python_environment()
                run_local_benchmarks()
                show_results_summary()
            elif choice == "4":
                check_python_environment()
                run_library_benchmarks()
            elif choice == "5":
                show_results_summary()
            elif choice == "6":
                open_analysis_notebook()
            elif choice == "0":
                print_info("Au revoir!")
                break
            else:
                print_warning("Choix invalide")
            
            input(f"\n{Colors.BOLD}Appuyez sur Entrée pour continuer...{Colors.ENDC}")


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print(f"\n\n{Colors.WARNING}Interruption par l'utilisateur{Colors.ENDC}")
        sys.exit(0)
    except Exception as e:
        print_error(f"Erreur fatale: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)