#!/usr/bin/env python3
"""
Démonstration du système d'apprentissage persistant - Fiche #18

Ce script démontre le fonctionnement du système d'apprentissage persistant
"mix" (JSONL + SQLite) pour la résolution de cibles UI.

Auteur: Dom, Alice Kiro - 22 décembre 2025
"""

import sys
import logging
from pathlib import Path
from datetime import datetime
from unittest.mock import Mock

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

from core.learning.target_memory_store import TargetMemoryStore, TargetFingerprint
from core.execution.target_resolver import TargetResolver
from core.execution.screen_signature import screen_signature

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


def create_mock_screen_state(window_title: str = "Test App") -> Mock:
    """Créer un mock ScreenState pour les tests"""
    screen_state = Mock()
    screen_state.screen_state_id = f"state_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
    screen_state.timestamp = datetime.now()
    
    # Mock window
    screen_state.window = Mock()
    screen_state.window.window_title = window_title
    screen_state.window.screen_resolution = [1920, 1080]
    
    # Mock perception
    screen_state.perception = Mock()
    screen_state.perception.detected_text = ["Login", "Password", "Submit", "Cancel"]
    
    return screen_state


def create_mock_ui_elements() -> list:
    """Créer des éléments UI mock pour les tests"""
    elements = []
    
    # Label "Email"
    email_label = Mock()
    email_label.element_id = "lbl_email"
    email_label.bbox = (50, 100, 80, 25)
    email_label.role = "label"
    email_label.label = "Email"
    elements.append(email_label)
    
    # Input email
    email_input = Mock()
    email_input.element_id = "input_email"
    email_input.bbox = (150, 100, 200, 25)
    email_input.role = "input"
    email_input.type = "text_input"
    email_input.label = ""
    elements.append(email_input)
    
    # Bouton Submit
    submit_btn = Mock()
    submit_btn.element_id = "btn_submit"
    submit_btn.bbox = (150, 200, 100, 35)
    submit_btn.role = "button"
    submit_btn.type = "submit"
    submit_btn.label = "Submit"
    elements.append(submit_btn)
    
    return elements


def create_mock_target_spec(by_role: str = None, by_text: str = None, context_hints: dict = None) -> Mock:
    """Créer un mock TargetSpec"""
    spec = Mock()
    spec.by_role = by_role
    spec.by_text = by_text
    spec.by_position = None
    spec.context_hints = context_hints or {}
    return spec


def demo_basic_learning():
    """Démonstration de base de l'apprentissage persistant"""
    print("\n" + "="*60)
    print("DÉMONSTRATION - Apprentissage persistant de base")
    print("="*60)
    
    # Initialiser le store
    store = TargetMemoryStore("data/learning_demo")
    
    # Créer des données de test
    screen_state = create_mock_screen_state("Login Form")
    ui_elements = create_mock_ui_elements()
    
    # Générer signature d'écran
    screen_sig = screen_signature(screen_state, ui_elements, mode="layout")
    print(f"📋 Signature d'écran générée: {screen_sig[:16]}...")
    
    # Créer un TargetSpec pour le bouton Submit
    target_spec = create_mock_target_spec(
        by_role="button",
        by_text="Submit"
    )
    
    print(f"🎯 TargetSpec: role={target_spec.by_role}, text={target_spec.by_text}")
    
    # Simuler plusieurs résolutions réussies
    submit_element = next(e for e in ui_elements if e.element_id == "btn_submit")
    fingerprint = TargetFingerprint(
        element_id=submit_element.element_id,
        bbox=tuple(submit_element.bbox),
        role=submit_element.role,
        etype=submit_element.type,
        label=submit_element.label,
        confidence=0.95
    )
    
    print("\n📚 Apprentissage - Enregistrement de 3 résolutions réussies...")
    for i in range(3):
        store.record_success(
            screen_signature=screen_sig,
            target_spec=target_spec,
            fingerprint=fingerprint,
            strategy_used="by_role",
            confidence=0.90 + i * 0.03  # Confiances variables
        )
        print(f"  ✅ Succès {i+1}/3 enregistré (confiance: {0.90 + i * 0.03:.2f})")
    
    # Test de lookup
    print("\n🔍 Test de lookup...")
    result = store.lookup(screen_sig, target_spec, min_success_count=2)
    
    if result:
        print(f"  ✅ Élément trouvé en mémoire!")
        print(f"     - Element ID: {result.element_id}")
        print(f"     - Role: {result.role}")
        print(f"     - Label: {result.label}")
        print(f"     - BBox: {result.bbox}")
        print(f"     - Confiance: {result.confidence:.3f}")
    else:
        print("  ❌ Aucun élément trouvé en mémoire")
    
    # Statistiques
    stats = store.get_stats()
    print(f"\n📊 Statistiques:")
    print(f"  - Entrées totales: {stats['total_entries']}")
    print(f"  - Succès totaux: {stats['total_successes']}")
    print(f"  - Échecs totaux: {stats['total_failures']}")
    print(f"  - Confiance moyenne: {stats['overall_confidence']:.3f}")
    print(f"  - Fichiers JSONL: {stats['jsonl_files_count']}")


def main():
    """Fonction principale de démonstration"""
    print("🚀 DÉMONSTRATION - Système d'apprentissage persistant RPA Vision V3")
    print("Fiche #18 - Architecture 'mix' (JSONL + SQLite)")
    print("Auteur: Dom, Alice Kiro - 22 décembre 2025")
    
    try:
        # Créer le répertoire de démonstration
        demo_dir = Path("data/learning_demo")
        demo_dir.mkdir(parents=True, exist_ok=True)
        
        # Exécuter les démonstrations
        demo_basic_learning()
        
        print("\n" + "="*60)
        print("✅ DÉMONSTRATION TERMINÉE AVEC SUCCÈS")
        print("="*60)
        print(f"📁 Données de démonstration sauvegardées dans: {demo_dir.absolute()}")
        print("🔍 Vous pouvez examiner les fichiers JSONL et la base SQLite générés")
        
    except Exception as e:
        logger.error(f"Erreur durant la démonstration: {e}", exc_info=True)
        print(f"\n❌ ERREUR: {e}")
        return 1
    
    return 0


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