# 🎮 Système de Rejeu de Tâches

## Vue d'ensemble

Le système de rejeu permet de **rejouer automatiquement des tâches apprises** en utilisant la reconnaissance visuelle pour localiser les éléments d'interface, même si leur position a changé.

## Architecture

```
TaskReplayEngine
├── Chargement de tâche (load_task)
├── Recherche visuelle (find_element_visually)
│   ├── Capture d'écran
│   ├── Génération d'embeddings
│   └── Recherche par similarité
├── Exécution d'action (execute_action_at_location)
│   ├── Click
│   ├── Type
│   ├── Scroll
│   └── Drag
└── Monitoring en temps réel
```

## Fonctionnalités

### 1. Rejeu Basique

```python
from core.task_replay import TaskReplayEngine

# Rejouer une tâche
results = await replay_engine.replay_task(
    task_id="task_fc1d3e52",
    interactive=False
)

print(f"Succès: {results['success']}")
print(f"Actions exécutées: {results['executed_actions']}")
```

### 2. Rejeu avec Monitoring

```python
def on_step_completed(step_result):
    print(f"Étape {step_result['step']}: {step_result['status']}")

results = await replay_engine.replay_task_with_monitoring(
    task_id="task_fc1d3e52",
    on_step_completed=on_step_completed
)
```

### 3. Liste des Tâches Disponibles

```python
tasks = replay_engine.list_available_tasks()

for task in tasks:
    print(f"{task['task_name']}: {task['observation_count']} observations")
```

## Reconnaissance Visuelle

### Recherche par Grille

Le système divise l'écran en grille et recherche l'élément dans chaque cellule :

```python
# Grille 4x4 par défaut
grid_size = 4

# Pour chaque cellule :
# 1. Extraire la région
# 2. Générer l'embedding CLIP
# 3. Calculer la similarité avec l'embedding cible
# 4. Retourner les meilleures correspondances
```

### Seuil de Similarité

```yaml
replay:
  similarity_threshold: 0.75  # Minimum pour accepter une correspondance
  max_search_attempts: 3      # Nombre de tentatives
```

## Types d'Actions Supportées

| Type | Description | Paramètres |
|------|-------------|------------|
| `click` | Clic souris | x, y, button |
| `type` | Saisie texte | text, interval |
| `scroll` | Défilement | direction, amount |
| `drag` | Glisser-déposer | start_x, start_y, end_x, end_y |

## Gestion des Variations d'Interface

### Adaptation Automatique

Le système s'adapte aux changements :

1. **Position différente** : Recherche visuelle localise l'élément
2. **Taille différente** : Utilise le centre de la région trouvée
3. **Style différent** : L'embedding CLIP capture la sémantique

### Retry et Fallback

```python
# Retry automatique si élément non trouvé
max_search_attempts = 3

# Délai entre tentatives
retry_delay = 0.5  # secondes
```

## Mode Interactif

En mode interactif, le système demande confirmation avant chaque action :

```python
results = await replay_engine.replay_task(
    task_id="task_fc1d3e52",
    interactive=True  # Demande confirmation
)
```

## Résultats du Rejeu

```python
{
    "task_id": "task_fc1d3e52",
    "success": True,
    "total_actions": 3,
    "executed_actions": 3,
    "failed_actions": 0,
    "actions": [
        {
            "step": 1,
            "success": True,
            "location": {
                "x": 640,
                "y": 360,
                "confidence": 0.89,
                "bbox": [600, 340, 680, 380]
            },
            "action_type": "click"
        },
        # ...
    ]
}
```

## Logging

Tous les événements sont loggés :

```python
# Démarrage du rejeu
{"action": "task_replay_started", "task_id": "...", "interactive": False}

# Élément trouvé
{"action": "element_found", "similarity": 0.89, "attempt": 1}

# Élément non trouvé
{"action": "element_not_found", "step": 2, "signature": "..."}

# Rejeu terminé
{"action": "task_replay_completed", "success": True, "executed": 3, "failed": 0}
```

## Utilisation avec le CLI

```bash
# Lister les tâches disponibles
python test_task_replay.py

# Le script vous guidera pour :
# 1. Voir les tâches disponibles
# 2. Choisir une tâche
# 3. Rejouer avec monitoring en temps réel
```

## Exemple Complet

```python
import asyncio
from core.task_replay import TaskReplayEngine
from core.learning_manager import LearningManager
from core.embeddings_manager import EmbeddingsManager
from core.utils.vision_utils import VisionUtils
from core.utils.input_utils import InputUtils
from core.logger import Logger
from core.config import load_config

async def replay_example():
    # Initialiser
    config = load_config()
    logger = Logger(config)
    embeddings_manager = EmbeddingsManager(logger, config)
    learning_manager = LearningManager(embeddings_manager, logger, config)
    vision_utils = VisionUtils(logger, config)
    input_utils = InputUtils(logger, config)
    
    replay_engine = TaskReplayEngine(
        learning_manager,
        embeddings_manager,
        vision_utils,
        input_utils,
        logger,
        config
    )
    
    # Lister les tâches
    tasks = replay_engine.list_available_tasks()
    print(f"Tâches disponibles: {len(tasks)}")
    
    # Rejouer la première tâche
    if tasks:
        task_id = tasks[0]['task_id']
        results = await replay_engine.replay_task(task_id)
        
        if results['success']:
            print("✅ Tâche rejouée avec succès!")
        else:
            print(f"❌ Échec: {results['failed_actions']} actions échouées")

# Exécuter
asyncio.run(replay_example())
```

## Limitations Actuelles

1. **Recherche par grille** : Peut manquer des petits éléments entre les cellules
2. **Pas de détection d'objets** : Utilise uniquement CLIP pour la similarité
3. **Mode interactif basique** : Pas d'interface graphique pour la confirmation

## Améliorations Futures

- [ ] Recherche multi-échelle (grilles de différentes tailles)
- [ ] Intégration avec OWL-v2 pour détection précise
- [ ] Interface graphique pour le mode interactif
- [ ] Gestion des erreurs avec rollback automatique
- [ ] Support des actions conditionnelles
- [ ] Rejeu parallèle de plusieurs tâches

## Configuration

```yaml
replay:
  similarity_threshold: 0.75      # Seuil de similarité minimum
  max_search_attempts: 3          # Tentatives de recherche
  delay_between_actions: 0.5      # Délai entre actions (secondes)
  grid_size: 4                    # Taille de la grille de recherche
```

## Dépendances

- `numpy` : Calculs d'embeddings
- `PIL` : Manipulation d'images
- `pyautogui` : Capture d'écran et contrôle souris/clavier
- `asyncio` : Exécution asynchrone

## Tests

```bash
# Test complet avec interface interactive
python test_task_replay.py

# Test programmatique
python -c "
import asyncio
from test_task_replay import test_list_tasks
asyncio.run(test_list_tasks())
"
```