#!/usr/bin/env python3
import os
import sys
import json
import logging
import argparse
from datetime import datetime
from .auth_manager import AuthManager
from .ticket_manager import TicketManager
from core.utils import setup_logging, log_separator

def retrieve_ticket(ticket_code, output=None, config_file="config.json", verbose=False):
    config = load_config(config_file)
    
    # Si config est vide, initialiser avec des valeurs par défaut
    if not config:
        logging.error("Impossible de charger la configuration, utilisation des valeurs par défaut")
        config = {"odoo": {}, "output_dir": "output"}
    
    # Configurer la journalisation
    log_level = logging.DEBUG if verbose else logging.INFO
    setup_logging(log_level, "retrieve_ticket.log")
    
    # Extraire les informations de connexion
    odoo_config = config.get("odoo", {})
    url = odoo_config.get("url")
    db = odoo_config.get("db")
    username = odoo_config.get("username")
    api_key = odoo_config.get("api_key")
    
    if not all([url, db, username, api_key]):
        logging.error("Informations de connexion Odoo manquantes dans le fichier de configuration")
        return None
    
    # Définir le répertoire de sortie
    output_dir = output or os.path.join(config.get("output_dir", "output"), f"ticket_{ticket_code}")
    
    # Créer le répertoire de sortie spécifique au ticket
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    ticket_dir = os.path.join(output_dir, f"{ticket_code}_{timestamp}")
    os.makedirs(ticket_dir, exist_ok=True)
    
    logging.info(f"Extraction du ticket {ticket_code}")
    log_separator()
    
    try:
        # Initialiser les gestionnaires
        auth_manager = AuthManager(
            url=url,
            db=db,
            username=username,
            api_key=api_key
        )
        
        if not auth_manager.login():
            logging.error("Échec de l'authentification à Odoo")
            return None
        
        # Extraire les données du ticket
        ticket_manager = TicketManager(auth_manager)
        result = ticket_manager.extract_ticket_data(ticket_code, ticket_dir)
        
        if not result:
            logging.error(f"Échec de l'extraction du ticket {ticket_code}")
            return None
        
        # Afficher le résumé
        log_separator()
        logging.info(f"Extraction terminée avec succès")
        logging.info(f"Ticket: {ticket_code}")
        logging.info(f"Répertoire: {ticket_dir}")
        logging.info(f"Messages traités: {result.get('messages_count', 0)}")
        logging.info(f"Pièces jointes: {result.get('attachments_count', 0)}")
        log_separator()
        
        # Générer un rapport de fin
        summary = {
            "timestamp": timestamp,
            "ticket_code": ticket_code,
            "output_directory": ticket_dir,
            "message_count": result.get("messages_count", 0),
            "attachment_count": result.get("attachments_count", 0),
            "files_created": [
                os.path.basename(result.get("ticket_info", "")),
                os.path.basename(result.get("ticket_summary", "")),
                os.path.basename(result.get("messages_file", "")),
                os.path.basename(result.get("ticket_data_file", ""))
            ]
        }
        
        summary_path = os.path.join(ticket_dir, "extraction_summary.json")
        with open(summary_path, 'w', encoding='utf-8') as f:
            json.dump(summary, f, indent=2, ensure_ascii=False)
            
        print(f"\nExtraction du ticket {ticket_code} terminée avec succès.")
        print(f"Les données ont été sauvegardées dans: {ticket_dir}")
        
        return ticket_dir
        
    except Exception as e:
        logging.exception(f"Une erreur est survenue: {e}")
        return None

def parse_arguments():
    parser = argparse.ArgumentParser(description="Récupère un ticket Odoo par son code et extrait ses données.")
    parser.add_argument("ticket_code", help="Code du ticket à extraire")
    parser.add_argument("--output", "-o", help="Répertoire de sortie", default=None)
    parser.add_argument("--config", "-c", help="Fichier de configuration", default="config.json")
    parser.add_argument("--verbose", "-v", action="store_true", help="Mode verbeux")
    return parser.parse_args()

def load_config(config_file):
    try:
        with open(config_file, 'r') as f:
            return json.load(f)
    except Exception as e:
        logging.error(f"Erreur lors du chargement du fichier de configuration: {e}")
        return {}

def main():
    args = parse_arguments()
    result = retrieve_ticket(
        ticket_code=args.ticket_code,
        output=args.output,
        config_file=args.config,
        verbose=args.verbose
    )
    
    if not result:
        sys.exit(1)

if __name__ == "__main__":
    main()