#!/usr/bin/env python3
"""
Test de Construction de Workflow depuis une Session Réelle

Ce script teste la construction complète d'un workflow depuis une RawSession.
Utiliser avec l'interface GUI pour capturer une vraie session.

Usage:
    1. Lancer l'interface GUI: http://127.0.0.1:5000
    2. Capturer une session (plusieurs actions répétées)
    3. Exécuter ce script avec le chemin de la session
"""

import sys
import logging
from pathlib import Path

# Ajouter le répertoire parent au path
sys.path.insert(0, str(Path(__file__).parent.parent))

from core.graph.graph_builder import GraphBuilder
from core.models.raw_session import RawSession
from core.embedding.faiss_manager import FAISSManager

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)


def test_workflow_construction(session_path: str):
    """
    Tester la construction d'un workflow depuis une session.
    
    Args:
        session_path: Chemin vers le fichier JSON de la session
    """
    logger.info("=" * 70)
    logger.info("TEST CONSTRUCTION DE WORKFLOW")
    logger.info("=" * 70)
    
    # Étape 1: Charger la session
    logger.info(f"\n[1/5] Chargement de la session: {session_path}")
    try:
        session = RawSession.load(session_path)
        logger.info(f"✓ Session chargée: {session.session_id}")
        logger.info(f"  - Screenshots: {len(session.screenshots)}")
        logger.info(f"  - Événements: {len(session.events) if hasattr(session, 'events') else 0}")
    except Exception as e:
        logger.error(f"✗ Erreur chargement session: {e}")
        return False
    
    # Étape 2: Créer le GraphBuilder
    logger.info("\n[2/5] Initialisation du GraphBuilder")
    try:
        # Créer FAISS manager optionnel
        faiss_manager = FAISSManager(dimensions=512)
        
        builder = GraphBuilder(
            faiss_manager=faiss_manager,
            min_pattern_repetitions=2,  # Bas pour les tests
            clustering_eps=0.15
        )
        logger.info("✓ GraphBuilder initialisé")
    except Exception as e:
        logger.error(f"✗ Erreur initialisation: {e}")
        return False
    
    # Étape 3: Construire le workflow
    logger.info("\n[3/5] Construction du workflow")
    try:
        workflow = builder.build_from_session(
            session,
            workflow_name="Test Workflow"
        )
        logger.info(f"✓ Workflow construit: {workflow.workflow_id}")
        logger.info(f"  - Nodes: {len(workflow.nodes)}")
        logger.info(f"  - Edges: {len(workflow.edges)}")
    except Exception as e:
        logger.error(f"✗ Erreur construction: {e}")
        import traceback
        traceback.print_exc()
        return False
    
    # Étape 4: Analyser les nodes
    logger.info("\n[4/5] Analyse des nodes")
    for node in workflow.nodes:
        logger.info(f"  Node {node.node_id}:")
        logger.info(f"    - Name: {node.name}")
        logger.info(f"    - Observations: {node.observation_count}")
        logger.info(f"    - Similarity threshold: {node.template.embedding.min_cosine_similarity}")
    
    # Étape 5: Analyser les edges
    logger.info("\n[5/5] Analyse des edges")
    for edge in workflow.edges:
        logger.info(f"  Edge {edge.edge_id}:")
        logger.info(f"    - From: {edge.from_node_id} → To: {edge.to_node_id}")
        logger.info(f"    - Action: {edge.action.type}")
        logger.info(f"    - Target: {edge.action.target.role}")
        logger.info(f"    - Observations: {edge.observation_count}")
    
    # Résumé
    logger.info("\n" + "=" * 70)
    logger.info("✓ TEST RÉUSSI")
    logger.info("=" * 70)
    logger.info(f"Workflow: {len(workflow.nodes)} nodes, {len(workflow.edges)} edges")
    logger.info(f"FAISS index: {faiss_manager.index.ntotal} vectors")
    
    return True


def main():
    """Point d'entrée principal."""
    # Chemin par défaut vers le dossier de sessions
    default_session_dir = Path(__file__).parent.parent / "data" / "sessions"
    
    # Chercher la session la plus récente
    if len(sys.argv) < 2:
        # Utiliser la session la plus récente dans data/sessions/
        if default_session_dir.exists():
            session_files = sorted(default_session_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
            if session_files:
                session_path = str(session_files[0])
                logger.info(f"Utilisation de la session la plus récente: {session_path}")
            else:
                logger.error(f"Aucune session trouvée dans {default_session_dir}")
                print("\nPour capturer une session:")
                print("  1. Lancer l'interface GUI: http://127.0.0.1:5000")
                print("  2. Effectuer plusieurs actions répétées")
                print("  3. Sauvegarder la session dans data/sessions/")
                print("  4. Relancer ce script")
                sys.exit(1)
        else:
            logger.error(f"Dossier non trouvé: {default_session_dir}")
            default_session_dir.mkdir(parents=True, exist_ok=True)
            logger.info(f"Dossier créé: {default_session_dir}")
            print("\nPour capturer une session:")
            print("  1. Lancer l'interface GUI: http://127.0.0.1:5000")
            print("  2. Effectuer plusieurs actions répétées")
            print("  3. Sauvegarder la session dans data/sessions/")
            print("  4. Relancer ce script")
            sys.exit(1)
    else:
        session_path = sys.argv[1]
    
    if not Path(session_path).exists():
        logger.error(f"Fichier non trouvé: {session_path}")
        sys.exit(1)
    
    success = test_workflow_construction(session_path)
    sys.exit(0 if success else 1)


if __name__ == "__main__":
    main()