/* AdminPanel.jsx — reserve-team dashboard, wired to real API */

/* Small fetch wrapper: always attaches the bearer token and never throws on
   HTTP errors so callers can check `.ok` explicitly. */
async function apiFetch(token, path, options = {}) {
  const headers = Object.assign({}, options.headers || {});
  if (token) headers["Authorization"] = "Bearer " + token;
  const isForm = options.body instanceof FormData;
  if (options.body && !isForm) headers["Content-Type"] = "application/json";
  try {
    const resp = await fetch(path, Object.assign({}, options, { headers }));
    const text = await resp.text();
    let data = null;
    try { data = text ? JSON.parse(text) : null; } catch (e) { data = null; }
    return { ok: resp.ok, status: resp.status, data };
  } catch (e) {
    return { ok: false, status: 0, data: null, networkError: true };
  }
}

function transformIncident(inc) {
  let cats = [];
  if (inc.categories) { try { cats = JSON.parse(inc.categories); } catch (e) { /* ignore */ } }
  if (!Array.isArray(cats) || cats.length === 0) cats = ["other"];

  const status = inc.status || (inc.resolved ? "resolved" : "new");
  const files = (inc.files || []).map((f) => ({
    id: f.id,
    path: f.file_path,
    type: f.file_type,
    name: f.original_name,
    url: f.url,
    thumb: f.thumb_url || f.url,
    isImage: !!(f.file_type && f.file_type.startsWith("image")),
  }));

  return {
    id: "RD-" + inc.id,
    _id: inc.id,
    cat: cats,
    when: inc.incident_date_time || inc.created_at,
    created_at: inc.created_at,
    status: status,
    ll: (inc.latitude != null && inc.longitude != null) ? [inc.latitude, inc.longitude] : null,
    files,
    ev: files.length,
    anon: !inc.reporter_name,
    name: inc.reporter_name,
    email: inc.reporter_email,
    phone: inc.reporter_phone,
    description: inc.description,
    assignedTo: inc.assigned_to,
    consent: !!inc.consent,
    redacted: !!inc.redacted,
    deletedAt: inc.deleted_at,
  };
}

/* ------------------------------------------------------------------ */
function EmailList({ token, lang }) {
  const [emails, setEmails] = React.useState([]);
  const [newEmail, setNewEmail] = React.useState("");
  const [adding, setAdding] = React.useState(false);
  const [err, setErr] = React.useState("");
  const de = lang === "de";

  const loadEmails = React.useCallback(async () => {
    const res = await apiFetch(token, "/api/admin/notification-emails");
    if (res.ok && res.data && res.data.success) setEmails(res.data.emails);
  }, [token]);

  React.useEffect(() => { loadEmails(); }, [loadEmails]);

  async function addEmail() {
    if (adding) return;
    if (!newEmail || !newEmail.includes("@")) { setErr(de ? "Ungültige E-Mail-Adresse" : "Invalid email address"); return; }
    setAdding(true); setErr("");
    const res = await apiFetch(token, "/api/admin/notification-emails", { method: "POST", body: JSON.stringify({ email: newEmail }) });
    if (res.ok && res.data && res.data.success) { setNewEmail(""); loadEmails(); }
    else setErr((res.data && res.data.error) || (de ? "Fehler" : "Error"));
    setAdding(false);
  }

  async function toggleEmail(id, active) {
    await apiFetch(token, `/api/admin/notification-emails/${id}/toggle`, { method: "PUT", body: JSON.stringify({ active: !active }) });
    loadEmails();
  }
  async function deleteEmail(id) {
    await apiFetch(token, `/api/admin/notification-emails/${id}`, { method: "DELETE" });
    loadEmails();
  }

  return (
    <div className="area-section">
      <div className="area-section-head">
        <h2 className="area-sec-title">{tSafe(de, "Benachrichtigungs-E-Mails", "Notification Emails")}</h2>
      </div>
      <p style={{ fontSize: 14, color: "var(--ink-2)", margin: "0 0 16px", lineHeight: 1.5 }}>
        {de ? "Bei neuen Meldungen wird eine Benachrichtigung an diese Adressen gesendet." : "A notification is sent to these addresses when new reports arrive."}
      </p>
      <div className="notif-email-list">
        {emails.map(e => (
          <div key={e.id} className={"notif-email-row" + (e.active ? "" : " inactive")}>
            <Ico name={e.active ? "bell" : "bell-off"} size={15} style={{ color: e.active ? "var(--moss)" : "var(--ink-3)" }} />
            <span className="notif-email-addr">{e.email}</span>
            <div className="notif-email-actions">
              <button className="set-btn" title={e.active ? (de ? "Deaktivieren" : "Deactivate") : (de ? "Aktivieren" : "Activate")}
                aria-label={e.active ? (de ? "Deaktivieren" : "Deactivate") : (de ? "Aktivieren" : "Activate")}
                onClick={() => toggleEmail(e.id, e.active)}>
                {e.active ? <Ico name="bell-off" size={14} /> : <Ico name="bell" size={14} />}
              </button>
              <button className="btn-danger" style={{ padding: "6px 10px" }} aria-label={de ? "Löschen" : "Delete"} onClick={() => deleteEmail(e.id)}>
                <Ico name="trash-2" size={13} />
              </button>
            </div>
          </div>
        ))}
        {emails.length === 0 && (
          <p style={{ color: "var(--ink-3)", fontSize: 13.5, margin: 0 }}>
            {de ? "Noch keine E-Mail-Adressen konfiguriert." : "No email addresses configured yet."}
          </p>
        )}
      </div>
      <div className="notif-add">
        <input className="input" type="email" style={{ flex: 1 }}
          placeholder={de ? "Neue E-Mail-Adresse …" : "New email address …"}
          value={newEmail} onChange={e => setNewEmail(e.target.value)}
          onKeyDown={e => e.key === "Enter" && addEmail()} />
        <button className="btn btn-ghost" onClick={addEmail} disabled={adding} style={{ fontSize: 13 }}>
          <Ico name="plus" size={15} /> {de ? "Hinzufügen" : "Add"}
        </button>
      </div>
      {err && <div className="err-line" style={{ marginTop: 8 }}><Ico name="circle-alert" size={15} /> {err}</div>}
    </div>
  );
}

function tSafe(de, deText, enText) { return de ? deText : enText; }

/* ------------------------------------------------------------------ */
function EvidenceGallery({ files, t, lang }) {
  if (!files || !files.length) return <p className="detail-desc muted">—</p>;
  return (
    <div className="ev-thumbs">
      {files.map((f, i) => (
        <a key={i} href={f.url} target="_blank" rel="noopener" className="ev-thumb-link"
          title={f.name || f.path}>
          {f.isImage || f.thumb ? (
            <img className="ev-thumb-img" src={f.thumb} alt={f.name || ""} loading="lazy" />
          ) : (
            <div className="ev-thumb"><Ico name="video" size={18} /></div>
          )}
        </a>
      ))}
    </div>
  );
}

