#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Workflow d'analyse de tickets.
Ce module implémente le workflow pour analyser un ticket avec l'agent AgentTicketAnalyser.
"""

import os
import sys
import argparse
import json
import logging
import time
from typing import Dict, Any, Optional

# Import des factories
from tests.common.agent_factory import create_ticket_analyser
from tests.common.llm_factory import create_llm
from tests.common.ticket_utils import get_ticket_json, get_ticket_report_file

logger = logging.getLogger("TicketAnalyserWorkflow")

def execute_workflow(ticket_id: str, output_dir: str = "output", model: str = "mistral_large") -> Dict[str, Any]:
    """
    Exécute le workflow d'analyse de ticket.
    
    Args:
        ticket_id: Identifiant du ticket
        output_dir: Répertoire contenant les tickets
        model: Nom du modèle à utiliser pour l'analyse
    
    Returns:
        Dict avec les résultats du workflow
    """
    logger.info(f"Démarrage du workflow pour le ticket {ticket_id}")
    print(f"Démarrage du workflow pour le ticket {ticket_id}")
    
    workflow_start = time.time()
    
    # ÉTAPE 1: Initialiser le modèle LLM
    try:
        print(f"Initialisation du modèle {model}...")
        llm = create_llm(model)
        print(f"Modèle {model} initialisé avec succès")
    except Exception as e:
        logger.error(f"Erreur lors de l'initialisation du modèle: {e}")
        print(f"ERREUR: Impossible d'initialiser le modèle: {e}")
        return {"error": str(e), "stage": "init_llm"}
    
    # ÉTAPE 2: Initialiser l'agent
    try:
        print("Création de l'agent d'analyse de tickets...")
        agent = create_ticket_analyser(llm)
        print("Agent créé avec succès")
    except Exception as e:
        logger.error(f"Erreur lors de la création de l'agent: {e}")
        print(f"ERREUR: Impossible de créer l'agent: {e}")
        return {"error": str(e), "stage": "init_agent"}
    
    # ÉTAPE 3: Charger les données du ticket
    try:
        print("Chargement des données du ticket...")
        json_file, ticket_data = get_ticket_json(ticket_id, output_dir)
        
        if not json_file or not ticket_data:
            error_msg = f"Impossible de charger les données du ticket {ticket_id}"
            logger.error(error_msg)
            print(f"ERREUR: {error_msg}")
            return {"error": error_msg, "stage": "load_ticket"}
            
        print(f"Données du ticket chargées: {json_file}")
    except Exception as e:
        logger.error(f"Erreur lors du chargement du ticket: {e}")
        print(f"ERREUR: Impossible de charger le ticket: {e}")
        return {"error": str(e), "stage": "load_ticket"}
    
    # ÉTAPE 4: Analyser le ticket
    try:
        print("Analyse du ticket en cours...")
        analysis = agent.executer(ticket_data)
        print(f"Analyse du ticket terminée: {len(analysis) if analysis else 0} caractères")
    except Exception as e:
        logger.error(f"Erreur lors de l'analyse du ticket: {e}")
        print(f"ERREUR: Impossible d'analyser le ticket: {e}")
        return {"error": str(e), "stage": "analyse_ticket", "ticket_data": ticket_data}
    
    # Calcul du temps total d'exécution
    workflow_time = time.time() - workflow_start
    print(f"Workflow terminé en {workflow_time:.2f} secondes")
    
    # Retourner les résultats
    return {
        "ticket_id": ticket_id,
        "model": model,
        "ticket_data": ticket_data,
        "analysis": analysis,
        "execution_time": workflow_time
    }

def main():
    # Configuration de l'analyseur d'arguments
    parser = argparse.ArgumentParser(description="Exécuter le workflow d'analyse de tickets")
    parser.add_argument("ticket_id", help="ID du ticket à analyser (ex: T1234)")
    parser.add_argument("--output_dir", default="output", help="Répertoire de sortie contenant les tickets")
    parser.add_argument("--model", default="mistral_large", help="Modèle LLM à utiliser")
    parser.add_argument("--verbose", "-v", action="store_true", help="Mode verbeux")
    parser.add_argument("--save", action="store_true", help="Sauvegarder les résultats dans un fichier JSON")
    
    # Analyser les arguments
    args = parser.parse_args()
    
    # Configurer le logging
    log_level = logging.DEBUG if args.verbose else logging.INFO
    logging.basicConfig(
        level=log_level,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler(f"ticket_analyser_{args.ticket_id}.log"),
            logging.StreamHandler()
        ]
    )
    
    # Exécuter le workflow
    results = execute_workflow(args.ticket_id, args.output_dir, args.model)
    
    # Afficher un résumé des résultats
    if "error" in results:
        print(f"\nErreur lors de l'exécution du workflow: {results['error']}")
        print(f"Étape en échec: {results.get('stage', 'inconnue')}")
        return 1
    
    print("\nRésumé du workflow:")
    print(f"Ticket: {results['ticket_id']}")
    print(f"Modèle: {results['model']}")
    print(f"Taille de l'analyse: {len(results['analysis']) if results['analysis'] else 0} caractères")
    print(f"Temps d'exécution: {results['execution_time']:.2f} secondes")
    
    # Sauvegarder les résultats si demandé
    if args.save:
        results_dir = os.path.join("results", args.ticket_id)
        os.makedirs(results_dir, exist_ok=True)
        
        results_file = os.path.join(results_dir, f"ticket_analysis_{args.model}.json")
        
        save_results = {
            "ticket_id": results["ticket_id"],
            "model": results["model"],
            "analysis": results["analysis"],
            "execution_time": results["execution_time"],
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
        }
        
        with open(results_file, "w", encoding="utf-8") as f:
            json.dump(save_results, f, ensure_ascii=False, indent=2)
            
        print(f"Résultats sauvegardés dans: {results_file}")
    
    return 0

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