"""
Script para importar archivos HTML o DOCX y convertirlos a un archivo Markdown.
"""

import os
import sys
from pathlib import Path
import json
from utils.html_parser import procesar_html
from utils.markdown_handler import escribir_archivo_markdown
script_root = os.path.dirname(
    os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
)
sys.path.append(script_root)
from backend.script_utils import load_configuration

# Verificar si la biblioteca mammoth está disponible para procesamiento DOCX
try:
    from utils.docx_converter import procesar_docx
    DOCX_SUPPORT = True
except ImportError:
    DOCX_SUPPORT = False
    print("Nota: Soporte para DOCX no disponible. Instale mammoth para habilitar esta función.")

# Forzar UTF-8 en la salida estándar
try:
    sys.stdout.reconfigure(encoding="utf-8")
except AttributeError:
    # Para versiones anteriores de Python que no tienen reconfigure
    pass

# Definir símbolos de éxito/error sin caracteres especiales
SUCCESS_SYMBOL = "[OK]"
ERROR_SYMBOL = "[ERROR]"


def main():
    # Cargar configuraciones del entorno
    # configs = json.loads(os.environ.get("SCRIPT_CONFIGS", "{}"))
    configs = load_configuration()

    # Obtener working directory
    working_directory = configs.get("working_directory", ".")

    # Obtener configuraciones de nivel 2 (grupo)
    group_config = configs.get("level2", {})
    output_file = group_config.get("output_file", "contenido.md")
    attachments_dir = group_config.get("attachments_dir", "adjuntos")

    # Obtener directorio de salida (nivel 3)
    work_config = configs.get("level3", {})
    output_directory = work_config.get("output_directory", ".")

    # Construir rutas absolutas
    input_dir = (
        working_directory  # El directorio de trabajo es el directorio de entrada
    )
    output_path = os.path.join(output_directory, output_file)
    attachments_path = os.path.join(output_directory, attachments_dir)

    # Debug prints
    print(f"Working directory: {working_directory}")
    print(f"Input directory: {input_dir}")
    print(f"Output directory: {output_directory}")
    print(f"Output file: {output_path}")
    print(f"Attachments directory: {attachments_path}")

    # Asegurar que existen los directorios
    os.makedirs(attachments_path, exist_ok=True)

    # Verificar si el directorio de entrada existe
    input_path = Path(input_dir)
    if not input_path.exists():
        print(f"Error: Input directory {input_path} does not exist")
        return

    # Buscar archivos HTML y DOCX
    html_files = []
    docx_files = []
    
    # Buscar archivos HTML
    for ext in ["*.html", "*.htm"]:
        html_files.extend(list(input_path.glob(ext)))
    
    # Buscar archivos DOCX si el soporte está disponible
    if DOCX_SUPPORT:
        for ext in ["*.docx", "*.doc"]:
            docx_files.extend(list(input_path.glob(ext)))

    print(f"Found {len(html_files)} HTML files")
    if DOCX_SUPPORT:
        print(f"Found {len(docx_files)} DOCX files")

    if not html_files and not docx_files:
        print("No compatible files found in the input directory.")
        return

    # Procesar archivos
    paginas = []
    total_files = len(html_files) + len(docx_files)
    successful_files = 0
    failed_files = 0

    # Procesar archivos HTML
    for i, archivo in enumerate(html_files, 1):
        print(f"\nProcessing HTML [{i}/{total_files}] {archivo}")
        try:
            pagina = procesar_html(archivo, attachments_path)
            if pagina:
                paginas.append(pagina)
                # Verificar si hubo error al procesar
                if pagina.contenido.startswith("Error al procesar:"):
                    failed_files += 1
                    titulo_seguro = str(pagina.contenido).encode('ascii', 'replace').decode('ascii')
                    print(f"{ERROR_SYMBOL} Failed: {titulo_seguro}")
                else:
                    successful_files += 1
                    # Usar codificación ascii para evitar problemas de caracteres
                    titulo_seguro = str(pagina.titulo).encode('ascii', 'replace').decode('ascii')
                    print(f"{SUCCESS_SYMBOL} Success: {titulo_seguro}")
        except Exception as e:
            failed_files += 1
            print(f"{ERROR_SYMBOL} Error processing HTML file: {str(e)}")
    
    # Procesar archivos DOCX si el soporte está disponible
    if DOCX_SUPPORT:
        for i, archivo in enumerate(docx_files, len(html_files) + 1):
            print(f"\nProcessing DOCX [{i}/{total_files}] {archivo}")
            try:
                pagina = procesar_docx(archivo, attachments_path)
                if pagina:
                    paginas.append(pagina)
                    if pagina.contenido.startswith("Error al procesar:"):
                        failed_files += 1
                        titulo_seguro = str(pagina.contenido).encode('ascii', 'replace').decode('ascii')
                        print(f"{ERROR_SYMBOL} Failed: {titulo_seguro}")
                    else:
                        successful_files += 1
                        titulo_seguro = str(pagina.titulo).encode('ascii', 'replace').decode('ascii')
                        print(f"{SUCCESS_SYMBOL} Success: {titulo_seguro}")
            except Exception as e:
                failed_files += 1
                error_msg = str(e).encode('ascii', 'replace').decode('ascii')
                print(f"{ERROR_SYMBOL} Error processing DOCX file: {error_msg}")
                # Crear página con error
                from models.pagina_html import PaginaHTML
                error_pagina = PaginaHTML(
                    ruta_archivo=archivo, 
                    contenido=f"Error al procesar DOCX: {str(e)}"
                )
                paginas.append(error_pagina)

    # Escribir el archivo Markdown
    if paginas:
        print(f"\nSummary:")
        print(f"- Total files: {total_files}")
        print(f"- Successfully processed: {successful_files}")
        print(f"- Failed: {failed_files}")

        print(f"\nWriting {len(paginas)} pages to {output_path}")
        if escribir_archivo_markdown(paginas, output_path):
            print("Markdown file created successfully.")
        else:
            print("Error creating Markdown file.")
    else:
        print("No pages to write.")


if __name__ == "__main__":
    main()