/* ------------------------------------------------------------------ */
function IncidentHistory({ token, incidentId, lang, onChanged }) {
  const [events, setEvents] = React.useState([]);
  const [note, setNote] = React.useState("");
  const [sending, setSending] = React.useState(false);
  const [refresh, setRefresh] = React.useState(0);
  const de = lang === "de";

  // Guard against out-of-order responses when switching incidents quickly.
  React.useEffect(() => {
    let alive = true;
    (async () => {
      const res = await apiFetch(token, `/api/admin/incidents/${incidentId}/events`);
      if (alive && res.ok && res.data && res.data.success) setEvents(res.data.events);
    })();
    return () => { alive = false; };
  }, [token, incidentId, refresh]);

  const labels = {
    created: tSafe(de, "Erstellt", "Created"),
    status: tSafe(de, "Status geändert", "Status changed"),
    note: tSafe(de, "Notiz", "Note"),
    assign: tSafe(de, "Zugewiesen", "Assigned"),
    deleted: tSafe(de, "In Papierkorb", "Moved to bin"),
    restored: tSafe(de, "Wiederhergestellt", "Restored"),
    redacted: tSafe(de, "Daten anonymisiert", "PII redacted"),
  };
  const icons = { created: "sparkles", status: "refresh-cw", note: "message-square", assign: "user-check", deleted: "trash-2", restored: "rotate-ccw", redacted: "shield" };

  async function sendNote() {
    if (sending) return;
    const text = note.trim();
    if (!text) return;
    setSending(true);
    const res = await apiFetch(token, `/api/admin/incidents/${incidentId}/notes`, { method: "POST", body: JSON.stringify({ note: text }) });
    if (res.ok) { setNote(""); setRefresh((n) => n + 1); onChanged && onChanged(); }
    setSending(false);
  }

  return (
    <div className="history">
      <div className="history-list">
        {events.map((e) => (
          <div key={e.id} className="history-item">
            <span className="history-ico"><Ico name={icons[e.type] || "dot"} size={13} /></span>
            <div className="history-body">
              <div className="history-head">
                <strong>{labels[e.type] || e.type}</strong>
                <span className="history-time">{fmtWhen(e.created_at, lang)}</span>
              </div>
              {e.from_value || e.to_value ? (
                <div className="history-detail">{(e.from_value || "—") + " → " + (e.to_value || "—")}</div>
              ) : null}
              {e.note ? <div className="history-note">{e.note}</div> : null}
              {e.actor ? <div className="history-actor">{e.actor === "reporter" ? tSafe(de, "Melder:in", "Reporter") : e.actor}</div> : null}
            </div>
          </div>
        ))}
        {events.length === 0 && <p className="detail-desc muted">{tSafe(de, "Keine Einträge.", "No entries.")}</p>}
      </div>
      <div className="history-note-input">
        <input className="input" placeholder={tSafe(de, "Notiz hinzufügen …", "Add a note …")}
          value={note} onChange={(e) => setNote(e.target.value)}
          onKeyDown={(e) => e.key === "Enter" && sendNote()} />
        <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={sendNote} disabled={sending || !note.trim()}>
          <Ico name="send" size={14} /> {tSafe(de, "Senden", "Send")}
        </button>
      </div>
    </div>
  );
}

/* ------------------------------------------------------------------ */
function BinModal({ token, lang, onClose, onRestored }) {
  const de = lang === "de";
  const [items, setItems] = React.useState([]);
  const [loading, setLoading] = React.useState(true);
  const [err, setErr] = React.useState("");

  const load = React.useCallback(async () => {
    const res = await apiFetch(token, "/api/admin/incidents/bin");
    if (res.ok && res.data && res.data.success) setItems(res.data.incidents.map(transformIncident));
    else setErr(de ? "Papierkorb konnte nicht geladen werden." : "Could not load the bin.");
    setLoading(false);
  }, [token, de]);

  React.useEffect(() => { load(); }, [load]);

  async function restore(id) {
    setErr("");
    const res = await apiFetch(token, `/api/admin/incidents/${id}/restore`, { method: "POST" });
    if (res.ok) { await load(); onRestored && onRestored(); }
    else setErr(de ? "Wiederherstellen fehlgeschlagen." : "Restore failed.");
  }
  async function destroy(id) {
    if (!confirm(de ? "Endgültig löschen? Das kann nicht rückgängig gemacht werden." : "Delete permanently? This cannot be undone.")) return;
    setErr("");
    const res = await apiFetch(token, `/api/admin/incidents/${id}/permanent`, { method: "DELETE" });
    if (res.ok) await load();
    else setErr(de ? "Löschen fehlgeschlagen." : "Delete failed.");
  }

  return (
    <div className="modal-overlay" onClick={onClose}>
      <div className="modal-box" onClick={e => e.stopPropagation()}>
        <div className="modal-head">
          <h2 className="modal-title"><Ico name="trash-2" size={18} /> {tSafe(de, "Papierkorb", "Bin")}</h2>
          <button className="modal-close" onClick={onClose} aria-label={tSafe(de, "Schließen", "Close")}><Ico name="x" size={18} /></button>
        </div>
        <div className="modal-body">
          {err && <div className="err-line" style={{ marginBottom: 10 }}><Ico name="circle-alert" size={15} /> {err}</div>}
          {loading ? <div className="admin-loading"><Ico name="loader" size={18} /> …</div> : items.length === 0 ? (
            <p className="detail-desc muted">{tSafe(de, "Papierkorb ist leer.", "Bin is empty.")}</p>
          ) : items.map((r) => (
            <div key={r.id} className="bin-row">
              <div>
                <div className="bin-id">{r.id} · {r.cat.map((c) => catById(c)[lang]).join(" · ")}</div>
                <div className="bin-meta">{fmtWhen(r.when, lang)} · {tSafe(de, "gelöscht", "deleted")} {fmtWhen(r.deletedAt, lang)}</div>
              </div>
              <div style={{ display: "flex", gap: 8 }}>
                <button className="btn btn-ghost" style={{ fontSize: 12 }} onClick={() => restore(r._id)}>
                  <Ico name="rotate-ccw" size={14} /> {tSafe(de, "Wiederherstellen", "Restore")}
                </button>
                <button className="btn-danger" style={{ fontSize: 12 }} onClick={() => destroy(r._id)}>
                  <Ico name="trash-2" size={14} /> {tSafe(de, "Endgültig löschen", "Delete forever")}
                </button>
              </div>
            </div>
          ))}
        </div>
      </div>
    </div>
  );
}

