// Certify Unified — certificate detail, people (owners & contacts), about Certify.
const { useState: pS } = React;
const mailsOf = (s, certId) => {
  const c = byId(s.certs, certId); const own = c && c.ownerId && byId(s.collectors, c.ownerId);
  const base = c && c.invite === "sent" && own ? [{ id: "m-" + c.id, certId: c.id, to: own.email, toName: own.name, kind: "invite", at: c.issuedAt, status: "Consegnata" }] : [];
  return [...base, ...(s.mails || []).filter((m) => m.certId === certId)];
};
const MAILK = { invite: "Invito a ricevere l'autentica", reminder: "Promemoria", transfer: "Trasferimento approvato" };

function CertPage() {
  const { s, go, mut, say } = useC(); const c = byId(s.certs, s.route.id); const [mail, setMail] = pS(null); const [as, setAs] = pS(false); const [own, setOwn] = pS("");
  if (!c) return <div className="page"><div className="empty">Autentica non trovata.</div></div>;
  const a = byId(s.works, c.artworkId); const o = c.ownerId && byId(s.collectors, c.ownerId);
  const M = mailsOf(s, c.id); const T = s.transfers.filter((t) => t.certId === c.id);
  const E = s.events.filter((e) => e.text && e.text.includes(c.id));
  const send = (kind) => { mut((n) => { n.mails = n.mails || []; n.mails.push({ id: "m" + Date.now(), certId: c.id, to: o.email, toName: o.name, kind, at: today(), status: "Inviata" }); log(n, { type: "proprieta", artworkId: a.id, text: `${MAILK[kind]} inviato a ${o.name} · ${c.id}` }); }); say("Email inviata (simulata)"); };
  const ST = { issued: ["ok", "Valida"], revoked: ["bad", "Revocata"], superseded: ["lt", "Sostituita"] }[c.status];
  return <div className="page wide">
    <button className="lnk back" onClick={() => go({ v: "archive", p: "certs" })}><Ic.back /> Autentiche</button>
    <div className="cpg">
      <div className="cpg-l"><CertDoc snap={c.snapshot} id={c.id} issuedAt={c.issuedAt} a={a} /></div>
      <div className="cpg-r">
        <div className="ph-k">Certificato digitale di autenticità</div><h1 className="cpg-t">{c.id}</h1>
        <div className="row" style={{ flexWrap: "wrap", marginBottom: 18 }}><Pill k={ST[0]}>{ST[1]}</Pill><OwnPill c={c} />{c.fee && <Pill k="lt">Segreteria {c.fee.amount} {c.fee.cur} · {({ none: "Non richiesto", due: "Da pagare", processing: "Pagamento in corso", paid: "Pagato", refunded: "Rimborsato" })[c.payment || "none"]}</Pill>}{c.replaces && <Pill k="lt">Rettifica di {c.replaces}</Pill>}{c.replacedBy && <Pill k="lt">Sostituito da {c.replacedBy}</Pill>}</div>
        <div className="cpg-a">
          <Btn k="dark" onClick={() => go({ v: "verify", id: c.id })}><Ic.qr /> Verifica pubblica</Btn>
          <Btn onClick={() => say("PDF del certificato scaricato (simulato)")}><Ic.up /> Scarica PDF</Btn>
          <Btn onClick={() => go({ v: "archive", p: "work", id: a.id, tab: "auth" })}>Apri l'opera</Btn>
        </div>
        <section className="cpg-s"><h2>Opera certificata</h2>
          <button className="cpg-w" onClick={() => go({ v: "archive", p: "work", id: a.id })}><div><Art a={a} label={false} r={0} /></div><span><b>{c.snapshot.title}</b><em>{c.snapshot.artist} · {c.snapshot.year} · {c.snapshot.catNo}</em></span><Ic.chev /></button></section>
        <section className="cpg-s"><TxExplain c={c} /></section>
        <section className="cpg-s"><CertFacts c={c} a={a} /><div className="dr" style={{ marginTop: 8 }}><span>Nel catalogo pubblico</span><Tg on={c.public} onClick={() => mut((n) => { byId(n.certs, c.id).public = !c.public; })} label={c.public ? "Visibile" : "Nascosta"} /></div></section>
        <section className="cpg-s"><h2>Proprietario</h2>
          {o ? <><button className="cpg-p" onClick={() => go({ v: "archive", p: "collectors", id: o.id })}><span className="av">{o.name.split(" ").map((w) => w[0]).slice(0, 2).join("")}</span><span><b>{o.name}</b><em>{o.email}{o.city ? " · " + o.city : ""}</em></span><Ic.chev /></button>
            <div className="hint">Titolare registrato del certificato. Non equivale da solo a una prova giuridica di proprietà dell'opera.</div></>
          : c.status === "issued" ? (as ? <div className="row" style={{ marginTop: 6 }}><select value={own} onChange={(e) => setOwn(e.target.value)}><option value="">Scegli un collezionista…</option>{s.collectors.map((k) => <option key={k.id} value={k.id}>{k.name}</option>)}</select><Btn k="dark" disabled={!own} onClick={() => { mut((n) => { const x = byId(n.certs, c.id); x.ownerId = own; x.invite = "sent"; log(n, { type: "proprieta", artworkId: a.id, text: `${c.id} assegnata a ${byId(n.collectors, own).name}` }); }); setAs(false); say("Assegnata · invito inviato"); }}>Assegna</Btn></div>
            : <div className="empty">Non assegnato. <button className="lnk" onClick={() => setAs(true)}>Assegna a un collezionista</button></div>) : <div className="empty">Nessun proprietario.</div>}</section>
        <section className="cpg-s"><h2>Comunicazioni<span>{M.length}</span></h2>
          {M.map((m) => <button key={m.id} className="cpg-m" onClick={() => setMail(m)}><span className="file">MAIL</span><span><b>{MAILK[m.kind]}</b><em>A {m.toName} · {m.at}</em></span><Pill k="ok">{m.status}</Pill></button>)}
          {!M.length && <div className="empty">Nessuna email inviata.</div>}
          {o && c.status === "issued" && <div className="row" style={{ marginTop: 10 }}><Btn k="sm" onClick={() => send("reminder")}>Invia un promemoria</Btn></div>}</section>
        <section className="cpg-s"><h2>Cronologia</h2>
          {[...E.map((e) => [e.at, e.text]), ...T.map((t) => [t.at, `Trasferimento a ${t.toName} · ${{ requested: "in attesa", approved: "approvato", rejected: "respinto" }[t.status]}`])].map(([at, t], i) => <div key={i} className="ev"><span className="ev-d autentica"></span><div><b>{t}</b><span>{at}</span></div></div>)}
          {!E.length && !T.length && <div className="empty">Nessun evento.</div>}</section>
      </div>
    </div>
    {mail && <Modal w={640} title={MAILK[mail.kind]} onClose={() => setMail(null)}><Email a={a} id={c.id} c={o || { name: mail.toName, email: mail.to, id: "" }} /></Modal>}
  </div>;
}

