from odoo_connection import OdooConnection
import os
import json
from utils import save_json, ensure_export_directory, print_error
from config import EXPORT_DIR
from data_filter import filter_ticket_data

class TicketManager:
    """Gestionnaire de tickets simplifié avec seulement les fonctionnalités essentielles"""
    
    def __init__(self):
        """Initialise le gestionnaire de tickets"""
        self.conn = OdooConnection()
        self.odoo = self.conn.get_odoo_instance()
        self.model_name = "project.task"
    
    def _ensure_connection(self):
        """Vérifie et établit la onnexion si nécessaire"""
        if not self.odoo:
            self.odoo = self.conn.get_odoo_instance()
        return self.odoo is not None
    
    def _safe_execute(self, model, method, *args):
        """ 
        Exécute une méthode Odoo en toute sécurité via odoorpc.
        Vérifie la connexion avant d'exécuter.
        """
        # Vérifier que la connexion est bien établie
        if not self._ensure_connection():
            print_error("Connexion Odoo indisponible.")
            return None

        try:
            # Exécuter la méthode sur le modèle via OdooRPC
            return self.odoo.execute(model, method, *args) # type: ignore

        except odoorpc.error.RPCError as e: # type: ignore
            print_error(f" Erreur RPC lors de '{method}' sur '{model}': {e}")
            return None
        except Exception as e:
            print_error(f" Erreur inattendue lors de '{method}' sur '{model}': {e}")
            return None
        
    def save_raw_ticket_data(self, ticket_data, filename="raw_ticket_data.json"):
        """Sauvegarde les données brutes du ticket dans un fichier JSON"""
        file_path = os.path.join(EXPORT_DIR, filename)
        with open(file_path, "w", encoding="utf-8") as f:
            json.dump(ticket_data, f, indent=4, ensure_ascii=False)
        print(f"Données brutes du ticket sauvegardées dans : {file_path}")
        
    def get_ticket_by_id(self, ticket_id):
        """ Récupère les détails d'un ticket par son ID et applique le filtre """
        fields_to_read = ['id', 'name', 'code', 'stage_id', 'project_id', 'date_deadline', 'description', 'message_ids']
   
        # Récupérer les données du ticket
        ticket_data = self._safe_execute(self.model_name, 'read', [ticket_id], fields_to_read)

        if not ticket_data:
            print_error(f"Aucun ticket trouvé avec l'ID {ticket_id}")
            return None

        # Sauvegarde des données brutes pour analyse
        self.save_raw_ticket_data(ticket_data, f"ticket_{ticket_id}_raw.json")
        # Nettoyer et filtrer les données du ticket
        #return filter_ticket_data(ticket_data[0])  # Utilisation de data_filter.py

    def get_ticket_by_code(self, ticket_code):
        """Récupérer un ticket via son code"""
        domain = [('code', '=', ticket_code)]
        ticket_ids = self._safe_execute(self.model_name, 'search', domain, 0, 1)
        if not ticket_ids:
            print_error(f"Aucun ticket trouvé avec le code '{ticket_code}'.")
            return None
        
        # Sauvegarde des données brutes pour analyse
        self.save_raw_ticket_data(ticket_ids, f"ticket_{ticket_code}_raw.json")
        
        return self.get_ticket_by_id(ticket_ids[0])       
  
    def get_available_projects(self):
        """Retourne la liste des projets disponibles"""
        projects = self._safe_execute('project.project', 'search_read', [], ['id', 'name'])
        if not projects:
            print_error("Aucun projet trouvé.")
            return {}
        return {proj['id']: proj['name'] for proj in projects}
    
    def export_tickets_by_project_and_stage(self, project_id):
        """ Exporte les tickets d'un projet classés par étape """

        # Vérifier la connexion Odoo
        if not self._ensure_connection():
            print_error("Connexion Odoo indisponible.")
            return
        
        # Récupérer les tickets du projet
        domain = [('project_id', '=', project_id)]
        ticket_ids = self._safe_execute(self.model_name, 'search', domain, 0, 1000)
        if not ticket_ids:
            print_error(f"Aucun ticket trouvé pour le projet {project_id}.")
            return
        
        # Lire les détails des tickets
        tickets = []
        for ticket_id in ticket_ids:
            ticket = self.get_ticket_by_id(ticket_id)
            if ticket:
                tickets.append(ticket)
        
        #trier les tickets par étape
        tickets_by_stage = {}
        for ticket in tickets:
            champs_relationnels = ticket.get("Champs Relationnels", {})
            stage_data = champs_relationnels.get("stage_id", [0, "Non classé"])
            stage_id = stage_data[0] if isinstance(stage_data, list) and len(stage_data) > 0 else 0
            stage_name = stage_data[1] if isinstance(stage_data, list) and len(stage_data) > 1 else "Non classé"
            
            key = f"{stage_id}_{stage_name}"
            tickets_by_stage.setdefault(key, []).append(ticket)
            
        # Sauvegarde des fichiers
        project_dir = ensure_export_directory(f"project_{project_id}")
        for stage_key, stage_tickets in tickets_by_stage.items():
            stage_dir = os.path.join(project_dir, stage_key)
            os.makedirs(stage_dir, exist_ok=True)
            save_json(os.path.join(stage_dir, "all_tickets.json"), stage_tickets)
            
        print(f"Exportation terminée. Les fichiers sont enregistrés dans : {project_dir}/")