/* ------------------------------------------------------------------ */
function ExportModal({ token, lang, onClose }) {
  const de = lang === "de";
  const [from, setFrom] = React.useState("");
  const [to, setTo] = React.useState("");
  const [format, setFormat] = React.useState("csv");
  const [redact, setRedact] = React.useState(false);
  const [loading, setLoading] = React.useState(false);
  const [err, setErr] = React.useState("");

  function applyPreset(preset) {
    const today = new Date();
    const pad = n => String(n).padStart(2, "0");
    const fmt = d => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
    let f, t;
    if (preset === "this-year") { f = new Date(today.getFullYear(), 0, 1); t = today; }
    else if (preset === "last-year") { f = new Date(today.getFullYear() - 1, 0, 1); t = new Date(today.getFullYear() - 1, 11, 31); }
    else if (preset === "last-month") { f = new Date(today.getFullYear(), today.getMonth() - 1, 1); t = new Date(today.getFullYear(), today.getMonth(), 0); }
    else if (preset === "last-3-months") {
      f = new Date(today.getFullYear(), today.getMonth(), today.getDate());
      f.setMonth(f.getMonth() - 3);
      t = today;
    }
    else if (preset === "all") { setFrom(""); setTo(""); return; }
    setFrom(fmt(f)); setTo(fmt(t));
  }

  async function doExport() {
    setLoading(true); setErr("");
    try {
      const params = new URLSearchParams({ format, lang });
      if (from) params.set("from", from);
      if (to) params.set("to", to);
      if (redact) params.set("redact", "1");
      const resp = await fetch(`/api/admin/incidents/export?${params}`, { headers: { "Authorization": "Bearer " + token } });
      if (!resp.ok) {
        throw new Error(resp.status === 401 ? (de ? "Nicht autorisiert" : "Unauthorized") : (de ? "Export fehlgeschlagen" : "Export failed"));
      }
      const blob = await resp.blob();
      const cd = resp.headers.get("Content-Disposition") || "";
      const match = cd.match(/filename="?([^"]+)"?/);
      const filename = match ? match[1] : `meldungen.${format}`;
      const url = URL.createObjectURL(blob);
      const a = document.createElement("a");
      a.href = url; a.download = filename;
      document.body.appendChild(a); a.click(); a.remove();
      URL.revokeObjectURL(url);
      onClose();
    } catch (e) {
      setErr(e.message || "Error");
    }
    setLoading(false);
  }

  const presets = [
    { key: "all", label: de ? "Alle" : "All" },
    { key: "this-year", label: de ? "Dieses Jahr" : "This year" },
    { key: "last-3-months", label: de ? "Letzte 3 Monate" : "Last 3 months" },
    { key: "last-month", label: de ? "Letzter Monat" : "Last month" },
    { key: "last-year", label: de ? "Letztes Jahr" : "Last year" },
  ];

  return (
    <div className="modal-overlay" onClick={onClose}>
      <div className="modal-box" onClick={e => e.stopPropagation()}>
        <div className="modal-head">
          <h2 className="modal-title"><Ico name="download" size={18} /> {tSafe(de, "Meldungen exportieren", "Export reports")}</h2>
          <button className="modal-close" onClick={onClose} aria-label={tSafe(de, "Schließen", "Close")}><Ico name="x" size={18} /></button>
        </div>
        <div className="modal-body">
          <label className="field-label" style={{ marginBottom: 8 }}>{tSafe(de, "Zeitraum", "Date range")}</label>
          <div className="export-presets">
            {presets.map(p => (
              <button key={p.key} className="btn btn-ghost" style={{ fontSize: 12, padding: "6px 11px" }} onClick={() => applyPreset(p.key)}>{p.label}</button>
            ))}
          </div>
          <div className="export-range">
            <div>
              <label className="field-label" htmlFor="export-from">{tSafe(de, "Von", "From")}</label>
              <input id="export-from" className="input" type="date" value={from} onChange={e => setFrom(e.target.value)} />
            </div>
            <div>
              <label className="field-label" htmlFor="export-to">{tSafe(de, "Bis", "To")}</label>
              <input id="export-to" className="input" type="date" value={to} onChange={e => setTo(e.target.value)} />
            </div>
          </div>
          <div style={{ marginTop: 18 }}>
            <label className="field-label" style={{ marginBottom: 8 }}>Format</label>
            <div className="seg">
              {["csv", "json", "pdf"].map(f => (
                <button key={f} className={"seg-btn" + (format === f ? " on" : "")} onClick={() => setFormat(f)}>
                  {f.toUpperCase()}
                </button>
              ))}
            </div>
          </div>
          <label className="consent-row" style={{ marginTop: 14 }}>
            <input type="checkbox" checked={redact} onChange={(e) => setRedact(e.target.checked)} />
            <span className="anon-box">{redact ? <Ico name="check" size={13} /> : null}</span>
            <span className="consent-text">{tSafe(de, "Personenbezogene Daten (Melder:in) entfernen", "Redact reporter personal data")}</span>
          </label>
          {err && <div className="err-line" style={{ marginTop: 10 }}><Ico name="circle-alert" size={15} /> {err}</div>}
          <button className="btn btn-primary" style={{ marginTop: 22, width: "100%" }} onClick={doExport} disabled={loading}>
            <Ico name="download" size={15} /> {loading ? "…" : (de ? "Herunterladen" : "Download")}
          </button>
        </div>
      </div>
    </div>
  );
}

