#!/usr/bin/env python3
"""
cli.py — Wrapper de MarkItDown para swl-ses

Convierte cualquier archivo o URL soportado a Markdown limpio.
Diseñado para ser invocado por agentes SWL vía Bash tool.

Uso:
    python cli.py <ruta_o_url>             → imprime Markdown en stdout
    python cli.py <ruta_o_url> --title     → imprime título en stderr
    python cli.py --check                  → verifica dependencias instaladas
    python cli.py --formats                → lista formatos disponibles

Códigos de salida:
    0 → conversión exitosa
    1 → formato no soportado (UnsupportedFormatException)
    2 → dependencia faltante para ese formato (MissingDependencyException)
    3 → error de conversión (FileConversionException)
    4 → archivo no encontrado / URL inaccesible

Para SWL agents — detectar éxito:
    OUTPUT=$(python cli.py documento.xlsx 2>/dev/null) && [ -n "$OUTPUT" ]
"""

import sys
import os

# Compatibilidad con Windows paths en bash
# Git bash convierte /d/... a D:\..., pero markitdown necesita Windows paths
def normalize_path(path: str) -> str:
    """Normaliza paths de bash para Windows si es necesario."""
    if sys.platform == "win32" and path.startswith("/") and len(path) > 2 and path[2] == "/":
        # Patrón /d/... → D:/...
        drive = path[1].upper()
        rest = path[2:]
        return f"{drive}:{rest}"
    return path


def check_dependencies() -> dict:
    """Verifica qué dependencias opcionales están instaladas."""
    core = {}
    optional = {}

    # Core (requeridas)
    for pkg in ["bs4", "requests", "markdownify", "magika", "charset_normalizer", "defusedxml"]:
        try:
            __import__(pkg)
            core[pkg] = True
        except ImportError:
            core[pkg] = False

    # Opcionales por formato
    format_deps = {
        "pdf": ["pdfminer", "pdfplumber"],
        "docx": ["mammoth", "lxml"],
        "xlsx/xls": ["pandas", "openpyxl"],
        "pptx": ["pptx"],
        "youtube": ["youtube_transcript_api"],
    }

    for fmt, pkgs in format_deps.items():
        available = []
        for pkg in pkgs:
            try:
                __import__(pkg)
                available.append(pkg)
            except ImportError:
                pass
        optional[fmt] = len(available) == len(pkgs)

    return {"core": core, "formats": optional}


def print_check():
    """Imprime diagnóstico de dependencias instaladas."""
    deps = check_dependencies()

    all_core_ok = all(deps["core"].values())
    print(f"markitdown — diagnóstico de dependencias")
    print(f"Core: {'OK' if all_core_ok else 'INCOMPLETO'}")
    for pkg, ok in deps["core"].items():
        mark = "[OK]" if ok else "[--]"
        print(f"  {mark} {pkg}")

    print("\nFormatos opcionales:")
    for fmt, ok in deps["formats"].items():
        mark = "[OK]" if ok else "[--]"
        print(f"  {mark} {fmt}")

    if all_core_ok:
        print("\nEstado: listo para conversión")
        return 0
    else:
        print("\nEstado: dependencias core faltantes — ejecutar:")
        print("  pip install markitdown[pdf,docx,pptx,xlsx]")
        return 2


def print_formats():
    """Imprime formatos soportados según dependencias instaladas."""
    deps = check_dependencies()

    formats = [
        ("Siempre disponibles", [
            ".html / .htm", ".txt / .md", ".csv", ".json",
            ".xml / .rss / .atom", ".zip (recursivo)", ".ipynb (Jupyter)",
            ".epub", "URLs YouTube (transcripciones)", "URLs Wikipedia",
        ]),
        ("PDF (requiere: pdfminer, pdfplumber)", [".pdf"]),
        ("Word (requiere: mammoth, lxml)", [".docx"]),
        ("Excel (requiere: pandas, openpyxl)", [".xlsx", ".xls"]),
        ("PowerPoint (requiere: python-pptx)", [".pptx"]),
    ]

    for categoria, fmts in formats:
        print(f"\n{categoria}:")
        for f in fmts:
            print(f"  {f}")


def main():
    args = sys.argv[1:]

    if not args or args[0] in ("-h", "--help"):
        print(__doc__)
        return 0

    if args[0] == "--check":
        return print_check()

    if args[0] == "--formats":
        print_formats()
        return 0

    show_title = "--title" in args
    source_args = [a for a in args if not a.startswith("--")]

    if not source_args:
        print("Error: se requiere una ruta o URL", file=sys.stderr)
        return 4

    source = source_args[0]

    # Normalizar path Windows si estamos en bash
    if not source.startswith(("http://", "https://", "data:", "file:")):
        source = normalize_path(source)
        if not os.path.exists(source):
            print(f"Error: archivo no encontrado: {source}", file=sys.stderr)
            return 4

    try:
        from markitdown import (
            MarkItDown,
            UnsupportedFormatException,
            FileConversionException,
            MissingDependencyException,
        )
    except ImportError:
        print("Error: markitdown no está instalado.", file=sys.stderr)
        print("Ejecutar: pip install markitdown[pdf,docx,pptx,xlsx]", file=sys.stderr)
        return 2

    md = MarkItDown()

    try:
        result = md.convert(source)

        if show_title and result.title:
            print(f"TITLE: {result.title}", file=sys.stderr)

        print(result.markdown)
        return 0

    except UnsupportedFormatException as e:
        print(f"Formato no soportado: {e}", file=sys.stderr)
        return 1

    except MissingDependencyException as e:
        print(f"Dependencia faltante: {e}", file=sys.stderr)
        print("Ver: python cli.py --check", file=sys.stderr)
        return 2

    except FileConversionException as e:
        print(f"Error de conversión: {e}", file=sys.stderr)
        return 3

    except Exception as e:
        print(f"Error inesperado: {type(e).__name__}: {e}", file=sys.stderr)
        return 3


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