"use strict";

const gvlReferenceMaintenanceStatus = document.getElementById(
  "gvl-reference-maintenance-status"
);
const gvlReferenceProtectedRevisions = document.getElementById(
  "gvl-reference-protected-revisions"
);
const gvlReferenceMaintenanceMessage = document.getElementById(
  "gvl-reference-maintenance-message"
);
const purgeGvlReferenceDataButton = document.getElementById(
  "purge-gvl-reference-data-button"
);

document.addEventListener("DOMContentLoaded", async () => {
  purgeGvlReferenceDataButton.addEventListener("click", async () => {
    await purgeUnlockedEvidenceRecords();
  });
  await renderGvlReferenceMaintenanceStatus();
});

async function renderGvlReferenceMaintenanceStatus() {
  try {
    const result = await browser.runtime.sendMessage({
      type: "list_gvl_snapshots"
    });

    if (!result?.success) {
      throw new Error(result?.error ?? "list_gvl_snapshots_failed");
    }

    renderGvlReferenceSnapshotStatus(result.gvlSnapshots ?? []);
  } catch (error) {
    renderGvlReferenceStatus("–", true, "Status nicht verfügbar.");
    renderProtectedRevisions([]);
    console.warn("VG-Observe GVL maintenance status failed", error);
  }
}

function renderGvlReferenceSnapshotStatus(snapshots) {
  if (!snapshots.length) {
    renderGvlReferenceStatus("–", true, "Keine GVL-Revisionen.");
    renderProtectedRevisions([]);
    return;
  }

  const protectedRevisions = snapshots
    .filter((snapshot) => snapshot.workspaceDeleteProtected === true)
    .map((snapshot) => snapshot.vendorListVersion)
    .filter((vendorListVersion) => vendorListVersion !== null)
    .filter((vendorListVersion) => vendorListVersion !== undefined);
  const allRevisionsDeleteAllowed = snapshots.every((snapshot) => {
    return snapshot.workspaceDeleteAllowed === true;
  });

  if (allRevisionsDeleteAllowed) {
    renderGvlReferenceStatus("🔓", false, "GVL-Revisionen löschbar.");
  } else if (protectedRevisions.length) {
    renderGvlReferenceStatus("🔒", true, "GVL-Revisionen geschützt.");
  } else {
    renderGvlReferenceStatus("–", true, "Status nicht verfügbar.");
  }

  renderProtectedRevisions(protectedRevisions);
}

function renderGvlReferenceStatus(statusSymbol, buttonDisabled, message) {
  gvlReferenceMaintenanceStatus.textContent = statusSymbol;
  purgeGvlReferenceDataButton.disabled = buttonDisabled;
  gvlReferenceMaintenanceMessage.textContent = message;
}

async function purgeUnlockedEvidenceRecords() {
  if (
    !confirm(
      "Ungesperrte Evidence-Daten mit bestehender Schutzlogik bereinigen?"
    )
  ) {
    return;
  }

  purgeGvlReferenceDataButton.disabled = true;
  gvlReferenceMaintenanceMessage.textContent = "Bereinigung läuft...";

  try {
    const result = await browser.runtime.sendMessage({
      type: "purge_unlocked_evidence_records"
    });

    if (!result?.success) {
      throw new Error(result?.error ?? "purge_unlocked_evidence_records_failed");
    }

    await renderGvlReferenceMaintenanceStatus();
    gvlReferenceMaintenanceMessage.textContent = buildPurgeSuccessMessage(result);
  } catch (error) {
    await renderGvlReferenceMaintenanceStatus();
    gvlReferenceMaintenanceMessage.textContent = "Bereinigung fehlgeschlagen.";
    console.warn("VG-Observe protected purge failed", error);
  }
}

function buildPurgeSuccessMessage(result) {
  if (Number.isFinite(result.deletedCount)) {
    return `Bereinigung abgeschlossen: ${result.deletedCount} Records.`;
  }

  return "Bereinigung abgeschlossen.";
}

function renderProtectedRevisions(vendorListVersions) {
  gvlReferenceProtectedRevisions.hidden = vendorListVersions.length === 0;
  gvlReferenceProtectedRevisions.textContent = vendorListVersions.length
    ? `Geschützt: ${vendorListVersions
        .map((vendorListVersion) => String(vendorListVersion))
        .join(", ")}`
    : "";
}