/* ------------------------------------------------------------------ */
function AreaMapSection({ token, incidents, lang, selId, onSelect, cluster, canManage }) {
  const elRef = React.useRef(null);
  const mapRef = React.useRef(null);
  const incLayerRef = React.useRef(null);
  const savedLayerRef = React.useRef(null);
  const importLayerRef = React.useRef(null);
  const pendingLayerRef = React.useRef(null);
  const qgisRef = React.useRef(null);

  const [areaMode, setAreaMode] = React.useState(false);
  const [pending, setPending] = React.useState([]);
  const [saving, setSaving] = React.useState(false);
  const [qgisLoading, setQgisLoading] = React.useState(false);
  const [urlValue, setUrlValue] = React.useState("");
  const [urlLoading, setUrlLoading] = React.useState(false);
  const [err, setErr] = React.useState("");
  const [areasLoaded, setAreasLoaded] = React.useState(false);

  const de = lang === "de";

  React.useEffect(() => {
    const map = L.map(elRef.current, { center: window.MELD.center || [47.4985, 9.6365], zoom: 12, zoomControl: true, scrollWheelZoom: true });
    map.zoomControl.setPosition("bottomright");
    mapRef.current = map;

    const sat = L.tileLayer("https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}", {
      attribution: "© Esri, Maxar, Earthstar Geographics", maxZoom: 19,
    });
    const osm = L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", {
      attribution: "© OpenStreetMap contributors", maxZoom: 19,
    });
    sat.addTo(map);
    L.control.layers({ "Satellite": sat, "Street Map": osm }).addTo(map);

    savedLayerRef.current = L.layerGroup().addTo(map);
    importLayerRef.current = L.layerGroup().addTo(map);
    pendingLayerRef.current = L.layerGroup().addTo(map);

    const legend = L.control({ position: "topright" });
    legend.onAdd = function () {
      const div = L.DomUtil.create("div", "area-legend");
      div.innerHTML = `<strong>Legend</strong>
        <div><span class="leg-swatch" style="background:#3388ff;opacity:.5;border:2px solid #3388ff;"></span> Imported Areas</div>
        <div><span class="leg-swatch" style="background:transparent;border:2px dashed #22aa22;"></span> Importable Areas</div>`;
      L.DomEvent.disableClickPropagation(div);
      return div;
    };
    legend.addTo(map);

    setTimeout(() => map.invalidateSize(), 120);
    doLoadSavedAreas(map);
    return () => map.remove();
  }, []);

  React.useEffect(() => {
    const map = mapRef.current;
    if (!map) return;
    if (incLayerRef.current) map.removeLayer(incLayerRef.current);
    const canCluster = cluster && typeof L.markerClusterGroup === "function";
    const layer = canCluster
      ? L.markerClusterGroup({ showCoverageOnHover: false, maxClusterRadius: 45, disableClusteringAtZoom: 17 })
      : L.layerGroup();
    incLayerRef.current = layer;
    (incidents || []).filter(r => r.ll).forEach(r => {
      const active = r.id === selId;
      const mk = L.circleMarker(r.ll, {
        radius: active ? 13 : 10,
        fillColor: active ? "#C2613B" : "#e74c3c",
        color: "#fff", weight: active ? 3 : 2, fillOpacity: 0.95, zIndexOffset: active ? 1000 : 0,
      });
      if (onSelect) mk.on("click", () => onSelect(r.id));
      layer.addLayer(mk);
    });
    layer.addTo(map);
    if (selId) {
      const sel = (incidents || []).find(r => r.id === selId);
      if (sel && sel.ll) map.panTo(sel.ll, { animate: true });
    }
  }, [incidents, selId, cluster]);

  React.useEffect(() => {
    const layer = pendingLayerRef.current;
    if (!layer) return;
    layer.clearLayers();
    pending.forEach(a => {
      try {
        const gj = typeof a.geojson === "string" ? JSON.parse(a.geojson) : a.geojson;
        L.geoJSON(gj, { style: { color: "#3388ff", fillColor: "#3388ff", fillOpacity: 0.3, weight: 2 } }).addTo(layer);
      } catch (e) { /* ignore */ }
    });
  }, [pending]);

  async function doLoadSavedAreas(mapInst) {
    const res = await apiFetch(token, "/api/admin/areas");
    if (res.ok && res.data && res.data.success && savedLayerRef.current) {
      savedLayerRef.current.clearLayers();
      const geoLayers = [];
      res.data.areas.forEach(a => {
        try {
          const gj = JSON.parse(a.geojson);
          const l = L.geoJSON(gj, { style: { color: "#3388ff", fillColor: "#3388ff", fillOpacity: 0.3, weight: 2 } });
          l.addTo(savedLayerRef.current);
          geoLayers.push(l);
        } catch (e) { /* ignore */ }
      });
      if (geoLayers.length && mapInst) {
        const grp = L.featureGroup(geoLayers.flatMap(l => l.getLayers()));
        if (grp.getLayers().length) mapInst.fitBounds(grp.getBounds(), { padding: [40, 40] });
      }
    }
  }

  function addReservePolygon(coords, name) {
    const gj = { type: "Feature", geometry: { type: "Polygon", coordinates: [coords.map(c => [c[1], c[0]])] }, properties: { name } };
    setPending(prev => [...prev, { name, geojson: JSON.stringify(gj) }]);
  }

  function loadNatureReserves() {
    const map = mapRef.current;
    if (!map || !importLayerRef.current) return;
    const bounds = map.getBounds();
    const bbox = `${bounds.getSouth()},${bounds.getWest()},${bounds.getNorth()},${bounds.getEast()}`;
    const query = `[out:json][timeout:25];(way["leisure"="nature_reserve"](${bbox});way["boundary"="protected_area"](${bbox});relation["leisure"="nature_reserve"](${bbox});relation["boundary"="protected_area"](${bbox}););out geom;`;

    fetch("https://overpass-api.de/api/interpreter", { method: "POST", body: "data=" + encodeURIComponent(query) })
      .then(r => r.json())
      .then(data => {
        if (!importLayerRef.current) return;
        importLayerRef.current.clearLayers();
        data.elements.forEach(el => {
          const shapes = [];
          if (el.type === "way" && el.geometry) shapes.push(el.geometry.map(c => [c.lat, c.lon]));
          if (el.type === "relation" && el.members) {
            el.members.filter(m => m.role !== "inner" && m.geometry).forEach(m => {
              const ring = m.geometry.map(c => [c.lat, c.lon]);
              if (ring.length > 2) shapes.push(ring);
            });
          }
          if (!shapes.length) return;
          const name = (el.tags && el.tags.name) || "Nature Reserve";
          shapes.forEach(coords => {
            const poly = L.polygon(coords, { color: "#22aa22", fillColor: "#22aa22", fillOpacity: 0.15, weight: 2, dashArray: "5,5" });
            const div = L.DomUtil.create("div");
            const strong = document.createElement("strong"); strong.textContent = name; div.appendChild(strong);
            div.appendChild(document.createElement("br"));
            const small = document.createElement("small");
            small.textContent = de ? "Als erlaubten Bereich importieren:" : "Import as allowed area:";
            div.appendChild(small);
            const btn = document.createElement("button");
            btn.className = "area-import-pop-btn"; btn.type = "button";
            btn.textContent = de ? "Importieren" : "Import";
            L.DomEvent.on(btn, "click", (e) => { L.DomEvent.stopPropagation(e); addReservePolygon(coords, name); poly.closePopup(); });
            div.appendChild(btn);
            poly.bindPopup(div);
            importLayerRef.current.addLayer(poly);
          });
        });
      })
      .catch(e => { console.error("Overpass error", e); setErr(de ? "Schutzgebiete konnten nicht geladen werden." : "Could not load nature reserves."); });
  }

  async function enterAreaMode() {
    setErr("");
    const res = await apiFetch(token, "/api/admin/areas");
    if (!res.ok || !res.data || !res.data.success) {
      setErr(de ? "Bereiche konnten nicht geladen werden. Bitte erneut versuchen." : "Could not load areas. Please try again.");
      return;
    }
    setPending(res.data.areas.map(a => ({ name: a.name, geojson: a.geojson })));
    setAreaMode(true);
    setAreasLoaded(true);
    if (savedLayerRef.current) savedLayerRef.current.clearLayers();
    loadNatureReserves();
  }

  function exitAreaMode() {
    setAreaMode(false);
    setPending([]);
    setErr("");
    setAreasLoaded(false);
    if (importLayerRef.current) importLayerRef.current.clearLayers();
    doLoadSavedAreas(mapRef.current);
  }

  async function saveAreas() {
    if (saving || !areasLoaded) return;
    if (pending.length === 0 && !confirm(de
      ? "Alle erlaubten Bereiche wirklich entfernen? Danach sind keine Meldungen mehr möglich, bis neue Bereiche definiert werden."
      : "Really remove all allowed areas? No reports will be possible until new areas are defined.")) return;
    setSaving(true); setErr("");
    const res = await apiFetch(token, "/api/admin/areas", { method: "POST", body: JSON.stringify({ areas: pending }) });
    if (res.ok && res.data && res.data.success) exitAreaMode();
    else setErr((res.data && res.data.error) || (de ? "Speichern fehlgeschlagen" : "Save failed"));
    setSaving(false);
  }

  async function handleQGIS(e) {
    const file = e.target.files[0];
    if (!file) return;
    const ok = /\.(zip|geojson|json)$/i.test(file.name);
    if (!ok) { setErr(de ? "Nur .zip, .geojson oder .json" : "Only .zip, .geojson or .json"); return; }
    setQgisLoading(true); setErr("");
    const fd = new FormData();
    fd.append("shapefile", file);
    const res = await apiFetch(token, "/api/admin/import-qgis", { method: "POST", body: fd });
    if (res.ok && res.data && res.data.success) {
      (res.data.geojson.features || []).forEach(f => {
        if (f.geometry && (f.geometry.type === "Polygon" || f.geometry.type === "MultiPolygon")) {
          const name = (f.properties && (f.properties.name || f.properties.Name || f.properties.NAME)) || "Imported";
          setPending(prev => [...prev, { name, geojson: JSON.stringify(f) }]);
        }
      });
    } else setErr((res.data && res.data.error) || (de ? "Import fehlgeschlagen" : "Import failed"));
    setQgisLoading(false);
    if (qgisRef.current) qgisRef.current.value = "";
  }

  async function handleImportUrl() {
    if (urlLoading || !urlValue) return;
    setUrlLoading(true); setErr("");
    const res = await apiFetch(token, "/api/admin/import-url", { method: "POST", body: JSON.stringify({ url: urlValue }) });
    if (res.ok && res.data && res.data.success) {
      (res.data.geojson.features || []).forEach(f => {
        const name = (f.properties && f.properties.name) || "Imported";
        setPending(prev => [...prev, { name, geojson: JSON.stringify(f) }]);
      });
      setUrlValue("");
    } else setErr((res.data && res.data.error) || (de ? "Import fehlgeschlagen" : "Import failed"));
    setUrlLoading(false);
  }

  function exportGeoJSON() {
    const fc = {
      type: "FeatureCollection", features: (incidents || []).filter(r => r.ll).map(r => ({
        type: "Feature",
        geometry: { type: "Point", coordinates: [r.ll[1], r.ll[0]] },
        properties: { id: r.id, categories: (r.cat || []).map(c => catById(c)[lang]).join(", "), description: r.description || "", status: r.status, when: r.when },
      })),
    };
    const url = URL.createObjectURL(new Blob([JSON.stringify(fc, null, 2)], { type: "application/geo+json" }));
    const a = document.createElement("a");
    a.href = url; a.download = "meldungen.geojson"; a.click();
    setTimeout(() => URL.revokeObjectURL(url), 1000);
  }

  return (
    <div className="area-section">
      <div className="area-section-head">
        <h2 className="area-sec-title">{de ? "Vorfallkarte" : "Incident Map"}</h2>
        {!areaMode ? (
          <div style={{ display: "flex", gap: 8 }}>
            <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={exportGeoJSON}>
              <Ico name="map" size={15} /> GeoJSON
            </button>
            {canManage && (
              <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={enterAreaMode}>
                <Ico name="shapes" size={15} /> {de ? "Erlaubte Bereiche verwalten" : "Manage allowed areas"}
              </button>
            )}
          </div>
        ) : (
          <div style={{ display: "flex", gap: 8, flexWrap: "wrap" }}>
            <label className="btn btn-ghost" style={{ fontSize: 13, cursor: "pointer" }}>
              <Ico name="upload" size={15} /> {qgisLoading ? "…" : (de ? "Datei importieren" : "Import file")}
              <input ref={qgisRef} type="file" accept=".zip,.geojson,.json" hidden onChange={handleQGIS} disabled={qgisLoading} />
            </label>
            <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={() => setPending([])}
              title={de ? "Alle ausstehenden Bereiche löschen" : "Clear pending areas"}>
              <Ico name="trash-2" size={15} />
            </button>
            <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={exitAreaMode} disabled={saving}>
              {de ? "Abbrechen" : "Cancel"}
            </button>
            <button className="btn btn-primary" style={{ fontSize: 13 }} onClick={saveAreas} disabled={saving}>
              <Ico name="save" size={15} /> {saving ? "…" : (de ? (pending.length > 0 ? `${pending.length} speichern` : "Bereiche löschen") : (pending.length > 0 ? `Save ${pending.length}` : "Clear areas"))}
            </button>
          </div>
        )}
      </div>
      {areaMode && (
        <div className="notice notice-warn" style={{ marginBottom: 12 }}>
          <Ico name="info" size={16} />
          <span>{de ? "Klicke auf ein Schutzgebiet (grün gestrichelt) auf der Karte, um es zu importieren. Oder lade eine QGIS-Shapefile (.zip), GeoJSON-Datei oder eine WFS/GeoJSON-URL." : "Click a nature reserve (dashed green) on the map to import it. Or upload a QGIS shapefile (.zip), GeoJSON file, or a WFS/GeoJSON URL."}</span>
        </div>
      )}
      {areaMode && (
        <div className="import-url-row">
          <input className="input" style={{ flex: 1 }} placeholder={de ? "WFS- oder GeoJSON-URL (outputFormat=application/json)" : "WFS or GeoJSON URL (outputFormat=application/json)"}
            value={urlValue} onChange={e => setUrlValue(e.target.value)}
            onKeyDown={e => e.key === "Enter" && handleImportUrl()} />
          <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={handleImportUrl} disabled={urlLoading || !urlValue}>
            <Ico name="link" size={15} /> {urlLoading ? "…" : (de ? "Von URL laden" : "Load from URL")}
          </button>
        </div>
      )}
      {err && <div className="err-line" style={{ marginBottom: 10 }}><Ico name="circle-alert" size={15} /> {err}</div>}
      <div ref={elRef} className="area-map-el"></div>
      {areaMode && pending.length > 0 && (
        <div className="pending-areas">
          {pending.map((a, i) => (
            <div key={i} className="pending-area-item">
              <Ico name="map" size={14} /> <span>{a.name}</span>
              <button className="file-x" aria-label={de ? "Entfernen" : "Remove"} onClick={() => setPending(p => p.filter((_, j) => j !== i))}>
                <Ico name="x" size={12} />
              </button>
            </div>
          ))}
        </div>
      )}
    </div>
  );
}

