#!/usr/bin/env python3
"""
Script pour nettoyer les anciens résultats d'évaluation et relancer LightEval
"""
import os
import sys
import shutil
import argparse
import asyncio
from pathlib import Path
from datetime import datetime

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


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, threshold=None):
    """
    Nettoie les anciens résultats et relance l'évaluation
    
    Args:
        session_id: ID de la session à traiter
        dataset_name: Nom du dataset à évaluer
        threshold: Seuil optionnel pour l'analyse des sentiments (positive_count - negative_count)
    """
    # 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

    # Chemin vers les résultats LightEval
    results_dir = session_dir / "lighteval_results"
    
    # Suppression des anciens résultats
    if results_dir.exists():
        log(f"Suppression de l'ancien dossier de résultats: {results_dir}")
        shutil.rmtree(results_dir)
        log("Nettoyage terminé")
    
    # Si un seuil est spécifié, modifier le config yaml pour le sentiment analysis
    if threshold is not None:
        # Chemin du module lighteval_task
        lighteval_task_path = Path("lighteval_task/lighteval_task.py")
        
        # Modifier le module uniquement s'il existe
        if lighteval_task_path.exists():
            log(f"Ajustement du seuil d'analyse de sentiment à {threshold}")
            
            # Lire le contenu
            with open(lighteval_task_path, 'r', encoding='utf-8') as file:
                content = file.read()
            
            # Remplacer le seuil dans la code
            content = content.replace(
                "pos_count > neg_count + 2",  # Seuil par défaut
                f"pos_count > neg_count + {threshold}"
            )
            content = content.replace(
                "neg_count > pos_count + 2",  # Seuil par défaut
                f"neg_count > pos_count + {threshold}"
            )
            
            # Écrire le fichier modifié
            with open(lighteval_task_path, 'w', encoding='utf-8') as file:
                file.write(content)
            
            log(f"Seuil d'analyse de sentiment ajusté à {threshold}")
    
    # Créer une nouvelle tâche d'évaluation
    log("Initialisation d'une nouvelle tâche d'évaluation")
    evaluation_task = EvaluationTask(session_id, dataset_name)
    
    # Exécuter l'évaluation
    log("Démarrage de l'évaluation...")
    await evaluation_task.run(clean_first=True)
    
    # 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="Nettoyage et relance d'évaluation LightEval")
    parser.add_argument("session_id", help="ID de la session à nettoyer et réévaluer")
    parser.add_argument("--dataset", "-d", dest="dataset_name", 
                        help="Nom du dataset à évaluer (par défaut: basé sur l'ID de session)")
    parser.add_argument("--threshold", "-t", dest="threshold", type=int, default=None,
                       help="Seuil pour l'analyse des sentiments (différence entre mots positifs et négatifs)")
    
    args = parser.parse_args()
    
    # Si le nom du dataset n'est pas fourni, le construire à partir de l'ID de session
    if not args.dataset_name:
        args.dataset_name = f"yourbench/yourbench_{args.session_id}"
    
    # Exécuter la fonction principale de manière asynchrone
    exit_code = asyncio.run(main(args.session_id, args.dataset_name, args.threshold))
    sys.exit(exit_code)