#!/usr/bin/env python3
"""
Script pour relancer l'évaluation LightEval avec un timeout personnalisé
"""
import os
import sys
import argparse
import asyncio
from pathlib import Path
from datetime import datetime

# Importer la tâche d'évaluation
from tasks.evaluation_task import EvaluationTask, DEFAULT_EVALUATION_TIMEOUT


def log(message):
    """Affiche un message avec un timestamp"""
    print(f"[{datetime.now().strftime('%H:%M:%S')}] {message}")


async def main(session_id, dataset_name, timeout=None):
    """
    Relance l'évaluation avec un timeout personnalisé
    
    Args:
        session_id: ID de la session à traiter
        dataset_name: Nom du dataset à évaluer
        timeout: Timeout en secondes pour chaque évaluation de modèle (utilise la valeur par défaut si None)
    """
    # Vérifier que le dossier de session existe
    session_dir = Path(f"uploaded_files/{session_id}")
    if not session_dir.exists():
        log(f"Erreur: Le dossier de session {session_id} n'existe pas")
        return 1
    
    # Afficher le timeout utilisé
    timeout_value = timeout if timeout is not None else DEFAULT_EVALUATION_TIMEOUT
    log(f"Utilisation d'un timeout de {timeout_value} secondes pour l'évaluation")
    
    # Créer une nouvelle tâche d'évaluation avec le timeout spécifié
    log("Initialisation d'une nouvelle tâche d'évaluation")
    evaluation_task = EvaluationTask(
        session_uid=session_id,
        dataset_name=dataset_name,
        clean_old_results=True,  # Nettoyer automatiquement les anciens résultats
        timeout=timeout
    )
    
    # Exécuter l'évaluation
    log("Démarrage de l'évaluation...")
    await evaluation_task.run()
    
    # Vérifier les résultats
    if evaluation_task.is_completed:
        log("Évaluation terminée avec succès")
        # Trier les résultats par accuracy
        results_sorted = sorted(evaluation_task.results, key=lambda x: x.get('accuracy', 0), reverse=True)
        log(f"Résultats: {results_sorted}")
    else:
        log("L'évaluation n'a pas pu être terminée")
    
    return 0


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Relancer l'évaluation LightEval avec un timeout personnalisé")
    parser.add_argument("session_id", help="ID de la session à traiter")
    parser.add_argument("dataset_name", help="Nom du dataset à évaluer")
    parser.add_argument("--timeout", type=float, default=None, 
                        help=f"Timeout en secondes pour chaque évaluation de modèle (défaut: {DEFAULT_EVALUATION_TIMEOUT})")
    
    args = parser.parse_args()
    
    # Exécuter la fonction principale de manière asynchrone
    exit_code = asyncio.run(main(args.session_id, args.dataset_name, args.timeout))
    sys.exit(exit_code)