#!/usr/bin/env python3
"""
Diagnostic de l'index FAISS - Vérifie l'état et le contenu de l'index.
"""

import os
import sys
import pickle
from pathlib import Path

# Ajouter le chemin du projet
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'geniusia2'))

def check_faiss_installation():
    """Vérifie si FAISS est installé."""
    print("\n1. Vérification de l'installation FAISS")
    print("=" * 60)
    
    try:
        import faiss
        print(f"✓ FAISS installé: version {faiss.__version__ if hasattr(faiss, '__version__') else 'inconnue'}")
        return True
    except ImportError:
        print("✗ FAISS n'est pas installé")
        return False


def check_index_files():
    """Vérifie la présence des fichiers d'index."""
    print("\n2. Vérification des fichiers d'index")
    print("=" * 60)
    
    index_path = Path("geniusia2/data/faiss_index")
    index_file = index_path / "embeddings.index"
    metadata_file = index_path / "metadata.pkl"
    
    results = {}
    
    # Vérifier le répertoire
    if index_path.exists():
        print(f"✓ Répertoire d'index existe: {index_path}")
        results['dir'] = True
    else:
        print(f"✗ Répertoire d'index manquant: {index_path}")
        results['dir'] = False
        return results
    
    # Vérifier le fichier d'index
    if index_file.exists():
        size = index_file.stat().st_size
        print(f"✓ Fichier d'index existe: {index_file}")
        print(f"  Taille: {size:,} octets ({size / 1024:.2f} KB)")
        results['index'] = True
    else:
        print(f"✗ Fichier d'index manquant: {index_file}")
        results['index'] = False
    
    # Vérifier le fichier de métadonnées
    if metadata_file.exists():
        size = metadata_file.stat().st_size
        print(f"✓ Fichier de métadonnées existe: {metadata_file}")
        print(f"  Taille: {size:,} octets ({size / 1024:.2f} KB)")
        results['metadata'] = True
    else:
        print(f"✗ Fichier de métadonnées manquant: {metadata_file}")
        results['metadata'] = False
    
    return results


def check_index_content():
    """Vérifie le contenu de l'index FAISS."""
    print("\n3. Vérification du contenu de l'index")
    print("=" * 60)
    
    try:
        import faiss
        
        index_file = Path("geniusia2/data/faiss_index/embeddings.index")
        
        if not index_file.exists():
            print("✗ Impossible de charger l'index (fichier manquant)")
            return False
        
        # Charger l'index
        index = faiss.read_index(str(index_file))
        
        print(f"✓ Index FAISS chargé avec succès")
        print(f"  Type d'index: {type(index).__name__}")
        print(f"  Dimension des vecteurs: {index.d}")
        print(f"  Nombre de vecteurs: {index.ntotal}")
        print(f"  Index entraîné: {'Oui' if index.is_trained else 'Non'}")
        
        if index.ntotal == 0:
            print("\n⚠ L'index est vide (aucun embedding stocké)")
        else:
            print(f"\n✓ L'index contient {index.ntotal} embeddings")
        
        return True
        
    except Exception as e:
        print(f"✗ Erreur lors du chargement de l'index: {e}")
        return False


def check_metadata_content():
    """Vérifie le contenu des métadonnées."""
    print("\n4. Vérification des métadonnées")
    print("=" * 60)
    
    metadata_file = Path("geniusia2/data/faiss_index/metadata.pkl")
    
    if not metadata_file.exists():
        print("✗ Fichier de métadonnées manquant")
        return False
    
    try:
        with open(metadata_file, 'rb') as f:
            metadata = pickle.load(f)
        
        print(f"✓ Métadonnées chargées avec succès")
        print(f"  Type: {type(metadata).__name__}")
        print(f"  Nombre d'entrées: {len(metadata)}")
        
        if len(metadata) == 0:
            print("\n⚠ Aucune métadonnée stockée")
        else:
            print(f"\n✓ {len(metadata)} métadonnées stockées")
            
            # Afficher un exemple
            if metadata:
                first_key = list(metadata.keys())[0]
                first_entry = metadata[first_key]
                print(f"\n  Exemple de métadonnée (ID {first_key}):")
                for key, value in first_entry.items():
                    if isinstance(value, str) and len(value) > 50:
                        value = value[:50] + "..."
                    print(f"    {key}: {value}")
        
        return True
        
    except Exception as e:
        print(f"✗ Erreur lors du chargement des métadonnées: {e}")
        return False