function People() {
  const { s, mut, go, say } = useC(); const sel = s.route.id && byId(s.collectors, s.route.id);
  const [f, setF] = pS("all"); const [q, setQ] = pS(""); const [add, setAdd] = pS(s.route.create ? { name: "", email: "", city: "" } : null); const [ed, setEd] = pS(null);
  const reqs = s.transfers.filter((t) => t.status === "requested");
  const owned = (id) => s.certs.filter((c) => c.ownerId === id && c.status === "issued");
  const decide = (t, ok) => { mut((n) => { const x = byId(n.transfers, t.id); x.status = ok ? "approved" : "rejected"; const c = byId(n.certs, t.certId);
    if (ok) { let to = n.collectors.find((k) => k.email === t.toEmail); if (!to) { to = { id: "c" + Date.now(), name: t.toName, email: t.toEmail, city: "" }; n.collectors.push(to); } c.ownerId = to.id; c.invite = "sent"; n.mails = n.mails || []; n.mails.push({ id: "m" + Date.now(), certId: c.id, to: to.email, toName: to.name, kind: "transfer", at: today(), status: "Inviata" }); byId(n.works, c.artworkId).provenance.push({ who: "Collezione privata", when: new Date().getFullYear() + "–oggi", show: "anon" }); }
    log(n, { type: "proprieta", artworkId: c.artworkId, text: `Trasferimento ${ok ? "approvato" : "respinto"}: ${t.toName} · ${c.id}` }); }); say(ok ? "Trasferimento approvato · nuovo proprietario avvisato" : "Trasferimento respinto"); };
  if (sel) { const C = owned(sel.id); const T = s.transfers.filter((t) => t.from === sel.id || C.some((c) => c.id === t.certId));
    const save = () => { mut((n) => { Object.assign(byId(n.collectors, sel.id), ed); log(n, { type: "proprieta", text: `Collezionista aggiornato: ${ed.name}` }); }); setEd(null); say("Collezionista aggiornato"); };
    const RQ = (s.requests || []).filter((r) => r.email && sel.email && r.email.toLowerCase() === sel.email.toLowerCase());
    const pend = RQ.filter((r) => !["approved", "rejected", "archived", "done"].includes(r.status));
    const last = s.events.find((e) => e.text && e.text.includes(sel.name)); const rel = C.length ? "Attiva" : pend.length ? "In attesa" : "Inattiva";
    const AW = [...C.map((c) => ({ k: c.id, a: byId(s.works, c.artworkId), st: "ok", go: () => go({ v: "archive", p: "cert", id: c.id }) })), ...pend.map((r) => ({ k: r.id, a: r.workId && byId(s.works, r.workId), r, st: "pend", go: () => go({ v: "archive", p: "request", id: r.id }) }))];
    return <div className="page cl"><button className="lnk back" onClick={() => go({ v: "archive", p: "collectors" })}><Ic.back /> Collezionisti</button>
      <div className="cl-p">
        <div className="cl-ph"><span className="cl-av">{sel.name.split(" ").map((w) => w[0]).slice(0, 2).join("")}</span><div className="grow"><h1>{sel.name}</h1><p>{sel.kind || "Collezionista privato"}{sel.city ? " · " + sel.city : ""}</p><p className="mono">{sel.email}</p></div>
          <div className="row"><Btn onClick={() => go({ v: "collector", p: "home", cid: sel.id })}>Vedi il suo portale</Btn><Btn k="dark" onClick={() => setEd({ name: sel.name, email: sel.email, city: sel.city || "", phone: sel.phone || "", notes: sel.notes || "", kind: sel.kind || "Collezionista privato" })}>Modifica</Btn></div></div>
        <div className="cl-st">{[["Opere registrate", `${C.length + pend.length} ${C.length + pend.length === 1 ? "opera" : "opere"}`], ["Autentiche emesse", `${C.length} ${C.length === 1 ? "autentica" : "autentiche"}`], ["Ultima interazione", last ? last.at.split(" · ")[0] : "—"], ["Relazione", rel]].map(([k, v]) => <div key={k}><span>{k}</span><b className={k === "Relazione" ? "rel " + rel.toLowerCase().replace(" ", "-") : ""}>{v}</b></div>)}</div>
        <div className="cl-aw"><h3>Opere associate</h3>
          {AW.map((x) => <button key={x.k} className="cl-w" onClick={x.go}><div className="cl-wi">{x.a ? <Art a={x.a} label={false} r={0} /> : <span></span>}</div><div className="grow"><b>{x.a ? x.a.title : (x.r.title || "Opera in richiesta")}{x.a && x.a.catNo ? <em className="mono"> #{x.a.catNo}</em> : null}</b><span>{x.a ? [x.a.yearLabel || x.a.year, x.a.medium].filter(Boolean).join(" · ") : "In attesa di esame"}</span>
            <i className={"cl-s " + x.st}>{x.st === "ok" ? <><Ic.check /> Autenticata</> : <><Ic.clock /> Autenticazione in corso</>}</i></div><Ic.chev /></button>)}
          {!AW.length && <div className="empty">Nessuna opera associata.</div>}</div>
      </div>
      <div className="g2" style={{ alignItems: "start", marginTop: 20 }}>
        <div className="card"><div className="c-h"><h2>Recapiti</h2><Ic.lock /></div>
          <div className="dr"><span>Email</span><b>{sel.email || "—"}</b></div><div className="dr"><span>Telefono</span><b>{sel.phone || "—"}</b></div><div className="dr"><span>Città</span><b>{sel.city || "—"}</b></div><div className="dr"><span>Note riservate</span><b>{sel.notes || "—"}</b></div>
          <div className="hint">Non vengono mai pubblicati. Nel catalogo il proprietario compare al massimo come «Collezione privata».</div></div>
        <div className="card"><div className="c-h"><h2>Trasferimenti</h2></div>{T.map((t) => <div key={t.id} className="li"><div className="grow"><b>{t.toName}</b><div className="mut sm">{t.at}</div></div><Pill k={t.status === "approved" ? "ok" : t.status === "rejected" ? "bad" : "warn"}>{{ requested: "In attesa", approved: "Approvato", rejected: "Respinto" }[t.status]}</Pill></div>)}{!T.length && <div className="empty">Nessun trasferimento.</div>}</div>
      </div>
      {ed && <Modal title="Modifica collezionista" onClose={() => setEd(null)} foot={<><Btn onClick={() => setEd(null)}>Annulla</Btn><Btn k="dark" disabled={!ed.name.trim()} onClick={save}>Salva</Btn></>}>
        <label className="fld"><span>Tipo</span><select value={ed.kind} onChange={(e) => setEd({ ...ed, kind: e.target.value })}>{["Collezionista privato", "Galleria", "Istituzione", "Fondazione", "Casa d'aste"].map((x) => <option key={x}>{x}</option>)}</select></label>{[["name", "Nome e cognome"], ["email", "Email"], ["phone", "Telefono"], ["city", "Città"]].map(([k, l]) => <label key={k} className="fld"><span>{l}</span><input value={ed[k]} onChange={(e) => setEd({ ...ed, [k]: e.target.value })} /></label>)}
        <label className="fld"><span>Note riservate</span><textarea rows={3} value={ed.notes} onChange={(e) => setEd({ ...ed, notes: e.target.value })} /></label></Modal>}
    </div>; }
  const L = s.collectors.filter((k) => (f === "all" || (f === "owners" ? owned(k.id).length : !owned(k.id).length)) && (k.name + k.email + (k.city || "")).toLowerCase().includes(q.toLowerCase()));
  return <div className="page"><PH t="Collezionisti" sub="I collezionisti dell'archivio e le autentiche a loro intestate. Sezione privata." right={<Btn k="dark" onClick={() => setAdd({ name: "", email: "", city: "" })}><Ic.plus /> Nuovo collezionista</Btn>} />
    {(() => { const iss = s.certs.filter((c) => c.status === "issued"); const linked = new Set(iss.filter((c) => c.ownerId).map((c) => c.artworkId)).size; return <div className="cl-k">{[[s.collectors.length, "Collezionisti"], [linked, "Opere collegate"], [iss.filter((c) => c.ownerId).length, "Autentiche intestate"]].map(([v, l]) => <div key={l}><b>{v.toLocaleString("it-IT")}</b><span>{l}</span></div>)}</div>; })()}
    {reqs.length > 0 && <div className="card" style={{ marginBottom: 20 }}><div className="c-h"><h2>Richieste di trasferimento</h2><Pill k="warn">{reqs.length} da approvare</Pill></div>{reqs.map((t) => { const c = byId(s.certs, t.certId); const a = byId(s.works, c.artworkId); return <div key={t.id} className="li"><div style={{ width: 44, height: 44 }}><Art a={a} label={false} r={6} /></div><div className="grow"><b>{a.title}</b><div className="mut sm">{byId(s.collectors, t.from).name} → {t.toName} ({t.toEmail}) · {t.at}</div>{t.note && <div className="sm">«{t.note}»</div>}</div><Btn k="sm" onClick={() => decide(t, false)}>Respingi</Btn><Btn k="sm dark" onClick={() => decide(t, true)}>Approva</Btn></div>; })}</div>}
    <div className="tools"><label className="search"><Ic.search /><input value={q} onChange={(e) => setQ(e.target.value)} placeholder="Cerca per nome, email, città…" /></label><div className="seg">{[["all", "Tutti"], ["owners", "Con autentiche"], ["none", "Senza autentiche"]].map(([k, l]) => <button key={k} className={f === k ? "on" : ""} onClick={() => setF(k)}>{l}</button>)}</div></div>
    <div className="tbl"><table><thead><tr><th>Nome</th><th>Tipo</th><th>Città</th><th>Autentiche</th><th>Ultima attività</th></tr></thead><tbody>{L.map((k) => { const C = owned(k.id); const ev = s.events.find((e) => e.text && e.text.includes(k.name)); return <tr key={k.id} onClick={() => go({ v: "archive", p: "collectors", id: k.id })}><td><div className="row"><span className="av">{k.name.split(" ").map((w) => w[0]).slice(0, 2).join("")}</span><span><b>{k.name}</b><div className="mut sm">{k.email}</div></span></div></td><td>{k.kind || "Collezionista privato"}</td><td>{k.city || "—"}</td><td>{C.length || <span className="mut">—</span>}</td><td className="mut sm">{ev ? ev.at.split(" · ")[0] : "—"}</td></tr>; })}</tbody></table></div>
    {!L.length && <div className="empty">Nessun collezionista.</div>}
    {add && <Modal title="Nuovo collezionista" onClose={() => setAdd(null)} foot={<><Btn onClick={() => setAdd(null)}>Annulla</Btn><Btn k="dark" disabled={!add.name.trim()} onClick={() => { mut((n) => { n.collectors.push({ id: "c" + Date.now(), ...add }); log(n, { type: "proprieta", text: `Nuovo collezionista: ${add.name}` }); }); setAdd(null); say("Collezionista aggiunto"); }}>Aggiungi</Btn></>}>
      {[["name", "Nome e cognome"], ["email", "Email"], ["city", "Città"]].map(([k, l]) => <label key={k} className="fld"><span>{l}</span><input value={add[k]} onChange={(e) => setAdd({ ...add, [k]: e.target.value })} /></label>)}</Modal>}
  </div>;
}

function About() {
  const { s, go } = useC();
  const MOD = [["Catalogo ragionato", "Un unico database delle opere, con mostre, collezioni, provenienza, bibliografia e documenti. Decidi cosa pubblicare online.", Ic.works], ["Autentiche digitali", "Emetti l'autentica dalla scheda già compilata: ID univoco, QR code e verifica pubblica. L'archivio resta l'unica autorità.", Ic.seal], ["Richieste di autentica", "I collezionisti inviano l'opera con foto e documenti. L'archivio esamina, chiede una visione dal vivo se serve, e decide.", Ic.clock], ["Proprietà", "Assegna l'autentica al proprietario, approva i trasferimenti e mantieni la storia dell'opera nel tempo.", Ic.users]];
  const FLOW = ["L'archivio cataloga l'opera", "Verifica i dati ed emette l'autentica", "Il proprietario riceve l'invito per email", "Accede al suo portale e conserva il certificato", "Ogni trasferimento passa dall'archivio"];
  const REQ = ["Il collezionista invia la richiesta dal catalogo pubblico, con foto, dati e documenti", "Paga i diritti di esame in app, se previsti dall'archivio", "L'archivio riceve la richiesta organizzata nella sezione Richieste", "Esamina l'opera e, se serve, chiede di portarla in sede per una visione dal vivo", "Decide: autentica, archiviata senza autentica, oppure non autentica", "Il collezionista riceve l'esito per email e lo ritrova nel suo portale"];
  const FAQ = [["Chi può inviare una richiesta?", "Qualsiasi collezionista, dal catalogo pubblico dell'archivio. Non serve un account: lo crea alla prima richiesta."], ["Quando si pagano le tariffe?", "Lo decide l'archivio nelle impostazioni: tutto all'invio, diviso tra esame ed esito, oppure solo all'esito. I diritti di esame non sono rimborsabili; il certificato si paga solo se l'opera viene autenticata."], ["Se l'archivio vuole vedere l'opera dal vivo?", "Dalla richiesta invia un messaggio già pronto, modificabile, con data e luogo per la visione. La richiesta resta in sospeso fino all'esame in sede."], ["Che cosa resta pubblico?", "Solo i campi che scegli nelle impostazioni del catalogo. Proprietari, note riservate e documenti «solo archivio» non vengono mai pubblicati."], ["Come si verifica un'autentica?", "Chiunque può inquadrare il QR code o inserire l'ID. Certify confronta l'impronta dei dati certificati con quella registrata all'emissione."], ["Che ruolo ha la blockchain?", "Registra l'impronta del certificato e i passaggi di proprietà, così che non possano essere alterati. I dati dell'opera restano nel database dell'archivio, modificabili."], ["Se una scheda cambia dopo l'emissione?", "Il certificato conserva i dati certificati. Una correzione sostanziale diventa una rettifica tracciata, e il certificato precedente resta in archivio come sostituito."]];
  return <div className="page ab">
    <div className="ab-h"><div className="ph-k">Informazioni</div><h1>L'infrastruttura digitale per gli archivi d'artista.</h1><p>Certify esiste per preservare l'integrità, la provenienza e la sicurezza di ogni opera: un unico sistema per catalogarla, autenticarla e seguirne la storia nel tempo.</p></div>
    <div className="ab-m">{MOD.map(([t, d, I]) => <div key={t}><span><I /></span><b>{t}</b><p>{d}</p></div>)}</div>
    <div className="ab-g">
      <section><h2>Come funziona un'autentica</h2><ol className="ab-f">{FLOW.map((x, i) => <li key={x}><i>{i + 1}</i>{x}</li>)}</ol>
        <div className="row" style={{ marginTop: 16, flexWrap: "wrap" }}><Btn k="dark" onClick={() => go({ v: "archive", p: "works" })}>Emetti da una scheda</Btn><Btn onClick={() => go({ v: "verify" })}>Prova la verifica</Btn><Btn onClick={openTour}>Rivedi il tour</Btn></div></section>
      <section><h2>Come funziona una richiesta</h2><ol className="ab-f">{REQ.map((x, i) => <li key={x}><i>{i + 1}</i>{x}</li>)}</ol>
        <div className="row" style={{ marginTop: 16, flexWrap: "wrap" }}><Btn k="dark" onClick={() => go({ v: "archive", p: "requests" })}>Vai alle richieste</Btn><Btn onClick={() => go({ v: "collector", p: "request" })}>Vedi il modulo del collezionista</Btn></div></section>
      <section className="ab-wide"><h2>Domande frequenti</h2>{FAQ.map(([q, a]) => <details key={q} className="ab-q"><summary>{q}</summary><p>{a}</p></details>)}</section>
    </div>
    <div className="ab-ft"><div><span>Archivio</span><b>{s.archive.name}</b></div><div><span>Versione</span><b>Prototipo · dati dimostrativi</b></div><div><span>Supporto</span><b>hello@certifyarchive.com</b></div><div><span>Sito</span><b>certifyarchive.com</b></div></div>
  </div>;
}


// Authentication flow — same staged flow as Certify Piattaforma: Richiesta → Esame → Decisione → Certificato, then owner invite & acceptance.
function AuthStaged({ a }) {
  const { s, mut, go, say } = useC();
  const st0 = (a.authState && a.authState.status) || (certOf(s, a.id) ? "approved" : "none");
  const [notes, setNotes] = pS((a.authState && a.authState.notes) || ""); const [prev, setPrev] = pS(null); const [view, setView] = pS(false); const [owner, setOwner] = pS(""); const [busy, setBusy] = pS(false);
  const cert = certOf(s, a.id); const old = s.certs.filter((x) => x.artworkId === a.id && x.status === "superseded");
  const idx = cert ? 4 : st0 === "none" ? 0 : st0 === "review" ? 1 : 2;
  const pre = (s.certs[0] && s.certs[0].id.split("-").slice(0, 2).join("-")) || "CERT-FA";
  const nextId = `${pre}-${String(s.certs.length + 124).padStart(6, "0")}`;
  const LBL = { none: "Nessuna richiesta", review: "In esame", approved: "Autenticata", rejected: "Non autenticata" };
  const setAuth = (status, label) => mut((n) => { const x = byId(n.works, a.id); const from = (x.authState && x.authState.status) || "none"; x.authState = { status, notes }; log(n, { type: "autentica", artworkId: a.id, text: `${a.title}: autentica · ${LBL[from]} → ${label || LBL[status]}` }); });
  const issue = async (supersede) => {
    setBusy(true); const snap = snapOf(s, a); const id = nextId; const h = await sha({ ...snap, id, note: "" });
    mut((n) => { const o = supersede && byId(n.certs, supersede); if (o) { o.status = "superseded"; o.replacedBy = id; }
      n.certs.push({ id, artworkId: a.id, snapshot: snap, hash: h, issuedAt: today(), status: "issued", ownerId: o ? o.ownerId : null, claim: o ? o.claim : null, invite: o ? o.invite : null, public: true, note: "", replaces: o ? o.id : null, anchored: false });
      log(n, { type: "autentica", artworkId: a.id, text: `${a.title}: ${o ? "certificato sostitutivo" : "certificato"} ${id} emesso`, hash: h.slice(0, 10) }); });
    setTimeout(() => mut((n) => { const c = byId(n.certs, id); if (c) c.anchored = true; }), 3000);
    setBusy(false); setPrev(null); say(supersede ? "Autentica sostitutiva emessa" : "Autentica emessa e registrata");
  };
  const invite = () => { mut((n) => { const c = byId(n.certs, cert.id); const o = byId(n.collectors, owner); c.ownerId = owner; c.claim = "invited"; c.invite = "sent";
    n.mails = n.mails || []; n.mails.push({ id: "m" + Date.now(), certId: c.id, to: o.email, toName: o.name, kind: "invite", at: today(), status: "Inviata" });
    log(n, { type: "proprieta", artworkId: a.id, text: `Invito inviato a ${o.name} · ${c.id}` }); }); setOwner(""); say("Invito inviato"); };
  const accept = () => { mut((n) => { const c = byId(n.certs, cert.id); c.claim = "claimed"; const x = byId(n.works, a.id); const o = byId(n.collectors, c.ownerId);
    if (!x.provenance.some((p) => p.who === o.name)) x.provenance.push({ who: o.name, when: new Date().getFullYear() + "–oggi", show: "anon" });
    log(n, { type: "proprieta", artworkId: a.id, text: `${o.name} ha accettato il certificato ${c.id}` }); }); say("Proprietario collegato: provenienza aggiornata"); };
  const dr = cert && drift(s, a); const own = cert && cert.ownerId && byId(s.collectors, cert.ownerId);
  const ini = (n) => n.split(" ").map((w) => w[0]).slice(0, 2).join("");
  return <div className="as2">
    <div className="steps">{["Richiesta", "Esame", "Decisione", "Autentica"].map((l, i) => <span key={l} className={i < idx || cert ? "d" : i === idx ? "on" : ""}><i>{i < idx || cert ? "✓" : i + 1}</i>{l}</span>)}</div>
    {a.uncatalogued && <div className="hint" style={{ marginTop: 0, marginBottom: 12 }}><b>Opera non catalogata.</b> Registrata nel database solo per l'autentica: puoi completarne la scheda e pubblicarla nel catalogo in seguito.</div>}
    <p className="mut" style={{ marginTop: 0 }}>L'autenticità la stabilisce l'archivio. Certify registra la decisione e rilascia il certificato a nome dell'archivio.</p>
    {!cert && st0 === "none" && <div className="card"><div className="c-h"><h2>Avvia l'esame dell'opera</h2></div>
      <label className="fld"><span>Note per il comitato</span><textarea rows={3} value={notes} onChange={(e) => setNotes(e.target.value)} placeholder="Es. richiesta del proprietario, documentazione disponibile…" /></label>
      <Btn k="dark" onClick={() => setAuth("review", "Esame avviato")}>Avvia esame</Btn></div>}
    {!cert && st0 === "review" && <div className="card"><div className="c-h"><h2>Opera in esame</h2><Pill k="warn">In esame</Pill></div>
      <label className="fld"><span>Note di esame · private</span><textarea rows={3} value={notes} onChange={(e) => setNotes(e.target.value)} /></label>
      <div className="row"><Btn k="dark" onClick={() => setAuth("approved")}>Approva autentica</Btn><Btn onClick={() => setAuth("rejected")}>Non autenticare</Btn></div></div>}
    {!cert && st0 === "rejected" && <div className="card"><div className="c-h"><h2>L'archivio non ha autenticato l'opera</h2><Pill k="bad">Non autenticata</Pill></div><p className="mut">{(a.authState && a.authState.notes) || "Nessuna nota."}</p><Btn onClick={() => setAuth("review", "Esame riaperto")}>Riapri l'esame</Btn></div>}
    {!cert && st0 === "approved" && <div className="card"><div className="c-h"><h2>Autentica approvata</h2><Pill k="ok">Approvata</Pill></div>
      <p className="mut" style={{ marginTop: 0 }}>Il certificato fissa i dati dell'opera come sono oggi e ne registra l'impronta. Se in futuro la scheda cambia, il certificato resta fedele a ciò che è stato certificato.</p>
      <Btn k="dark" onClick={() => setPrev(true)}><Ic.seal /> Emetti autentica</Btn></div>}
    {cert && <div className="card">
      <div className="c-h"><div><div className="ph-k">Autentica emessa</div><div className="as2-no">{cert.id}</div></div><Pill k="ok">Valido</Pill></div>
      <CertFacts c={cert} a={a} compact />
      <div className="row" style={{ margin: "14px 0 4px", flexWrap: "wrap" }}><Btn k="sm" onClick={() => setView(true)}>Vedi autentica</Btn><Btn k="sm" onClick={() => go({ v: "verify", id: cert.id })}><Ic.qr /> Verifica pubblica</Btn><Btn k="sm" onClick={() => go({ v: "archive", p: "cert", id: cert.id })}>Apri l'autentica</Btn></div>
      <h3 className="as2-h">Proprietario</h3>
      {!own ? <div className="row"><select value={owner} onChange={(e) => setOwner(e.target.value)}><option value="">Scegli il proprietario…</option>{s.collectors.map((k) => <option key={k.id} value={k.id}>{k.name}</option>)}</select><Btn k="dark" disabled={!owner} onClick={invite}>Invia invito</Btn></div>
        : <div className="li"><span className="av">{ini(own.name)}</span><div className="grow"><b>{own.name}</b><div className="mut sm">{cert.claim === "invited" ? "Invito inviato · in attesa di conferma" : "Ha accettato il certificato · collegato all'opera"}</div></div>
          {cert.claim === "invited" ? <Btn k="sm" onClick={accept}>Simula accettazione</Btn> : <Pill k="ok">Collegato</Pill>}</div>}
      {dr && <div className="warn" style={{ marginTop: 16 }}><b>La scheda è cambiata dopo l'emissione.</b> Il certificato resta fedele ai dati certificati il {cert.issuedAt}. Se la modifica è sostanziale, emetti un certificato sostitutivo: il precedente resta in archivio come sostituito.
        <div style={{ marginTop: 10 }}><Btn k="sm dark" onClick={() => setPrev(cert.id)}>Emetti autentica sostitutiva</Btn></div></div>}
      {old.map((x) => <div key={x.id} className="mut sm" style={{ marginTop: 10 }}>Sostituito: <span className="mono">{x.id}</span> del {x.issuedAt}</div>)}
    </div>}
    {prev && <Modal w={820} title="Certificato di autenticità" onClose={() => setPrev(null)} foot={<><Btn onClick={() => setPrev(null)}>Annulla</Btn><Btn k="dark" disabled={busy} onClick={() => issue(prev === true ? null : prev)}>{busy ? "Registrazione…" : "Firma ed emetti"}</Btn></>}><CertDoc snap={snapOf(s, a)} id={nextId} a={a} /></Modal>}
    {view && cert && <Modal w={820} title="Certificato di autenticità" onClose={() => setView(false)}><CertDoc snap={cert.snapshot} id={cert.id} issuedAt={cert.issuedAt} a={a} /></Modal>}
  </div>;
}

// Blockchain registration — each authentication gets a unique transaction code.
function txOf(c) { if (!c || !c.hash) return null; const h = c.hash; return { tx: "0x" + h.slice(32) + h.slice(0, 32), block: (parseInt(h.slice(0, 6), 16) % 9000000) + 52000000, net: "Polygon PoS", at: c.issuedAt }; }
function Copy({ v }) { const { say } = useC(); return <button className="cf-cp" onClick={() => { try { navigator.clipboard.writeText(v); } catch (e) {} say("Copiato"); }} aria-label="Copia"><svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7"><rect x="8" y="8" width="12" height="12" rx="2"/><path d="M16 8V5a1 1 0 0 0-1-1H5a1 1 0 0 0-1 1v10a1 1 0 0 0 1 1h3"/></svg></button>; }
const short = (x) => x.slice(0, 10) + "…" + x.slice(-8);
function CertFacts({ c, a, compact }) {
  const { s } = useC(); const t = txOf(c); const on = c.anchored;
  const G = (title, rows) => <div className="cf-g"><h4>{title}</h4>{rows.filter(Boolean).map(([k, v, cp, mono]) => <div key={k} className="cf-r"><span>{k}</span><b className={mono ? "mono" : ""}>{v}{cp && <Copy v={cp} />}</b></div>)}</div>;
  return <div className={"cf" + (compact ? " sm" : "")}>
    {G("Identificativi", [["ID autentica", c.id, c.id, true], ["Codice transazione", on ? short(t.tx) : <span className="pend"><i></i>In attesa di conferma</span>, on && t.tx, on], a && ["Certify ID opera", a.certifyId, null, true], a && a.catNo && ["N. archivio", a.catNo, null, true]])}
    {G("Emissione", [["Emessa da", s.archive.name], ["Firma", `${s.archive.signatory} · ${s.archive.role}`], ["Data", c.issuedAt]])}
    {G("Registrazione su blockchain", [["Stato", on ? <span className="ok-t">Confermata</span> : <span className="pend"><i></i>In corso</span>], ["Rete", t.net], on && ["Blocco", "#" + t.block.toLocaleString("it-IT"), null, true], ["Impronta dei dati (SHA-256)", short(c.hash), c.hash, true]])}
    <p className="cf-n">Prototipo: transazione e blocco sono dimostrativi. In produzione vengono dalla rete e si verificano su un block explorer pubblico.</p>
  </div>;
}

// New authentication — full page: from a catalogued work, or for a work not yet in the catalogue.
function NewAuthButton({ k = "dark", label = "Nuova autentica" }) { const { go } = useC(); return <Btn k={k} onClick={() => go({ v: "archive", p: "newauth" })}><Ic.plus /> {label}</Btn>; }
function shrink(file) { return new Promise((res) => { const r = new FileReader(); r.onload = () => { const im = new Image(); im.onload = () => { const m = 1000, k = Math.min(1, m / Math.max(im.width, im.height)); const c = document.createElement("canvas"); c.width = im.width * k; c.height = im.height * k; c.getContext("2d").drawImage(im, 0, 0, c.width, c.height); res(c.toDataURL("image/jpeg", 0.82)); }; im.src = r.result; }; r.readAsDataURL(file); }); }
function NewAuthPage() {
  const { s, mut, go, say } = useC(); const [step, setStep] = pS(0); const [mode, setMode] = pS(s.route.mode || null); const [q, setQ] = pS(""); const [pick, setPick] = pS(null); const [n, setN] = pS(48);
  const cats = [...new Set(s.works.map((a) => a.category))];
  const [d, setD] = pS({ title: "", year: "", medium: "", dims: "", category: cats[0] || "Opere su tela", catNo: "", inscr: "" });
  const [ph, setPh] = pS({ front: null, back: null, sign: null }); const [notes, setNotes] = pS(""); const [busy, setBusy] = pS(false); const [res, setRes] = pS(null);
  const [own, setOwn] = pS({ mode: "existing", id: "", name: "", email: "" }); const [draft, setDraft] = pS(null);
  const L = s.works.filter((a) => !certOf(s, a.id) && (a.title + a.year + (a.catNo || "") + (a.medium || "")).toLowerCase().includes(q.toLowerCase()));
  const A = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"; const rid = () => { let x = ""; for (let i = 0; i < 8; i++) x += A[Math.floor(Math.random() * 32)]; return "CTF-" + x.slice(0, 4) + "-" + x.slice(4); };
  const up = async (k, e) => { const f = e.target.files && e.target.files[0]; if (!f) return; const u = await shrink(f); setPh((x) => ({ ...x, [k]: u })); };
  const pre = (s.certs[0] && s.certs[0].id.split("-").slice(0, 2).join("-")) || "CERT-FA"; const nextId = `${pre}-${String(s.certs.length + 124).padStart(6, "0")}`;
  const build = () => { const b = s.works[0] || {}; const w = {}; Object.keys(b).forEach((k) => { const v = b[k]; w[k] = Array.isArray(v) ? [] : typeof v === "string" ? "" : typeof v === "number" ? 0 : typeof v === "boolean" ? false : null; });
    const id = "u" + Date.now();
    return Object.assign(w, { id, certifyId: rid(), catNo: d.catNo, title: d.title.trim(), year: +d.year || d.year, yearLabel: d.year, medium: d.medium, dims: d.dims, inscr: d.inscr, category: d.category, hue: Math.floor(Math.random() * 360), pub: "draft", img: ph.front || undefined, edited: "adesso", added: Date.now(), uncatalogued: true,
      docs: [ph.back && { id: "d" + id + "b", label: "Retro", vis: "archive", type: "image", src: ph.back }, ph.sign && { id: "d" + id + "s", label: "Firma", vis: "archive", type: "image", src: ph.sign }].filter(Boolean) }); };
  const work = res ? byId(s.works, res.workId) : mode === "cat" ? byId(s.works, pick) : draft;
  const next0 = () => { if (mode === "new") setDraft(build()); setStep(1); };
  const emit = async () => {
    setBusy(true); const a = work; const id = nextId; const snap = snapOf(s, a); const h = await sha({ ...snap, id, note: "" });
    try { mut((nn) => { if (mode === "new") nn.works.unshift(a); const x = byId(nn.works, a.id); x.authState = { status: "approved", notes };
      nn.certs.push({ id, artworkId: a.id, snapshot: snap, hash: h, issuedAt: today(), status: "issued", ownerId: null, claim: null, invite: null, public: true, note: "", replaces: null, anchored: false });
      log(nn, { type: "autentica", artworkId: a.id, text: `${a.title}: autentica ${id} emessa${mode === "new" ? " · opera non catalogata" : ""}`, hash: h.slice(0, 10) }); }); }
    catch (e) { setBusy(false); say("Immagini troppo grandi per la demo"); return; }
    setTimeout(() => mut((nn) => { const c = byId(nn.certs, id); if (c) c.anchored = true; }), 3000);
    setRes({ id, hash: h, workId: a.id }); setBusy(false); setStep(3);
  };
  const assign = () => { mut((nn) => { const c = byId(nn.certs, res.id); let cid = own.id;
      if (own.mode === "new") { cid = "c" + Date.now(); nn.collectors.push({ id: cid, name: own.name.trim(), email: own.email.trim(), city: "" }); }
      const o = byId(nn.collectors, cid); c.ownerId = cid; c.claim = "invited"; c.invite = "sent";
      nn.mails = nn.mails || []; nn.mails.push({ id: "m" + Date.now(), certId: c.id, to: o.email, toName: o.name, kind: "invite", at: today(), status: "Inviata" });
      log(nn, { type: "proprieta", artworkId: c.artworkId, text: `Invito inviato a ${o.name} · ${c.id}` }); }); setStep(4); };
  const cert = res && byId(s.certs, res.id); const owner = cert && cert.ownerId && byId(s.collectors, cert.ownerId);
  const F = (k, l, phd, full) => <label className={"fld" + (full ? " na-full" : "")}><span>{l}</span><input value={d[k]} placeholder={phd} onChange={(e) => setD({ ...d, [k]: e.target.value })} /></label>;
  const Slot = ({ k, l, big }) => <label className={"na-ph" + (big ? " big" : "") + (ph[k] ? " has" : "")}>{ph[k] ? <img src={ph[k]} alt={l} /> : <span><Ic.up /><b>{l}</b><em>{big ? "Trascina o scegli un'immagine" : "Facoltativo"}</em></span>}<input type="file" accept="image/*" onChange={(e) => up(k, e)} />{ph[k] && <button className="na-x" onClick={(e) => { e.preventDefault(); setPh({ ...ph, [k]: null }); }} aria-label="Rimuovi"><Ic.x /></button>}</label>;
  const S = ["Opera", "Verifica", "Emissione", "Proprietario"];
  const Sum = () => <div className="nas"><div className="nas-i"><Art a={work} label={false} r={0} /></div><div className="nas-t"><b>{work.title}</b><span>{s.archive.artist} · {work.yearLabel || work.year || "s.d."}</span>{work.uncatalogued && <em>Non catalogata</em>}</div></div>;
  return <div className="page wide na">
    <button className="lnk back" onClick={() => go({ v: "archive", p: "certs" })}><Ic.back /> Autentiche</button>
    <div className="na-h"><div><h1>Nuova autentica</h1><p className="mut">Dall'opera al certificato, in un unico percorso.</p></div>
      </div>
    <div className="steps na-st">{S.map((l, i) => <span key={l} className={i === Math.min(step, 3) && step < 4 ? "on" : i < step ? "d" : ""}><i>{i < step ? "✓" : i + 1}</i>{l}</span>)}</div>

    {step === 0 && !mode && <div className="nac">
      <button className="nac-c" onClick={() => setMode("cat")}><div className="nac-i"><Ic.works /></div><div className="nac-t"><strong>Da un'opera del catalogo</strong><small>Cerca una scheda già compilata: i dati arrivano dal catalogo, senza reinserirli.</small></div><div className="nac-l">Cerca nel catalogo <Ic.chev /></div></button>
      <button className="nac-c" onClick={() => setMode("new")}><div className="nac-i"><Ic.plus /></div><div className="nac-t"><strong>Opera non catalogata</strong><small>Inserisci i dati essenziali e le foto. L'opera viene registrata nel database insieme all'autentica.</small></div><div className="nac-l">Inserisci i dati <Ic.chev /></div></button></div>}
    {step === 0 && mode && <button className="lnk na-chg" onClick={() => { setMode(null); setPick(null); setQ(""); }}><Ic.back /> {mode === "cat" ? "Da un'opera del catalogo" : "Opera non catalogata"} · cambia</button>}
    {step === 0 && mode === "cat" && <>
      <div className="na-bar"><label className="search"><Ic.search /><input autoFocus value={q} onChange={(e) => setQ(e.target.value)} placeholder="Cerca titolo, anno, numero d'archivio, tecnica…" /></label><span className="mut sm">{q.trim() ? `${L.length.toLocaleString("it-IT")} risultati` : `${L.length.toLocaleString("it-IT")} opere senza autentica`}</span><Btn k="dark" disabled={!pick} onClick={next0}>Continua</Btn></div>
      {!q.trim() && <h3 className="na-sub">Aggiunte di recente</h3>}<div className="na-g">{(q.trim() ? L.slice(0, n) : L.slice().sort((x, y) => (y.added || 0) - (x.added || 0)).slice(0, 8)).map((a) => <button key={a.id} className={pick === a.id ? "on" : ""} onClick={() => setPick(a.id)} onDoubleClick={() => { setPick(a.id); setStep(1); }}><div className="na-gi"><Art a={a} label={false} r={0} /><i>{pick === a.id && <Ic.check />}</i></div><b>{a.title}</b><span>{a.yearLabel || a.year}{a.catNo ? " · " + a.catNo : ""}</span></button>)}</div>
      {!L.length && <div className="empty">Nessuna opera da autenticare.</div>}
      {q.trim() && L.length > n && <div style={{ textAlign: "center", marginTop: 26 }}><Btn k="sm" onClick={() => setN(n + 48)}>Mostra altre opere</Btn></div>}</>}

    {step === 0 && mode === "new" && <div className="na-f">
      <div className="na-col"><Slot k="front" l="Foto dell'opera · fronte" big /><div className="na-two"><Slot k="back" l="Retro" /><Slot k="sign" l="Firma o iscrizioni" /></div></div>
      <div className="na-r"><section><h2>Dati dell'opera</h2>{F("title", "Titolo *", "Es. Senza titolo", true)}
        <div className="g2f">{F("year", "Anno", "Es. 1964")}<label className="fld"><span>Categoria</span><select value={d.category} onChange={(e) => setD({ ...d, category: e.target.value })}>{cats.map((c) => <option key={c}>{c}</option>)}</select></label></div>
        <div className="g2f">{F("medium", "Tecnica", "Es. Smalto su tela")}{F("dims", "Dimensioni", "Es. 100 × 80 cm")}</div>
        {F("inscr", "Firma e iscrizioni", "Es. firmato e datato sul retro", true)}{F("catNo", "N. archivio", "Lascia vuoto se non ancora assegnato", true)}</section>
        <div className="hint">L'opera viene registrata nel database come «non catalogata» insieme all'autentica. Potrai completarla e pubblicarla nel catalogo in seguito.</div>
        <div className="na-act"><Btn onClick={() => go({ v: "archive", p: "certs" })}>Annulla</Btn><Btn k="dark" disabled={!d.title.trim()} onClick={next0}>Continua</Btn></div></div></div>}

    {step === 1 && work && (() => { const RW = [["Titolo", work.title], ["Artista", s.archive.artist], ["Anno", work.yearLabel || work.year], ["Tecnica", work.medium], ["Dimensioni", work.dims], ["Firma e iscrizioni", work.inscr], ["N. archivio", work.catNo], ["Certify ID", work.certifyId]]; const miss = RW.filter((r) => !r[1]).length;
      return <div className="nav2">
        <div className="nav2-i"><div className="nav2-f"><Art a={work} label={false} r={0} /></div></div>
        <div className="nav2-b">
          <div className="nav2-h"><h2>{work.title}</h2><span>{s.archive.artist} · {work.yearLabel || work.year || "Senza data"}</span>{work.uncatalogued && <em>Non catalogata</em>}</div>
          <section className="nav2-s"><div className="nav2-sh"><h3>Dati da certificare</h3><button className="lnk" onClick={() => mode === "cat" ? go({ v: "archive", p: "work", id: work.id }) : setStep(0)}>Modifica</button></div>
            {RW.map(([k, val]) => <div key={k} className="nav2-r"><span>{k}</span>{val ? <b className={k === "Certify ID" ? "mono" : ""}>{val}</b> : <em>Da completare</em>}</div>)}</section>
          {miss > 0 && <div className="hint">{miss === 1 ? "Un campo è vuoto" : `${miss} campi sono vuoti`}: puoi completarli ora o emettere l'autentica con i dati disponibili. Il certificato riporterà solo i campi compilati.</div>}
          <div className="na-act"><Btn onClick={() => setStep(0)}>Indietro</Btn><Btn k="dark" onClick={() => setStep(2)}>Conferma i dati</Btn></div>
        </div></div>; })()}

    {step === 2 && work && <div className="na-f"><div className="na-col"><CertDoc snap={snapOf(s, work)} id={nextId} a={work} /></div>
      <div className="na-r"><section><h2>Anteprima del certificato</h2><p className="mut" style={{ marginTop: 0 }}>Il certificato fissa i dati dell'opera come sono oggi e ne registra l'impronta. Se in futuro la scheda cambia, resta fedele a ciò che è stato certificato.</p>
        <div className="cf"><div className="cf-g"><h4>Verrà registrata</h4><div className="cf-r"><span>ID autentica</span><b className="mono">{nextId}</b></div><div className="cf-r"><span>Emessa da</span><b>{s.archive.name}</b></div><div className="cf-r"><span>Firma</span><b>{s.archive.signatory} · {s.archive.role}</b></div><div className="cf-r"><span>Rete</span><b>Polygon PoS</b></div><div className="cf-r"><span>Codice transazione</span><b>Generato alla firma</b></div></div></div></section>
        <div className="na-act"><Btn onClick={() => setStep(1)}>Indietro</Btn><Btn k="dark" disabled={busy} onClick={emit}>{busy ? "Registrazione…" : "Firma ed emetti"}</Btn></div></div></div>}

    {step === 3 && cert && <div className="na-f"><Sum />
      <div className="na-r"><div className="na-ok"><div className="ok-c"><Ic.check /></div><div><b>Autentica emessa</b><span className="mono">{cert.id}</span></div></div>
        <section><h2>A chi viene assegnata?</h2>
          <div className="opts">{[["existing", "Collezionista registrato"], ["new", "Nuovo collezionista"]].map(([k, l]) => <button key={k} className={own.mode === k ? "on" : ""} onClick={() => setOwn({ ...own, mode: k })}><i></i><div><b>{l}</b></div></button>)}</div>
          {own.mode === "existing" ? <select value={own.id} onChange={(e) => setOwn({ ...own, id: e.target.value })}><option value="">Scegli un collezionista…</option>{s.collectors.map((k) => <option key={k.id} value={k.id}>{k.name} · {k.email}</option>)}</select>
            : <div className="g2f"><label className="fld"><span>Nome e cognome</span><input value={own.name} onChange={(e) => setOwn({ ...own, name: e.target.value })} /></label><label className="fld"><span>Email</span><input value={own.email} onChange={(e) => setOwn({ ...own, email: e.target.value })} /></label></div>}
          <div className="hint">Il proprietario riceve un invito per email e accede al suo portale. L'assegnazione è tracciata e non equivale da sola a una prova giuridica di proprietà.</div></section>
        <div className="na-act"><Btn onClick={() => setStep(4)}>Assegna più tardi</Btn><Btn k="dark" disabled={own.mode === "existing" ? !own.id : !own.name.trim() || !own.email.includes("@")} onClick={assign}>Assegna e invia invito</Btn></div></div></div>}

    {step === 4 && cert && <div className="na-done"><div className="ok-c"><Ic.check /></div><h2>Autentica completata</h2>
      <p className="mut">{work.title} · <span className="mono">{cert.id}</span>{owner ? ` · invito inviato a ${owner.name}` : " · non ancora assegnata"}</p>
      <div className="na-dl"><CertFacts c={cert} a={work} /></div>
      <div className="row" style={{ justifyContent: "center", flexWrap: "wrap" }}><Btn k="dark" onClick={() => go({ v: "archive", p: "cert", id: cert.id })}>Apri l'autentica</Btn><Btn onClick={() => go({ v: "verify", id: cert.id })}><Ic.qr /> Verifica pubblica</Btn><Btn onClick={() => { setStep(0); setPick(null); setRes(null); setDraft(null); setNotes(""); setPh({ front: null, back: null, sign: null }); setD({ ...d, title: "", year: "", medium: "", dims: "", catNo: "", inscr: "" }); setOwn({ mode: "existing", id: "", name: "", email: "" }); }}>Nuova autentica</Btn></div></div>}
  </div>;
}

// Delete artworks — blocked while a valid authentication exists; removes links, keeps the event log.
function DeleteWorks({ ids, onClose, onDone }) {
  const { s, mut, say } = useC(); const [t, setT] = pS("");
  const W = ids.map((id) => byId(s.works, id)).filter(Boolean);
  const blocked = W.filter((a) => certOf(s, a.id)); const ok = W.filter((a) => !certOf(s, a.id));
  const one = W.length === 1; const need = one ? "" : "ELIMINA";
  const run = () => { mut((n) => { const del = ok.map((a) => a.id); n.works = n.works.filter((a) => !del.includes(a.id)); n.requests = (n.requests || []).map((r) => del.includes(r.workId) ? { ...r, workId: null } : r);
      log(n, { type: "modifica", text: one ? `Opera eliminata: ${ok[0].title}` : `${del.length} opere eliminate` }); });
    say(one ? "Opera eliminata" : `${ok.length} opere eliminate`); onDone && onDone(ok.map((a) => a.id)); onClose(); };
  return <Modal w={520} title={one ? "Eliminare l'opera?" : `Eliminare ${W.length} opere?`} onClose={onClose}
    foot={<><Btn onClick={onClose}>Annulla</Btn><Btn k="del" disabled={!ok.length || (need && t !== need)} onClick={run}>{one ? "Elimina opera" : `Elimina ${ok.length}`}</Btn></>}>
    {one && ok.length === 1 && <div className="dw-w"><div><Art a={ok[0]} label={false} r={0} /></div><span><b>{ok[0].title}</b><em>{ok[0].yearLabel || ok[0].year}{ok[0].catNo ? " · " + ok[0].catNo : ""}</em></span></div>}
    <p className="mut" style={{ marginTop: 0 }}>La scheda viene rimossa dal database, dal catalogo pubblico, da mostre e collezioni. Immagini e documenti collegati vengono eliminati. L'operazione non si può annullare.</p>
    {blocked.length > 0 && <div className="warn"><b>{blocked.length === 1 && one ? "Quest'opera ha un'autentica valida e non può essere eliminata." : `${blocked.length} opere hanno un'autentica valida e verranno escluse.`}</b> Revoca prima l'autentica dalla sua pagina.</div>}
    {need && ok.length > 0 && <label className="fld"><span>Scrivi ELIMINA per confermare</span><input value={t} onChange={(e) => setT(e.target.value)} /></label>}
  </Modal>;
}
const ROLES = ["Amministratore", "Editor", "Ricercatore", "Sola lettura"];
const PERMS = [["Consultare archivio e documenti", [1, 1, 1, 1]], ["Modificare le schede delle opere", [1, 1, 1, 0]], ["Pubblicare nel catalogo", [1, 1, 0, 0]], ["Gestire le richieste di autentica", [1, 1, 0, 0]], ["Emettere e revocare autentiche", [1, 0, 0, 0]], ["Vedere i dati dei collezionisti", [1, 1, 0, 0]], ["Team, piano e fatturazione", [1, 0, 0, 0]]];
function TeamSettings() {
  const { s, mut, say } = useC(); const [inv, setInv] = React.useState(null);
  const team = s.team2 || [{ n: "Maria Angeli", e: "maria@archiviofrancoangeli.org", r: "Amministratore", last: "Oggi", t: "Presidente" }, { n: "Luca Ferri", e: "luca@archiviofrancoangeli.org", r: "Editor", last: "Ieri" }, { n: "Sara Conti", e: "sara@archiviofrancoangeli.org", r: "Ricercatore", last: "3 giorni fa" }];
  const setT = (f) => mut((n) => { n.team2 = (n.team2 || team).map((x) => ({ ...x })); f(n.team2); });
  return <><div className="st2-h"><div><h2>Team e permessi</h2><p className="st2-d">Chi accede all'archivio e cosa può fare.</p></div><Btn k="dark" onClick={() => setInv({ e: "", r: "Editor" })}><Ic.plus /> Invita</Btn></div>
    <div className="st2-grp">{team.map((m, i) => <div key={m.e} className="tm2-r"><div className="st2-u"><span className="av">{m.n.split(" ").map((x) => x[0]).slice(0, 2).join("")}</span><div><b>{m.n}</b><em>{m.e}</em></div></div>
      <span className="tm2-l">{m.pending ? "Invito inviato" : "Ultimo accesso · " + m.last}</span>
      <select value={m.r} disabled={i === 0} onChange={(e) => { setT((T) => { T[i].r = e.target.value; }); say("Ruolo aggiornato"); }}>{ROLES.map((x) => <option key={x}>{x}</option>)}</select>
      {i > 0 ? <button className="tm2-x" onClick={() => { if (confirm("Rimuovere " + m.n + " dal team?")) { setT((T) => { T.splice(i, 1); }); say("Accesso rimosso"); } }} aria-label="Rimuovi"><Ic.x /></button> : <span className="tm2-x"></span>}</div>)}</div>
    <h3>Cosa può fare ogni ruolo</h3>
    <div className="tm2-m"><div className="tm2-mh"><span></span>{ROLES.map((x) => <b key={x}>{x}</b>)}</div>{PERMS.map(([l, v]) => <div key={l} className="tm2-mr"><span>{l}</span>{v.map((y, i) => <i key={i} className={y ? "y" : ""}>{y ? "✓" : "—"}</i>)}</div>)}</div>
    <h3>Sicurezza</h3>
    <div className="st2-grp"><div className="st2-r"><span>Verifica in due passaggi obbligatoria</span><Tg on={!!s.tfa} onClick={() => mut((n) => { n.tfa = !n.tfa; })} /></div><div className="st2-r"><span>Registro accessi e modifiche</span><span className="st2-v">Sempre attivo · in Attività</span></div></div>
    {inv && <Modal title="Invita nel team" onClose={() => setInv(null)} foot={<><Btn onClick={() => setInv(null)}>Annulla</Btn><Btn k="dark" disabled={!inv.e.includes("@")} onClick={() => { setT((T) => { T.push({ n: inv.e.split("@")[0], e: inv.e, r: inv.r, pending: true, last: "" }); }); setInv(null); say("Invito inviato · simulato"); }}>Invia invito</Btn></>}>
      <label className="fld"><span>Email</span><input autoFocus value={inv.e} onChange={(e) => setInv({ ...inv, e: e.target.value })} /></label>
      <label className="fld"><span>Ruolo</span><select value={inv.r} onChange={(e) => setInv({ ...inv, r: e.target.value })}>{ROLES.map((x) => <option key={x}>{x}</option>)}</select></label></Modal>}</>;
}
Object.assign(window, { DeleteWorks, CertFacts, txOf, TeamSettings });
Object.assign(window, { CertPage, People, About, mailsOf, AuthStaged, AuthTab: AuthStaged, NewAuthButton, NewAuthPage });