/* ------------------------------------------------------------------ */
function LoginForm({ t, lang, onLogin }) {
  const [user, setUser] = React.useState("admin");
  const [pass, setPass] = React.useState("");
  const [loading, setLoading] = React.useState(false);
  const [err, setErr] = React.useState("");

  async function doLogin() {
    if (!pass) return;
    setLoading(true); setErr("");
    const res = await apiFetch("", "/api/admin/login", { method: "POST", body: JSON.stringify({ username: user, password: pass }) });
    if (res.ok && res.data && res.data.success) onLogin(res.data.token, res.data.role || user);
    else { setErr((res.data && res.data.error) || "Login failed"); setLoading(false); }
  }

  return (
    <div className="admin">
      <div style={{ maxWidth: 400, margin: "80px auto", textAlign: "center" }} className="anim-pop">
        <div className="success-mark" style={{ background: "var(--moss-deep)", margin: "0 auto 24px" }}>
          <Ico name="lock" size={32} />
        </div>
        <h2 className="display" style={{ fontSize: 28, color: "var(--moss-deep)", marginBottom: 6 }}>{t.admin_login}</h2>
        <p style={{ color: "var(--ink-2)", marginBottom: 28 }}>{t.admin_sub}</p>
        <div className="card" style={{ padding: 24, textAlign: "left" }}>
          <div style={{ marginBottom: 16 }}>
            <label className="field-label" htmlFor="admin-user">{t.admin_username}</label>
            <select id="admin-user" className="input" value={user} onChange={(e) => setUser(e.target.value)}>
              <option value="admin">admin</option>
              <option value="observer">observer</option>
            </select>
          </div>
          <div style={{ marginBottom: 20 }}>
            <label className="field-label" htmlFor="admin-pass">{t.admin_password}</label>
            <input id="admin-pass" className="input" type="password" value={pass} autoFocus
              onChange={(e) => setPass(e.target.value)} onKeyDown={(e) => e.key === "Enter" && doLogin()} />
          </div>
          {err && <div className="err-line" style={{ marginBottom: 12 }}><Ico name="circle-alert" size={15} /> {err}</div>}
          <button className="btn btn-primary" style={{ width: "100%" }} onClick={doLogin} disabled={loading || !pass}>
            {loading ? <Ico name="loader" size={16} /> : <Ico name="log-in" size={16} />} {t.admin_login}
          </button>
        </div>
      </div>
    </div>
  );
}

