# server_v1/visual_wait.py
"""
Module de patience visuelle pour le Stagiaire.
Permet d'attendre l'apparition d'un élément UI avant d'agir.
"""

import time
import logging
from pathlib import Path
from .vm_controller import VMController

# On suppose l'existence du moteur de vision dans core
# from core.vision.vlm_service import VLMService

logger = logging.getLogger("visual_wait")

class VisualWaitManager:
    def __init__(self, vm_controller: VMController):
        self.vm = vm_controller
        # self.vlm = VLMService()

    def wait_for_element(self, element_id: str, target_embedding, timeout: int = 30, threshold: float = 0.85):
        """
        Attend qu'un élément visuel soit détecté à l'écran de la VM.
        """
        logger.info(f"⏳ Patience visuelle : attente de '{element_id}'...")
        start_time = time.time()
        
        while (time.time() - start_time) < timeout:
            # 1. Capture de l'état actuel de la VM (via le flux vidéo/SPICE)
            # current_screen = self.vm.get_current_frame()
            
            # 2. Comparaison avec l'élément attendu (via l'IA)
            # score = self.vlm.compare(current_screen, target_embedding)
            score = 0.0 # Placeholder simulation
            
            if score >= threshold:
                logger.info(f"✅ Élément '{element_id}' détecté ! Score: {score}")
                return True
            
            logger.debug(f"   ... toujours en attente (score actuel: {score})")
            time.sleep(1) # On ne surcharge pas le GPU
            
        logger.warning(f"❌ Timeout : Élément '{element_id}' non trouvé après {timeout}s.")
        return False

    def wait_for_stable_screen(self, duration: float = 2.0, threshold: float = 0.98):
        """
        Attend que l'écran de la VM arrête de bouger (fin d'une animation ou chargement).
        """
        logger.info("⏳ Attente de stabilisation de l'écran...")
        # Logique de comparaison de hashs successifs
        time.sleep(duration)
        return True