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

"""
Script pour extraire toutes les images d'un ticket Odoo.
Ce script combine l'extracteur d'images standard et l'extracteur d'images HTML.
"""

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

# Importer les extracteurs
from .html_image_extractor import extract_images_from_ticket
from .extract_all_images import enhance_ticket_data_with_images

def setup_logging(verbose: bool = False) -> None:
    """
    Configure la journalisation.
    
    Args:
        verbose: Mode verbeux pour plus de détails
    """
    level = logging.DEBUG if verbose else logging.INFO
    logging.basicConfig(
        level=level,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )

def extract_ticket_images(ticket_dir: str, output_file: Optional[str] = None, verbose: bool = False) -> Dict[str, Any]:
    """
    Extrait toutes les images d'un ticket Odoo.
    
    Args:
        ticket_dir: Répertoire du ticket
        output_file: Fichier de sortie pour les résultats (optionnel)
        verbose: Mode verbeux pour plus de détails
        
    Returns:
        Dictionnaire avec les résultats de l'extraction
    """
    setup_logging(verbose)
    
    if not os.path.exists(ticket_dir):
        logging.error(f"Répertoire introuvable: {ticket_dir}")
        return {"status": "error", "message": "Répertoire introuvable"}
    
    logging.info(f"Analyse des images pour le ticket dans: {ticket_dir}")
    
    # Charger les données du ticket
    ticket_summary_path = os.path.join(ticket_dir, "ticket_summary.json")
    attachments_info_path = os.path.join(ticket_dir, "attachments_info.json")
    
    ticket_data = {"ticket_dir": ticket_dir}
    
    # Charger les données du ticket si disponibles
    if os.path.exists(ticket_summary_path):
        try:
            with open(ticket_summary_path, 'r', encoding='utf-8') as f:
                ticket_data["ticket_summary"] = json.load(f)
                logging.info("Données du ticket chargées")
        except Exception as e:
            logging.error(f"Erreur lors du chargement des données du ticket: {e}")
    
    # Charger les pièces jointes si disponibles
    if os.path.exists(attachments_info_path):
        try:
            with open(attachments_info_path, 'r', encoding='utf-8') as f:
                ticket_data["attachments"] = json.load(f)
                logging.info(f"Pièces jointes chargées: {len(ticket_data['attachments'])}")
        except Exception as e:
            logging.error(f"Erreur lors du chargement des pièces jointes: {e}")
    
    # Enrichir les données avec toutes les images
    try:
        enhanced_data = enhance_ticket_data_with_images(ticket_data)
        logging.info(f"Images identifiées: {enhanced_data.get('images_count', 0)}")
        
        # Préparer les résultats
        result = {
            "status": "success",
            "ticket_dir": ticket_dir,
            "images": enhanced_data.get("images", []),
            "standard_images": enhanced_data.get("standard_images", []),
            "embedded_images": enhanced_data.get("embedded_images", []),
            "stats": enhanced_data.get("images_stats", {})
        }
        
        # Ajouter les informations du ticket si disponibles
        if "ticket_summary" in enhanced_data:
            ticket_summary = enhanced_data["ticket_summary"]
            result["ticket_code"] = ticket_summary.get("code", "")
            result["ticket_name"] = ticket_summary.get("name", "")
        
        # Sauvegarder les résultats si un fichier de sortie est spécifié
        if output_file:
            output_dir = os.path.dirname(output_file)
            if output_dir and not os.path.exists(output_dir):
                os.makedirs(output_dir, exist_ok=True)
                
            with open(output_file, 'w', encoding='utf-8') as f:
                json.dump(result, f, indent=2, ensure_ascii=False)
            logging.info(f"Résultats sauvegardés dans: {output_file}")
        else:
            # Utiliser un fichier de sortie par défaut dans le répertoire du ticket
            default_output = os.path.join(ticket_dir, "all_images.json")
            with open(default_output, 'w', encoding='utf-8') as f:
                json.dump(result, f, indent=2, ensure_ascii=False)
            logging.info(f"Résultats sauvegardés dans: {default_output}")
        
        return result
        
    except Exception as e:
        logging.exception(f"Erreur lors de l'extraction des images: {e}")
        return {"status": "error", "message": str(e)}

def parse_arguments():
    """
    Parse les arguments de la ligne de commande.
    
    Returns:
        Arguments parsés
    """
    parser = argparse.ArgumentParser(description="Extrait toutes les images d'un ticket Odoo.")
    parser.add_argument("ticket_dir", help="Répertoire du ticket")
    parser.add_argument("--output", "-o", help="Fichier de sortie pour les résultats")
    parser.add_argument("--verbose", "-v", action="store_true", help="Mode verbeux pour plus de détails")
    return parser.parse_args()

def main():
    """
    Point d'entrée principal.
    """
    args = parse_arguments()
    
    result = extract_ticket_images(
        ticket_dir=args.ticket_dir,
        output_file=args.output,
        verbose=args.verbose
    )
    
    # Afficher un résumé des résultats
    if result["status"] == "success":
        stats = result.get("stats", {})
        print("\nStatistiques des images:")
        print(f"  Total: {stats.get('total', 0)}")
        print(f"  Standard: {stats.get('standard', 0)}")
        print(f"  Intégrées: {stats.get('embedded', 0)}")
        
        # Afficher les chemins des images
        if args.verbose:
            print("\nImages standard:")
            for img in result.get("standard_images", []):
                print(f"  {img}")
            
            print("\nImages intégrées dans le HTML:")
            for img in result.get("embedded_images", []):
                print(f"  {img}")
    else:
        print(f"Erreur: {result.get('message', 'Erreur inconnue')}")
        sys.exit(1)

if __name__ == "__main__":
    main()