function StatusBadge({ status, t }) {
  const map = { new: t.st_new, review: t.st_review, resolved: t.st_resolved };
  return <span className={"badge badge-" + status}>{map[status] || status}</span>;
}

function NotifModal({ token, lang, onClose }) {
  const de = lang === "de";
  return (
    <div className="modal-overlay" onClick={onClose}>
      <div className="modal-box" onClick={e => e.stopPropagation()}>
        <div className="modal-head">
          <h2 className="modal-title"><Ico name="bell" size={18} /> {tSafe(de, "Benachrichtigungs-E-Mails", "Notification Emails")}</h2>
          <button className="modal-close" onClick={onClose} aria-label={tSafe(de, "Schließen", "Close")}><Ico name="x" size={18} /></button>
        </div>
        <div className="modal-body">
          <EmailList token={token} lang={lang} />
        </div>
      </div>
    </div>
  );
}

function StatCard({ icon, label, value, sub }) {
  return (
    <div className="stat-card">
      <span className="stat-ico"><Ico name={icon} size={18} /></span>
      <div className="stat-val">{value}</div>
      <div className="stat-label">{label}</div>
      {sub && <div className="stat-sub">{sub}</div>}
    </div>
  );
}

/* ------------------------------------------------------------------ */
function AdminPanel({ lang, t }) {
  const [token, setToken] = React.useState(() => sessionStorage.getItem("meld_admin_token") || "");
  const [role, setRole] = React.useState(() => sessionStorage.getItem("meld_admin_role") || "");
  const [incidents, setIncidents] = React.useState([]);
  const [loading, setLoading] = React.useState(false);
  const [sel, setSel] = React.useState(null);
  const [overrides, setOverrides] = React.useState({});
  const [statusFilter, setStatusFilter] = React.useState("all");
  const [catFilter, setCatFilter] = React.useState("all");
  const [q, setQ] = React.useState("");
  const [notifOpen, setNotifOpen] = React.useState(false);
  const [exportOpen, setExportOpen] = React.useState(false);
  const [binOpen, setBinOpen] = React.useState(false);
  const [cluster, setCluster] = React.useState(() => localStorage.getItem("meld_cluster") !== "0");
  const [toast, setToast] = React.useState("");
  const de = lang === "de";
  const isAdmin = role === "admin";
  const langRef = React.useRef(lang);
  React.useEffect(() => { langRef.current = lang; }, [lang]);

  const withStatus = (r) => overrides[r.id] !== undefined ? overrides[r.id] : r.status;

  function logout() {
    sessionStorage.removeItem("meld_admin_token");
    sessionStorage.removeItem("meld_admin_role");
    setToken(""); setRole(""); setIncidents([]); setSel(null); setOverrides({});
  }

  function flash(msg) { setToast(msg); setTimeout(() => setToast(""), 3000); }

  const fetchIncidents = React.useCallback(async (tok) => {
    setLoading(true);
    const res = await apiFetch(tok, "/api/admin/incidents");
    if (res.ok && res.data && res.data.success) {
      const transformed = res.data.incidents.map(transformIncident);
      setIncidents(transformed);
      setSel((cur) => (cur && transformed.some((r) => r.id === cur)) ? cur : (transformed.length ? transformed[0].id : null));
    } else if (res.status === 401) {
      logout();
    } else {
      flash(langRef.current === "de" ? "Meldungen konnten nicht geladen werden." : "Could not load reports.");
    }
    setLoading(false);
  }, []);

  React.useEffect(() => { if (token) fetchIncidents(token); }, [token, fetchIncidents]);
  React.useEffect(() => { localStorage.setItem("meld_cluster", cluster ? "1" : "0"); }, [cluster]);

  async function updateStatus(reportId, newStatus) {
    const report = incidents.find((r) => r.id === reportId);
    if (!report) return;
    const previous = withStatus(report);
    setOverrides((o) => ({ ...o, [reportId]: newStatus }));
    const res = await apiFetch(token, `/api/admin/incidents/${report._id}/status`, { method: "PUT", body: JSON.stringify({ status: newStatus }) });
    if (!res.ok) {
      setOverrides((o) => {
        const n = { ...o };
        if (previous === report.status) delete n[reportId]; else n[reportId] = previous;
        return n;
      });
      flash(res.status === 401 ? (de ? "Keine Berechtigung." : "Not authorized.") : (de ? "Status konnte nicht geändert werden." : "Could not update status."));
    } else {
      setIncidents((prev) => prev.map((r) => r.id === reportId ? { ...r, status: newStatus } : r));
      setOverrides((o) => { const n = { ...o }; delete n[reportId]; return n; });
    }
  }

  async function deleteIncident(reportId) {
    const report = incidents.find((r) => r.id === reportId);
    if (!report) return;
    if (!confirm(t.delete_confirm)) return;
    const res = await apiFetch(token, `/api/admin/incidents/${report._id}`, { method: "DELETE" });
    if (!res.ok) { flash(de ? "Löschen fehlgeschlagen." : "Delete failed."); return; }
    setIncidents((prev) => {
      const remaining = prev.filter((r) => r.id !== reportId);
      setSel((cur) => cur === reportId ? (remaining.length ? remaining[0].id : null) : cur);
      return remaining;
    });
    setOverrides((o) => { const n = { ...o }; delete n[reportId]; return n; });
  }

  async function redactIncident(reportId) {
    const report = incidents.find((r) => r.id === reportId);
    if (!report) return;
    if (!confirm(de ? "Personenbezogene Daten endgültig entfernen?" : "Permanently remove reporter personal data?")) return;
    const res = await apiFetch(token, `/api/admin/incidents/${report._id}/redact`, { method: "POST" });
    if (!res.ok) { flash(de ? "Anonymisierung fehlgeschlagen." : "Redaction failed."); return; }
    setIncidents((prev) => prev.map((r) => r.id === reportId ? { ...r, anon: true, name: null, email: null, phone: null, redacted: true } : r));
    flash(de ? "Daten anonymisiert." : "Data redacted.");
  }

  async function assignIncident(reportId, assignedTo) {
    const report = incidents.find((r) => r.id === reportId);
    if (!report) return;
    const res = await apiFetch(token, `/api/admin/incidents/${report._id}/assign`, { method: "PUT", body: JSON.stringify({ assignedTo }) });
    if (res.ok) setIncidents((prev) => prev.map((r) => r.id === reportId ? { ...r, assignedTo } : r));
    else flash(de ? "Zuweisung fehlgeschlagen." : "Assignment failed.");
  }

  if (!token) {
    return (
      <LoginForm t={t} lang={lang} onLogin={(tok, r) => {
        sessionStorage.setItem("meld_admin_token", tok);
        sessionStorage.setItem("meld_admin_role", r || "admin");
        setToken(tok); setRole(r || "admin");
      }} />
    );
  }

  const filtered = incidents.filter((r) => {
    if (statusFilter !== "all" && withStatus(r) !== statusFilter) return false;
    if (catFilter !== "all" && !r.cat.includes(catFilter)) return false;
    if (q) {
      const hay = ([r.description, r.id, r.cat.map((c) => catById(c)[lang]).join(" ")]).join(" ").toLowerCase();
      if (!hay.includes(q.toLowerCase())) return false;
    }
    return true;
  });

  const weekAgo = Date.now() - 7 * 86400000;
  const counts = {
    total: incidents.length,
    new: incidents.filter((r) => withStatus(r) === "new").length,
    week: incidents.filter((r) => { const d = parseWhen(r.when); return d && d.getTime() >= weekAgo; }).length,
  };
  const tally = {};
  incidents.forEach((r) => r.cat.forEach((c) => (tally[c] = (tally[c] || 0) + 1)));
  const topCat = Object.entries(tally).sort((a, b) => b[1] - a[1])[0];

  const selReport = incidents.find((r) => r.id === sel);

  return (
    <div className="admin">
      {notifOpen && <NotifModal t={t} token={token} lang={lang} onClose={() => setNotifOpen(false)} />}
      {exportOpen && <ExportModal token={token} lang={lang} onClose={() => setExportOpen(false)} />}
      {binOpen && <BinModal token={token} lang={lang} onClose={() => setBinOpen(false)} onRestored={() => fetchIncidents(token)} />}
      <div className="admin-head">
        <div>
          <div className="eyebrow">{t.admin_sub}</div>
          <h1 className="display admin-h1">{t.admin_title}</h1>
        </div>
        <div style={{ display: "flex", gap: 8, alignItems: "center", flexWrap: "wrap" }}>
          {isAdmin && (
            <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={() => setBinOpen(true)}>
              <Ico name="trash-2" size={15} /> {de ? "Papierkorb" : "Bin"}
            </button>
          )}
          {isAdmin && (
            <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={() => setNotifOpen(true)}>
              <Ico name="bell" size={15} /> {de ? "Benachrichtigungen" : "Notifications"}
            </button>
          )}
          <button className="btn btn-ghost" onClick={logout} style={{ fontSize: 13 }}>
            <Ico name="log-out" size={15} /> {t.admin_logout}
          </button>
        </div>
      </div>

      {toast && <div className="admin-toast"><Ico name="info" size={15} /> {toast}</div>}

      {loading ? (
        <div className="admin-loading"><Ico name="loader" size={20} /> {t.loading}</div>
      ) : (
        <>
          <div className="stat-row">
            <StatCard icon="layers" label={t.a_total} value={counts.total} />
            <StatCard icon="bell-dot" label={t.a_new} value={counts.new} />
            <StatCard icon="calendar-days" label={t.a_week} value={counts.week} />
            <StatCard icon={topCat ? catById(topCat[0]).icon : "circle-help"} label={t.a_hot}
              value={topCat ? catById(topCat[0])[lang] : "—"} sub={topCat ? topCat[1] + " ×" : null} />
          </div>

          <div className="admin-toolbar">
            <div className="search-box">
              <Ico name="search" size={16} />
              <input className="search-in" placeholder={t.f_search} value={q} onChange={(e) => setQ(e.target.value)} aria-label={t.f_search} />
            </div>
            <div className="filter-segs">
              {["all", "new", "review", "resolved"].map((s) => (
                <button key={s} className={"fseg" + (statusFilter === s ? " on" : "")} onClick={() => setStatusFilter(s)}>
                  {s === "all" ? t.a_filter_all : { new: t.st_new, review: t.st_review, resolved: t.st_resolved }[s]}
                </button>
              ))}
            </div>
            <select className="input cat-select" value={catFilter} onChange={(e) => setCatFilter(e.target.value)} aria-label={t.f_category}>
              <option value="all">{t.f_category}: {t.a_filter_all}</option>
              {window.MELD.categories.map((c) => (<option key={c.id} value={c.id}>{c[lang]}</option>))}
            </select>
            <button className={"btn btn-ghost" + (cluster ? " on" : "")} style={{ fontSize: 13 }} onClick={() => setCluster(c => !c)}
              aria-pressed={cluster} title={de ? "Marker gruppieren" : "Cluster markers"}>
              <Ico name="group" size={15} /> {de ? "Cluster" : "Cluster"}: {cluster ? "On" : "Off"}
            </button>
            <div className="export-btns">
              <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={() => setExportOpen(true)}>
                <Ico name="download" size={15} /> {de ? "Exportieren" : "Export"}
              </button>
            </div>
          </div>

          <div className="admin-workspace">
            <div className="admin-map-col">
              <AreaMapSection token={token} incidents={incidents} lang={lang} selId={sel} onSelect={setSel} cluster={cluster} canManage={isAdmin} />
            </div>

            <div className="admin-right-col">
              <div className="admin-list">
                <div className="list-count">{filtered.length} {t.of_reports}</div>
                {filtered.map((r) => (
                  <button key={r.id} className={"rep-row" + (r.id === sel ? " sel" : "")} onClick={() => setSel(r.id)}>
                    <div className="rep-icos">
                      {r.cat.slice(0, 2).map((c) => (<span key={c} className="rep-ico"><Ico name={catById(c).icon} size={16} /></span>))}
                    </div>
                    <div className="rep-main">
                      <div className="rep-top">
                        <span className="rep-cat">{r.cat.length ? r.cat.map((c) => catById(c)[lang]).join(" · ") : t.no_categories}</span>
                        <StatusBadge status={withStatus(r)} t={t} />
                      </div>
                      <div className="rep-meta">
                        {r.ll && <span><Ico name="map-pin" size={12} /> {r.ll[0].toFixed(4)}, {r.ll[1].toFixed(4)}</span>}
                        <span><Ico name="clock" size={12} /> {fmtWhen(r.when, lang)}</span>
                        {r.ev > 0 && <span><Ico name="paperclip" size={12} /> {r.ev}</span>}
                        {r.assignedTo && <span><Ico name="user-check" size={12} /> {r.assignedTo}</span>}
                      </div>
                    </div>
                  </button>
                ))}
                {filtered.length === 0 && (
                  <div style={{ padding: "30px 16px", color: "var(--ink-3)", fontSize: 14, textAlign: "center" }}>
                    {incidents.length === 0 ? "—" : (de ? "Keine Meldungen gefunden." : "No reports found.")}
                  </div>
                )}
              </div>

              <div className="admin-detail-slot">
                {selReport ? (
                  <div className="detail-card anim-up" key={selReport.id}>
                    <div className="detail-card-head">
                      <div>
                        <span className="detail-id">{selReport.id}</span>
                        <div className="detail-cats">
                          {selReport.cat.map((c) => (
                            <span key={c} className="dcat"><Ico name={catById(c).icon} size={14} /> {catById(c)[lang]}</span>
                          ))}
                        </div>
                      </div>
                      <div style={{ display: "flex", alignItems: "center", gap: 8 }}>
                        <StatusBadge status={withStatus(selReport)} t={t} />
                        <button className="modal-close" onClick={() => setSel(null)} aria-label={de ? "Schließen" : "Close"}><Ico name="x" size={16} /></button>
                      </div>
                    </div>

                    <div className="detail-meta">
                      {selReport.ll && <span><Ico name="map-pin" size={14} /> {selReport.ll[0].toFixed(5)}, {selReport.ll[1].toFixed(5)}</span>}
                      <span><Ico name="clock" size={14} /> {fmtWhen(selReport.when, lang)}</span>
                      <span><Ico name="user" size={14} /> {selReport.anon ? t.detail_anon : selReport.name || t.detail_anon}</span>
                      {selReport.email && <span><Ico name="mail" size={14} /> {selReport.email}</span>}
                      {selReport.phone && <span><Ico name="phone" size={14} /> {selReport.phone}</span>}
                      {selReport.redacted && <span><Ico name="shield" size={14} /> {de ? "anonymisiert" : "redacted"}</span>}
                    </div>

                    <div className="detail-block">
                      <div className="detail-k">{t.detail_desc}</div>
                      <p className="detail-desc">{selReport.description || "—"}</p>
                    </div>

                    <div className="detail-block">
                      <div className="detail-k">{de ? "Belege" : "Evidence"} ({selReport.ev})</div>
                      <EvidenceGallery files={selReport.files} t={t} lang={lang} />
                    </div>

                    {isAdmin && (
                      <div className="detail-block">
                        <div className="detail-k">{de ? "Zuständig" : "Assignee"}</div>
                        <input className="input" style={{ marginTop: 6 }} placeholder={de ? "Name …" : "Name …"}
                          defaultValue={selReport.assignedTo || ""}
                          onBlur={(e) => { if (e.target.value !== (selReport.assignedTo || "")) assignIncident(selReport.id, e.target.value); }}
                          onKeyDown={(e) => { if (e.key === "Enter") e.target.blur(); }} />
                      </div>
                    )}

                    <div className="detail-block">
                      <div className="detail-k">{t.detail_setstatus}</div>
                      <div className="status-set">
                        {["new", "review", "resolved"].map((s) => (
                          <button key={s}
                            className={"set-btn set-" + s + (withStatus(selReport) === s ? " on" : "")}
                            disabled={!isAdmin}
                            onClick={() => updateStatus(selReport.id, s)}>
                            {{ new: t.st_new, review: t.st_review, resolved: t.st_resolved }[s]}
                          </button>
                        ))}
                      </div>
                    </div>

                    <div className="detail-block">
                      <div className="detail-k">{de ? "Verlauf" : "History"}</div>
                      <IncidentHistory token={token} incidentId={selReport._id} lang={lang}
                        onChanged={() => fetchIncidents(token)} />
                    </div>

                    {isAdmin && (
                      <div className="detail-actions">
                        <button className="btn-danger" onClick={() => deleteIncident(selReport.id)}>
                          <Ico name="trash-2" size={14} /> {t.delete_btn}
                        </button>
                        {!selReport.redacted && (
                          <button className="btn-danger" onClick={() => redactIncident(selReport.id)}>
                            <Ico name="shield" size={14} /> {de ? "Daten anonymisieren" : "Redact PII"}
                          </button>
                        )}
                      </div>
                    )}
                  </div>
                ) : (
                  <div className="detail-empty">{t.detail_none}</div>
                )}
              </div>
            </div>
          </div>
        </>
      )}
    </div>
  );
}

window.AdminPanel = AdminPanel;