def check_embeddings_manager():
    """Vérifie que l'EmbeddingsManager peut être initialisé."""
    print("\n5. Vérification de l'EmbeddingsManager")
    print("=" * 60)
    
    try:
        # Importer sans initialiser complètement (éviter de charger les modèles lourds)
        from geniusia2.core.embeddings_manager import EmbeddingsManager
        print("✓ Module EmbeddingsManager importé avec succès")
        
        # Vérifier les dépendances
        try:
            import open_clip
            print("✓ OpenCLIP disponible")
        except ImportError:
            print("✗ OpenCLIP non disponible")
        
        try:
            import faiss
            print("✓ FAISS disponible")
        except ImportError:
            print("✗ FAISS non disponible")
        
        try:
            import torch
            print(f"✓ PyTorch disponible (version {torch.__version__})")
        except ImportError:
            print("✗ PyTorch non disponible")
        
        return True
        
    except Exception as e:
        print(f"✗ Erreur lors de l'import de l'EmbeddingsManager: {e}")
        return False


def check_usage_in_code():
    """Vérifie où FAISS est utilisé dans le code."""
    print("\n6. Utilisation de FAISS dans le code")
    print("=" * 60)
    
    files_to_check = [
        "geniusia2/core/suggestion_manager.py",
        "geniusia2/core/embeddings_manager.py",
        "geniusia2/core/learning_manager.py"
    ]
    
    for file_path in files_to_check:
        if os.path.exists(file_path):
            with open(file_path, 'r') as f:
                content = f.read()
                
            # Chercher les références à FAISS
            if 'faiss' in content.lower() or 'embeddings_manager' in content.lower():
                print(f"✓ {file_path}")
                
                # Compter les occurrences
                faiss_count = content.lower().count('faiss')
                embeddings_count = content.count('embeddings_manager')
                search_similar_count = content.count('search_similar')
                
                if faiss_count > 0:
                    print(f"  - Mentions de 'faiss': {faiss_count}")
                if embeddings_count > 0:
                    print(f"  - Mentions de 'embeddings_manager': {embeddings_count}")
                if search_similar_count > 0:
                    print(f"  - Appels à 'search_similar': {search_similar_count}")
    
    return True


def main():
    """Fonction principale."""
    print("\n" + "=" * 60)
    print("DIAGNOSTIC DE L'INDEX FAISS")
    print("=" * 60)
    
    results = []
    
    # 1. Installation FAISS
    results.append(check_faiss_installation())
    
    # 2. Fichiers d'index
    file_results = check_index_files()
    results.append(all(file_results.values()))
    
    # 3. Contenu de l'index
    if file_results.get('index', False):
        results.append(check_index_content())
    else:
        print("\n3. Vérification du contenu de l'index")
        print("=" * 60)
        print("⊘ Ignoré (fichier d'index manquant)")
        results.append(False)
    
    # 4. Métadonnées
    if file_results.get('metadata', False):
        results.append(check_metadata_content())
    else:
        print("\n4. Vérification des métadonnées")
        print("=" * 60)
        print("⊘ Ignoré (fichier de métadonnées manquant)")
        results.append(False)
    
    # 5. EmbeddingsManager
    results.append(check_embeddings_manager())
    
    # 6. Usage dans le code
    results.append(check_usage_in_code())
    
    # Résumé
    print("\n" + "=" * 60)
    print("RÉSUMÉ")
    print("=" * 60)
    
    passed = sum(results)
    total = len(results)
    
    print(f"Vérifications réussies: {passed}/{total}")
    
    if passed == total:
        print("\n✓ FAISS est correctement installé et configuré!")
    elif passed >= total - 2:
        print("\n⚠ FAISS est installé mais l'index est peut-être vide")
        print("  Ceci est normal si aucune tâche n'a encore été apprise.")
    else:
        print("\n✗ Des problèmes ont été détectés avec FAISS")
        print("  Exécute './geniusia2/install_faiss.sh' pour réinstaller")
    
    return 0 if passed >= total - 2 else 1


if __name__ == "__main__":
    sys.exit(main())
