#!/usr/bin/env python3
"""
Script de Capture et Test Automatique

Ce script:
1. Capture l'écran pendant 1 minute (1 screenshot toutes les 2 secondes)
2. Enregistre les screenshots dans data/sessions/
3. Crée une RawSession JSON
4. Teste le GraphBuilder avec la session capturée
"""

import sys
import time
import logging
from pathlib import Path
from datetime import datetime
import json

sys.path.insert(0, str(Path(__file__).parent.parent))

# Import après ajout au path
try:
    import mss
    import mss.tools
except ImportError:
    print("❌ Erreur: mss n'est pas installé")
    print("Installation: pip install mss")
    sys.exit(1)

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

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


def capture_session(duration_seconds=60, interval_seconds=2):
    """
    Capturer l'écran pendant une durée donnée.
    
    Args:
        duration_seconds: Durée totale de capture (défaut: 60s)
        interval_seconds: Intervalle entre captures (défaut: 2s)
    
    Returns:
        Tuple (session_dir, screenshots_list)
    """
    # Créer répertoire de session
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    session_id = f"session_{timestamp}"
    session_dir = Path(__file__).parent.parent / "data" / "sessions" / session_id
    screenshots_dir = session_dir / "screenshots"
    screenshots_dir.mkdir(parents=True, exist_ok=True)
    
    logger.info("=" * 70)
    logger.info("CAPTURE DE SESSION")
    logger.info("=" * 70)
    logger.info(f"Session ID: {session_id}")
    logger.info(f"Durée: {duration_seconds}s")
    logger.info(f"Intervalle: {interval_seconds}s")
    logger.info(f"Screenshots attendus: ~{duration_seconds // interval_seconds}")
    logger.info(f"Répertoire: {session_dir}")
    logger.info("")
    logger.info("🎬 Démarrage de la capture dans 3 secondes...")
    logger.info("   Effectuez des actions répétées pour créer des patterns!")
    time.sleep(3)
    
    screenshots = []
    start_time = time.time()
    screenshot_count = 0
    
    with mss.mss() as sct:
        while (time.time() - start_time) < duration_seconds:
            # Capturer l'écran
            monitor = sct.monitors[1]  # Écran principal
            screenshot_data = sct.grab(monitor)
            
            # Sauvegarder
            screenshot_id = f"screen_{screenshot_count:04d}"
            screenshot_filename = f"{screenshot_id}.png"
            screenshot_path = screenshots_dir / screenshot_filename
            
            mss.tools.to_png(screenshot_data.rgb, screenshot_data.size, output=str(screenshot_path))
            
            # Créer objet Screenshot
            screenshot = Screenshot(
                screenshot_id=screenshot_id,
                relative_path=f"screenshots/{screenshot_filename}",
                captured_at=datetime.now().isoformat()
            )
            screenshots.append(screenshot)
            
            screenshot_count += 1
            elapsed = time.time() - start_time
            remaining = duration_seconds - elapsed
            
            logger.info(f"📸 Screenshot {screenshot_count} capturé - Reste {remaining:.0f}s")
            
            # Attendre avant prochaine capture
            time.sleep(interval_seconds)
    
    logger.info("")
    logger.info(f"✅ Capture terminée: {screenshot_count} screenshots")
    
    return session_dir, screenshots, session_id


def create_session_json(session_dir, screenshots, session_id):
    """Créer le fichier JSON de la session."""
    logger.info("\n📝 Création du fichier session.json...")
    
    session = RawSession(
        session_id=session_id,
        agent_version="v3.0",
        environment={"os": "linux", "capture": "auto"},
        user="test_user",
        context={"type": "automated_capture"},
        started_at=screenshots[0].captured_at if screenshots else datetime.now().isoformat()
    )
    
    session.screenshots = screenshots
    
    # Sauvegarder JSON
    session_file = session_dir / "session.json"
    session.save(str(session_file))
    
    logger.info(f"✅ Session sauvegardée: {session_file}")
    return session, session_file


def test_workflow_construction(session, session_file):
    """Tester la construction du workflow."""
    logger.info("\n" + "=" * 70)
    logger.info("TEST CONSTRUCTION DE WORKFLOW")
    logger.info("=" * 70)
    
    # Créer GraphBuilder
    logger.info("\n[1/3] Initialisation du GraphBuilder")
    faiss_manager = FAISSManager(dimensions=512)
    builder = GraphBuilder(
        faiss_manager=faiss_manager,
        min_pattern_repetitions=2,  # Bas pour détecter plus facilement
        clustering_eps=0.18  # Légèrement permissif
    )
    logger.info("✅ GraphBuilder initialisé")
    
    # Construire workflow
    logger.info("\n[2/3] Construction du workflow")
    try:
        workflow = builder.build_from_session(session, "Captured 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
    
    # Analyser résultats
    logger.info("\n[3/3] Analyse des résultats")
    
    if workflow.nodes:
        logger.info(f"\n📊 {len(workflow.nodes)} patterns détectés:")
        for node in workflow.nodes:
            logger.info(f"   • {node.node_id}: {node.observation_count} observations")
    else:
        logger.warning("\n⚠️  Aucun pattern détecté")
        logger.info("   Conseils:")
        logger.info("   - Répétez les mêmes actions plusieurs fois")
        logger.info("   - Attendez 2-3 secondes entre chaque action")
        logger.info("   - Utilisez des actions simples (cliquer, taper)")
    
    if workflow.edges:
        logger.info(f"\n🔗 {len(workflow.edges)} transitions détectées:")
        for edge in workflow.edges:
            logger.info(f"   • {edge.from_node_id} → {edge.to_node_id} ({edge.observation_count}x)")
    
    logger.info(f"\n💾 Index FAISS: {faiss_manager.index.ntotal} vecteurs")
    logger.info(f"📁 Session: {session_file}")
    
    # Résumé
    logger.info("\n" + "=" * 70)
    if workflow.nodes:
        logger.info("✅ TEST RÉUSSI - Patterns détectés!")
    else:
        logger.info("⚠️  TEST TERMINÉ - Aucun pattern (normal si actions variées)")
    logger.info("=" * 70)
    
    return True


def main():
    """Point d'entrée principal."""
    logger.info("🚀 CAPTURE ET TEST AUTOMATIQUE")
    logger.info("")
    
    # Étape 1: Capturer
    session_dir, screenshots, session_id = capture_session(
        duration_seconds=60,  # 1 minute
        interval_seconds=2     # 1 screenshot toutes les 2 secondes
    )
    
    if not screenshots:
        logger.error("❌ Aucun screenshot capturé")
        return False
    
    # Étape 2: Créer session JSON
    session, session_file = create_session_json(session_dir, screenshots, session_id)
    
    # Étape 3: Tester GraphBuilder
    success = test_workflow_construction(session, session_file)
    
    return success


if __name__ == "__main__":
    try:
        success = main()
        sys.exit(0 if success else 1)
    except KeyboardInterrupt:
        logger.info("\n\n⚠️  Capture interrompue par l'utilisateur")
        sys.exit(1)
    except Exception as e:
        logger.error(f"\n❌ Erreur: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)