api_web.py

"""
API Python expuesta a la interfaz web vía pywebview (OperaMar).

Puente JS ↔ motor_web: datos ERA5, análisis de ventanas operacionales y
exportación Excel/CSV/informe.
"""

import json
import queue
import threading
from pathlib import Path

import webview

import io_era5
import motor_web
import sistema


class Api:
    """Puente JS ↔ motor de OperaMar."""

    def __init__(self):
        self._window = None
        self._busy = False
        self._lock = threading.Lock()
        self._eventos = queue.Queue()

    def set_window(self, window):
        self._window = window

    # ------------------------------------------------------------------ eventos
    def _emit(self, event, data):
        """Encola evento para el hilo GUI (poll_eventos desde JS)."""
        self._eventos.put({"event": event, "data": data})

    def poll_eventos(self):
        """Drena la cola de eventos hacia la UI (llamar periódicamente desde JS)."""
        enviados = 0
        while self._window:
            try:
                item = self._eventos.get_nowait()
            except queue.Empty:
                break
            payload = json.dumps(item, ensure_ascii=False)
            try:
                self._window.evaluate_js(f"window.dispatchPyEvent({payload})")
                enviados += 1
            except Exception:
                self._eventos.put(item)
                break
        return {"ok": True, "n": enviados}

    def _parse_json(self, val, etiqueta="payload"):
        if isinstance(val, dict):
            return val
        if isinstance(val, list):
            return val
        try:
            return json.loads(val)
        except (json.JSONDecodeError, TypeError) as exc:
            raise ValueError(f"{etiqueta} JSON inválido.") from exc

    def _error_tarea(self, exc):
        """Mensaje seguro para la UI (sin rutas ni trazas internas)."""
        if isinstance(exc, ValueError):
            return str(exc)
        return exc.__class__.__name__

    def _run_task(self, task_id, func):
        with self._lock:
            if self._busy:
                return {"ok": False, "error": "Ya hay una tarea en curso."}
            self._busy = True

        def worker():
            try:
                result = func()
                self._emit("task_done", {"id": task_id, "ok": True, "result": result})
            except Exception as exc:
                self._emit("task_done", {
                    "id": task_id, "ok": False,
                    "error": self._error_tarea(exc),
                })
            finally:
                with self._lock:
                    self._busy = False

        self._emit("task_start", {"id": task_id})
        threading.Thread(target=worker, daemon=True).start()
        return {"ok": True}

    def _ventana(self):
        return self._window or webview.active_window()

    # ------------------------------------------------------------------ diálogos
    def elegir_archivo(self, tipo="oleaje"):
        win = self._ventana()
        if not win:
            return None
        mapa = {
            "oleaje": ("Datos marítimos (*.nc;*.mat;*.csv)",),
            "serie": ("Serie (*.nc;*.mat;*.csv)",),
        }
        tipos = mapa.get(tipo, mapa["oleaje"]) + ("Todos (*.*)",)
        r = win.create_file_dialog(webview.OPEN_DIALOG, file_types=tipos)
        if r:
            motor_web.guardar_config_carpeta("ultima_carpeta_datos", Path(r[0]).parent)
            return r[0]
        return None

    def elegir_carpeta(self, tipo="datos"):
        win = self._ventana()
        if not win:
            return None
        inicial = motor_web.obtener_config_carpeta("ultima_carpeta_datos")
        r = win.create_file_dialog(webview.FOLDER_DIALOG, directory=inicial or None)
        if r:
            motor_web.guardar_config_carpeta("ultima_carpeta_datos", r[0])
            return r[0]
        return None

    def abrir_en_explorador(self, ruta):
        try:
            p = motor_web._ruta_usuario(ruta, "Ruta", debe_existir=True)
        except ValueError as e:
            return {"ok": False, "error": str(e)}
        try:
            if p.is_file():
                sistema.abrir_carpeta(p.parent)
            else:
                sistema.abrir_carpeta(p)
        except Exception as e:
            return {"ok": False, "error": str(e)}
        return {"ok": True}

    def abrir_url_externa(self, url):
        """Abre un enlace HTTPS en el navegador del sistema."""
        url = (url or "").strip()
        if not url.startswith("https://"):
            return {"ok": False, "error": "Solo se permiten URLs https."}
        try:
            import webbrowser
            webbrowser.open(url)
        except Exception as e:
            return {"ok": False, "error": str(e)}
        return {"ok": True}

    def ruta_existe(self, ruta):
        try:
            p = motor_web._ruta_usuario(ruta, "Ruta", debe_existir=False)
            return p.exists()
        except ValueError:
            return False

    # ------------------------------------------------------------------ datos
    def revision_datos(self, ruta):
        return motor_web.revision_datos(ruta)

    def revision_datos_ventanas(self, ruta):
        return motor_web.revision_datos_ventanas(ruta)

    def estado_cds_credenciales(self):
        return {"ok": True, **io_era5.estado_credenciales_cds()}

    def guardar_cds_credenciales(self, url, key=""):
        try:
            datos = io_era5.guardar_credenciales_cds(url, key or None)
            return {"ok": True, **datos}
        except ValueError as e:
            return {"ok": False, "error": str(e)}

    def probar_cds_credenciales(self, url="", key=""):
        try:
            datos = io_era5.probar_credenciales_cds(
                url or None, key or None)
            return {"ok": True, **datos}
        except ValueError as e:
            return {"ok": False, "error": str(e)}

    def descargar_era5(self, lat, lon, inicio, fin, viento=True, espectro=False):
        if not io_era5.leer_credenciales_cds():
            return {"ok": False, "error": "Faltan credenciales ERA5"}
        try:
            motor_web._validar_era5(lat, lon, inicio, fin)
        except ValueError as e:
            return {"ok": False, "error": str(e)}

        def log(msg):
            self._emit("log", {"msg": msg})

        def trabajo():
            return motor_web.descargar_era5(
                lat, lon, inicio, fin, con_viento=True, log_fn=log)

        return self._run_task("era5", trabajo)

    def listar_recientes(self):
        return {"ok": True, "items": motor_web.listar_recientes()}

    def listar_cache_era5(self):
        return {"ok": True, "items": motor_web.listar_cache_era5()}

    def eliminar_cache_era5(self, carpeta):
        try:
            return motor_web.eliminar_cache_era5(carpeta)
        except ValueError as e:
            return {"ok": False, "error": str(e)}

    def guardar_preferencias(self, prefs_json):
        try:
            prefs = self._parse_json(prefs_json, "preferencias")
        except ValueError as e:
            return {"ok": False, "error": str(e)}
        motor_web.guardar_preferencias(prefs)
        return {"ok": True}

    def obtener_preferencias(self):
        return {"ok": True, "prefs": motor_web.obtener_preferencias()}

    def preview_archivo(self, ruta):
        try:
            img = motor_web.preview_archivo(ruta)
            return {"ok": True, "img": img}
        except ValueError as e:
            return {"ok": False, "error": str(e)}

    def info_aplicacion(self):
        return {"ok": True, **motor_web.info_aplicacion()}

    def guardar_sesion_wizard(self, wizard, step, ctx_json):
        try:
            ctx = self._parse_json(ctx_json, "contexto wizard")
        except ValueError as e:
            return {"ok": False, "error": str(e)}
        motor_web.guardar_sesion_wizard(wizard, int(step), ctx)
        return {"ok": True}

    def cargar_sesion_wizard(self):
        ses = motor_web.cargar_sesion_wizard()
        return {"ok": True, "sesion": ses}

    def limpiar_sesion_wizard(self):
        motor_web.limpiar_sesion_wizard()
        return {"ok": True}

    def abrir_archivo(self, ruta):
        try:
            p = motor_web._ruta_usuario(ruta, "Archivo", debe_existir=True)
        except ValueError as e:
            return {"ok": False, "error": str(e)}
        try:
            sistema.abrir_archivo(p)
        except Exception as e:
            return {"ok": False, "error": str(e)}
        return {"ok": True}

    def _ocupado(self):
        """Dict de error si hay una tarea en hilo corriendo; None si libre."""
        with self._lock:
            if self._busy:
                return {"ok": False,
                        "error": "Espera a que termine la tarea en curso."}
        return None

    # ---------------------------------------------------------- ventanas (F4)
    def listar_faenas(self):
        return {"ok": True, **motor_web.listar_faenas()}

    def analizar_faenas(self, ruta, faenas_json):
        try:
            faenas = self._parse_json(faenas_json, "faenas")
        except ValueError as e:
            return {"ok": False, "error": str(e)}
        if not isinstance(faenas, list) or not faenas:
            return {"ok": False, "error": "Selecciona al menos una faena."}
        try:
            motor_web._ruta_usuario(ruta, "Archivo de datos", debe_existir=True)
        except ValueError as e:
            return {"ok": False, "error": str(e)}

        def log(msg):
            self._emit("log", {"msg": msg})

        def trabajo():
            return motor_web.analizar_faenas(ruta, faenas, log_fn=log)

        return self._run_task("analizar_faenas", trabajo)

    def exportar_excel_ventanas(self, ruta, faena_json):
        ocupado = self._ocupado()
        if ocupado:
            return ocupado
        try:
            faena = self._parse_json(faena_json, "faena")
            return {"ok": True, **motor_web.exportar_excel_ventanas(ruta, faena)}
        except (ValueError, TypeError) as e:
            return {"ok": False, "error": str(e)}

    def exportar_csv_serie(self, ruta, faena_json):
        ocupado = self._ocupado()
        if ocupado:
            return ocupado
        try:
            faena = self._parse_json(faena_json, "faena")
            return {"ok": True, **motor_web.exportar_csv_serie(ruta, faena)}
        except (ValueError, TypeError) as e:
            return {"ok": False, "error": str(e)}

    def exportar_informe(self, ruta, faena_json, proyecto="", autor=""):
        ocupado = self._ocupado()
        if ocupado:
            return ocupado
        try:
            faena = self._parse_json(faena_json, "faena")
            return {"ok": True, **motor_web.exportar_informe_ventanas(
                ruta, faena, proyecto=proyecto or "", autor=autor or "")}
        except (ValueError, TypeError) as e:
            return {"ok": False, "error": str(e)}


def ruta_ui():
    return Path(__file__).resolve().parent / "ui" / "index.html"