async function fetchJSON(url, options) {
    const res = await fetch(url, options);
    if (!res.ok) throw new Error(await res.text());
    return await res.json();
  }
  

  let _datasets = [];
  let _currentDatasetId = "";
  

  function fmtNumber(value, digits = 3) {
    if (value == null || Number.isNaN(Number(value))) return "-";
    return Number(value).toFixed(digits);
  }
  

  function metricColumns(metrics) {
    const defs = [

      {
        title: "Primary",
        keys: [
          "Primary_Metric_Score",
          "NDCG@20",
          "NDCG@50",
          "ERR@10",
          "Strong_Precision@10",
          "Strong_Precision@20",
          "Useful_Precision@50",
          "Avg_Grade@10",
          "Gain_Recall@20",
        ],
      },

      { title: "NDCG", keys: ["NDCG@5", "NDCG@10", "NDCG@20", "NDCG@50"] },
      { title: "ERR", keys: ["ERR@5", "ERR@10", "ERR@20", "ERR@50"] },

      {

        title: "Top slot",
        keys: [
          "Exact_Precision@5",
          "Exact_Precision@10",
          "Strong_Precision@5",
          "Strong_Precision@10",
          "Strong_Precision@20",
        ],

      },
      {

        title: "Recall",
        keys: [
          "Useful_Precision@10",
          "Useful_Precision@20",
          "Useful_Precision@50",
          "Gain_Recall@10",
          "Gain_Recall@20",
          "Gain_Recall@50",
        ],

      },
      {

        title: "First good",
        keys: [
          "Exact_Success@5",
          "Exact_Success@10",
          "Strong_Success@5",
          "Strong_Success@10",
          "MRR_Exact@10",
          "MRR_Strong@10",
          "Avg_Grade@10",
        ],

      },
    ];
    const seen = new Set();

    const columns = defs
      .map((col) => {
        const rows = col.keys

          .filter((key) => metrics && Object.prototype.hasOwnProperty.call(metrics, key))
          .map((key) => {
            seen.add(key);
            return [key, metrics[key]];
          });

        return { title: col.title, rows };

      })

      .filter((col) => col.rows.length);
    const rest = Object.keys(metrics || {})
      .filter((key) => !seen.has(key))
      .sort()
      .map((key) => [key, metrics[key]]);
    if (rest.length) columns.push({ title: "Other", rows: rest });
    return columns;

  }
  
  function renderMetrics(metrics, metricContext) {
    const root = document.getElementById("metrics");
    root.innerHTML = "";
    const ctx = document.getElementById("metricContext");

    const parts = [];
    if (metricContext && metricContext.primary_metric) {
      parts.push(`Primary: ${metricContext.primary_metric}`);
    }

    if (metricContext && Array.isArray(metricContext.primary_metrics) && metricContext.primary_metrics.length) {
      parts.push(`Primary metrics: ${metricContext.primary_metrics.join(", ")}`);
    }
    if (metricContext && metricContext.primary_metric_formula) {
      parts.push(metricContext.primary_metric_formula);
    }

    if (metricContext && metricContext.gain_scheme) {
      parts.push(
        `NDCG gains: ${Object.entries(metricContext.gain_scheme)
          .map(([label, gain]) => `${label}=${gain}`)
          .join(", ")}`
      );
    }
    if (metricContext && metricContext.stop_prob_scheme) {
      parts.push(
        `ERR P(stop): ${Object.entries(metricContext.stop_prob_scheme)
          .map(([label, p]) => `${label}=${p}`)
          .join(", ")}`
      );
    }
    ctx.textContent = parts.length ? `${parts.join(". ")}.` : "";

    const bar = document.createElement("div");
    bar.className = "metrics-columns";
    metricColumns(metrics || {}).forEach((col) => {
      const column = document.createElement("div");
      column.className = "metric-column";
      const h = document.createElement("h4");
      h.className = "metric-column-title";
      h.textContent = col.title;
      column.appendChild(h);
      col.rows.forEach(([key, value]) => {
        const row = document.createElement("div");
        row.className = "metric-row";
        row.innerHTML = `<span class="metric-row-name">${key}:</span> <span class="metric-row-value">${fmtNumber(value)}</span>`;
        column.appendChild(row);

      });

      bar.appendChild(column);

    });

    root.appendChild(bar);

  }
  
  function labelBadgeClass(label) {
    if (!label || label === "Unknown") return "badge-unknown";
    return "label-" + String(label).toLowerCase().replace(/\s+/g, "-");
  }
  
  function renderResults(results, rootId = "results", showRank = true) {
    const mount = document.getElementById(rootId);
    mount.innerHTML = "";
    (results || []).forEach((item) => {
      const label = item.label || "Unknown";
      const box = document.createElement("div");
      box.className = "result";
      box.innerHTML = `
        <div><span class="badge ${labelBadgeClass(label)}">${label}</span><div class="muted" style="margin-top:8px">${showRank ? `#${item.rank || "-"}` : (item.rerank_score != null ? `rerank=${item.rerank_score.toFixed ? item.rerank_score.toFixed(4) : item.rerank_score}` : "not recalled")}</div></div>
        <img class="thumb" src="${item.image_url || ""}" alt="" />
        <div>
          <div class="title">${item.title || ""}</div>
          ${item.title_zh ? `<div class="title-zh">${item.title_zh}</div>` : ""}
          <div class="options">
            <div>${(item.option_values || [])[0] || ""}</div>
            <div>${(item.option_values || [])[1] || ""}</div>
            <div>${(item.option_values || [])[2] || ""}</div>
          </div>
        </div>`;
      mount.appendChild(box);
    });
    if (!(results || []).length) {
      mount.innerHTML = '<div class="muted">None.</div>';
    }
  }
  
  function renderTips(data) {
    const root = document.getElementById("tips");
    const tips = [...(data.tips || [])];
    const stats = data.label_stats || {};
    tips.unshift(
      `Cached labels: ${stats.total || 0}. Recalled hits: ${stats.recalled_hits || 0}. Missed judged useful results: ${stats.missing_relevant_count || 0} (Exact ${stats.missing_exact_count || 0}, High ${stats.missing_high_count || 0}, Low ${stats.missing_low_count || 0}).`
    );
    root.innerHTML = tips.map((text) => `<div class="tip">${text}</div>`).join("");
  }
  
  async function loadQueries() {

    if (!_currentDatasetId) return;
    const data = await fetchJSON("/api/datasets/" + encodeURIComponent(_currentDatasetId) + "/queries");

    const root = document.getElementById("queryList");
    root.innerHTML = "";

    const dataset = data.dataset || {};
    document.getElementById("queriesMeta").innerHTML = `Loaded from <code>${dataset.query_file || ""}</code>`;
    document.getElementById("datasetMeta").textContent =
      `${dataset.display_name || dataset.dataset_id || ""} · ${dataset.query_count || 0} queries`;
    document.getElementById("pageSubtitle").textContent =
      `Current dataset: ${dataset.display_name || dataset.dataset_id || ""}. Single-query evaluation and batch evaluation share the same service on port 6010.`;
    document.getElementById("batchButton").textContent =
      `Batch Evaluation: ${dataset.display_name || dataset.dataset_id || ""}`;

    data.queries.forEach((query) => {
      const btn = document.createElement("button");
      btn.className = "query-item";
      btn.textContent = query;
      btn.onclick = () => {
        document.getElementById("queryInput").value = query;
        runSingle();
      };
      root.appendChild(btn);
    });
  }
  

  async function loadDatasets() {
    const data = await fetchJSON("/api/datasets");
    _datasets = data.datasets || [];
    if (!_currentDatasetId) _currentDatasetId = data.current_dataset_id || (_datasets[0] && _datasets[0].dataset_id) || "";
    const select = document.getElementById("datasetSelect");
    select.innerHTML = "";
    _datasets.forEach((dataset) => {
      const opt = document.createElement("option");
      opt.value = dataset.dataset_id;
      opt.textContent = `${dataset.display_name || dataset.dataset_id} (${dataset.query_count || 0})`;
      if (dataset.dataset_id === _currentDatasetId) opt.selected = true;
      select.appendChild(opt);
    });
    select.onchange = async (ev) => {
      _currentDatasetId = ev.target.value;
      await loadQueries();
      await loadHistory();
    };
  }
  

  function historySummaryHtml(meta) {
    const m = meta && meta.aggregate_metrics;

    const nq = (meta && meta.query_count) || (meta && meta.queries && meta.queries.length) || (meta && meta.per_query && meta.per_query.length) || null;

    const parts = [];
    if (nq != null) parts.push(`<span>Queries</span> ${nq}`);

    if (m && m["Primary_Metric_Score"] != null) parts.push(`<span>Primary</span> ${fmtNumber(m["Primary_Metric_Score"])}`);
    if (m && m["NDCG@20"] != null) parts.push(`<span>NDCG@20</span> ${fmtNumber(m["NDCG@20"])}`);

    if (m && m["ERR@10"] != null) parts.push(`<span>ERR@10</span> ${fmtNumber(m["ERR@10"])}`);

    if (m && m["Strong_Precision@10"] != null) parts.push(`<span>Strong@10</span> ${fmtNumber(m["Strong_Precision@10"])}`);

    if (m && m["Gain_Recall@20"] != null) parts.push(`<span>Gain Recall@20</span> ${fmtNumber(m["Gain_Recall@20"])}`);

    if (!parts.length) return "";
    return `<div class="hstats">${parts.join(" · ")}</div>`;
  }
  
  async function loadHistory() {

    if (!_currentDatasetId) return;
    const data = await fetchJSON("/api/history?dataset_id=" + encodeURIComponent(_currentDatasetId));

    const root = document.getElementById("history");
    root.classList.remove("muted");
    const items = data.history || [];
    if (!items.length) {
      root.innerHTML = '<span class="muted">No history yet.</span>';
      return;
    }
    root.innerHTML = `<div class="history-list"></div>`;
    const list = root.querySelector(".history-list");
    items.forEach((item) => {
      const btn = document.createElement("button");
      btn.type = "button";
      btn.className = "history-item";
      btn.setAttribute("aria-label", `Open report ${item.batch_id}`);
      const sum = historySummaryHtml(item.metadata);

      const dataset = (item.metadata && item.metadata.dataset) || {};
      const datasetName = dataset.display_name || dataset.dataset_id || item.dataset_id || "";

      btn.innerHTML = `<div class="hid">${item.batch_id}</div>

        <div class="hmeta">${item.created_at} · tenant ${item.tenant_id}${datasetName ? ` · ${datasetName}` : ""}</div>${sum}`;

      btn.onclick = () => openBatchReport(item.batch_id);
      list.appendChild(btn);
    });
  }
  
  let _lastReportPath = "";
  
  function closeReportModal() {
    const el = document.getElementById("reportModal");
    el.classList.remove("is-open");
    el.setAttribute("aria-hidden", "true");
    document.getElementById("reportModalBody").innerHTML = "";
    document.getElementById("reportModalMeta").textContent = "";
  }
  
  async function openBatchReport(batchId) {
    const el = document.getElementById("reportModal");
    const body = document.getElementById("reportModalBody");
    const metaEl = document.getElementById("reportModalMeta");
    const titleEl = document.getElementById("reportModalTitle");
    el.classList.add("is-open");
    el.setAttribute("aria-hidden", "false");
    titleEl.textContent = batchId;
    metaEl.textContent = "";
    body.className = "report-modal-body batch-report-md report-modal-loading";
    body.textContent = "Loading report…";
    try {
      const rep = await fetchJSON("/api/history/" + encodeURIComponent(batchId) + "/report");
      _lastReportPath = rep.report_markdown_path || "";

      const dataset = rep.dataset || {};
      metaEl.textContent = [dataset.display_name || dataset.dataset_id || "", rep.report_markdown_path || ""]
        .filter(Boolean)
        .join(" · ");

      const raw = marked.parse(rep.markdown || "", { gfm: true });
      const safe = DOMPurify.sanitize(raw, { USE_PROFILES: { html: true } });
      body.className = "report-modal-body batch-report-md";
      body.innerHTML = safe;
    } catch (e) {
      body.className = "report-modal-body report-modal-error";
      body.textContent = e && e.message ? e.message : String(e);
    }
  }
  
  document.getElementById("reportModal").addEventListener("click", (ev) => {
    if (ev.target && ev.target.getAttribute("data-close-report") === "1") closeReportModal();
  });
  
  document.addEventListener("keydown", (ev) => {
    if (ev.key === "Escape") closeReportModal();
  });
  
  document.getElementById("reportCopyPath").addEventListener("click", async () => {
    if (!_lastReportPath) return;
    try {
      await navigator.clipboard.writeText(_lastReportPath);
    } catch (_) {}
  });
  
  async function runSingle() {
    const query = document.getElementById("queryInput").value.trim();
    if (!query) return;

    document.getElementById("status").textContent = `Evaluating "${query}" on ${_currentDatasetId}...`;

    const data = await fetchJSON("/api/search-eval", {
      method: "POST",
      headers: { "Content-Type": "application/json" },

      body: JSON.stringify({ query, dataset_id: _currentDatasetId, top_k: 100, auto_annotate: false }),

    });
    document.getElementById("status").textContent = `Done. total=${data.total}`;
    renderMetrics(data.metrics, data.metric_context);
    renderResults(data.results, "results", true);
    renderResults(data.missing_relevant, "missingRelevant", false);
    renderTips(data);
    loadHistory();
  }
  
  async function runBatch() {

    document.getElementById("status").textContent = `Running batch evaluation for ${_currentDatasetId}...`;

    const data = await fetchJSON("/api/batch-eval", {
      method: "POST",
      headers: { "Content-Type": "application/json" },

      body: JSON.stringify({ dataset_id: _currentDatasetId, top_k: 100, auto_annotate: false }),

    });
    document.getElementById("status").textContent = `Batch done. report=${data.batch_id}`;
    renderMetrics(data.aggregate_metrics, data.metric_context);
    renderResults([], "results", true);
    renderResults([], "missingRelevant", false);

    document.getElementById("tips").innerHTML =
      '<div class="tip">Batch evaluation uses cached labels only unless force refresh is requested via CLI/API.</div>';

    loadHistory();
  }
  

  loadDatasets().then(() => loadQueries()).then(() => loadHistory());