(function (global) {
  const app = (global.EpicrisisApp = global.EpicrisisApp || {});

  function generarClaveAyudaManual(tipo, nombre, fuente = "manual_pdf") {
    const slug = String(nombre || "")
      .normalize("NFD")
      .replace(/[\u0300-\u036f]/g, "")
      .toLowerCase()
      .replace(/[^a-z0-9]+/g, "-")
      .replace(/^-+|-+$/g, "") || "sin-nombre";
    return `ayuda:${tipo || "imagen"}:${slug}:${fuente}`;
  }

  function normalizarTipoAyuda(tipo) {
    const value = String(tipo || "").toLowerCase().replace(/[\s-]+/g, "_");
    if (["laboratorio", "lab", "laboratorios"].includes(value)) return "laboratorio";
    if (["procedimiento_diagnostico", "procedimiento_diagnóstico", "procedimiento"].includes(value)) {
      return "procedimiento_diagnostico";
    }
    return "imagen";
  }

  function inferirTipoAyuda(texto) {
    const value = String(texto || "").toLowerCase();
    if (/laboratorio|hemograma|creatinina|uroan[aá]lisis/.test(value)) return "laboratorio";
    if (/endoscopia|electrocardiograma|ecg/.test(value)) return "procedimiento_diagnostico";
    return "imagen";
  }

  function normalizarAyudaDiagnostica(item) {
    if (item && typeof item === "object") {
      const tipo = normalizarTipoAyuda(item.tipo);
      const nombre = String(item.nombre || item.texto || item.descripcion || "").trim();
      if (!nombre) return null;
      return {
        key: String(item.key || generarClaveAyudaManual(tipo, nombre, item.fuente || "desconocida")).trim(),
        tipo,
        nombre,
        concepto: String(item.concepto || item.interpretacion || "").trim(),
        fuente: String(item.fuente || "desconocida").trim(),
        documento_id: String(item.documento_id || "").trim(),
        documento_nombre: String(item.documento_nombre || "").trim(),
        ordenado: Boolean(item.ordenado),
        interpretado: Boolean(item.interpretado),
        facturado: Boolean(item.facturado),
        glosado: Boolean(item.glosado),
        estado_interpretacion: String(item.estado_interpretacion || (item.interpretado ? "interpretado" : "pendiente_revision")).trim(),
        razon_inclusion: String(item.razon_inclusion || "").trim(),
        alertas: Array.isArray(item.alertas) ? item.alertas.map((alerta) => String(alerta || "").trim()).filter(Boolean) : [],
        exportable: item.exportable !== false,
      };
    }
    const texto = String(item || "").trim();
    if (!texto) return null;
    const parts = texto.split(/\s+-\s+/);
    const nombre = parts.shift() || texto;
    const concepto = parts.join(" - ");
    const tipo = inferirTipoAyuda(texto);
    return {
      key: generarClaveAyudaManual(tipo, texto, "legacy"),
      tipo,
      nombre,
      concepto,
      fuente: "legacy_imagenes_diagnosticas",
      documento_id: "",
      documento_nombre: "",
      ordenado: false,
      interpretado: Boolean(concepto && concepto !== "No interpretado"),
      facturado: false,
      glosado: false,
      estado_interpretacion: concepto && concepto !== "No interpretado" ? "interpretado" : "no_interpretado",
      razon_inclusion: "Compatibilidad con imágenes diagnósticas legacy.",
      alertas: concepto ? [] : ["ayuda_no_interpretada"],
      exportable: true,
    };
  }

  function deduplicarAyudasDiagnosticas(items) {
    const seen = new Set();
    const result = [];
    (items || []).forEach((item) => {
      const ayuda = normalizarAyudaDiagnostica(item);
      if (!ayuda) return;
      const key = ayuda.key || generarClaveAyudaManual(ayuda.tipo, ayuda.nombre, ayuda.fuente);
      if (seen.has(key)) return;
      seen.add(key);
      result.push(ayuda);
    });
    return result;
  }

  function etiquetaTipoAyuda(tipo) {
    const labels = {
      imagen: "Imagen",
      laboratorio: "Laboratorio",
      procedimiento_diagnostico: "Procedimiento diagnóstico",
    };
    return labels[normalizarTipoAyuda(tipo)] || "Imagen";
  }

  function esPlaceholderInterpretacion(value) {
    const normalized = String(value || "")
      .normalize("NFD")
      .replace(/[\u0300-\u036f]/g, "")
      .replace(/\s+/g, " ")
      .trim()
      .toLowerCase();
    return ["", "no interpretado", "no interpretada", "sin interpretacion", "pendiente"].includes(normalized);
  }

  function obtenerNombreExportable(ayuda) {
    const item = normalizarAyudaDiagnostica(ayuda);
    if (!item) return "";
    const nombre = String(item.nombre || "").trim();
    const concepto = String(item.concepto || item.interpretacion || "").trim();
    if (
      item.fuente === "factura"
      && !item.interpretado
      && concepto
      && !esPlaceholderInterpretacion(concepto)
      && concepto.toLowerCase() !== nombre.toLowerCase()
      && !nombre.toLowerCase().includes(concepto.toLowerCase())
    ) {
      return nombre ? `${nombre} - ${concepto}` : concepto;
    }
    return nombre;
  }

  function obtenerInterpretacionExportable(ayuda) {
    const item = normalizarAyudaDiagnostica(ayuda);
    if (!item || !item.interpretado) return "";
    const interpretacion = String(item.concepto || item.interpretacion || "").trim();
    return esPlaceholderInterpretacion(interpretacion) ? "" : interpretacion;
  }

  function renderBadgesAyuda(ayuda) {
    const badges = [
      etiquetaTipoAyuda(ayuda.tipo),
      ayuda.ordenado ? "Ordenado" : "",
      ayuda.interpretado ? "Interpretado" : "",
      ayuda.facturado ? "Facturado" : "",
      ayuda.glosado ? "Glosado" : "",
      ayuda.estado_interpretacion === "no_interpretado" ? "No interpretado" : "",
    ].filter(Boolean);
    const alerts = Array.isArray(ayuda.alertas) ? ayuda.alertas : [];
    return [
      ...badges.map((badge) => `<span class="aid-badge${badge === "Glosado" ? " blocked" : ""}">${app.utils.escapeHtml(badge)}</span>`),
      ...alerts.map((alerta) => `<span class="aid-badge alert">${app.utils.escapeHtml(alerta.replace(/_/g, " "))}</span>`),
    ].join("");
  }

  function parseAyudaManual(line) {
    const text = String(line || "").trim();
    const parts = text.split("|").map((part) => part.trim()).filter(Boolean);
    if (parts.length >= 2) {
      return {
        tipo: parts[0],
        nombre: parts[1],
        concepto: parts.slice(2).join(" | ") || "Agregada manualmente.",
        fuente: "manual_pdf",
        estado_interpretacion: "pendiente_revision",
        razon_inclusion: "Agregada manualmente para exportación.",
      };
    }
    return {
      tipo: inferirTipoAyuda(text),
      nombre: text,
      concepto: "Agregada manualmente.",
      fuente: "manual_pdf",
      estado_interpretacion: "pendiente_revision",
      razon_inclusion: "Agregada manualmente para exportación.",
    };
  }

  app.ayudasDiagnosticas = {
    generarClaveAyudaManual,
    normalizarTipoAyuda,
    inferirTipoAyuda,
    normalizarAyudaDiagnostica,
    deduplicarAyudasDiagnosticas,
    etiquetaTipoAyuda,
    esPlaceholderInterpretacion,
    obtenerNombreExportable,
    obtenerInterpretacionExportable,
    renderBadgesAyuda,
    parseAyudaManual,
  };
})(globalThis);
