// dictator.jsx — Phase 3: the main loop. Seeded by the escape profile.

const { useState: useStateD, useMemo: useMemoD, useEffect: useEffectD } = React;
const SFX_D = () => window.SFX || { thunk(){}, alert(){}, statUp(){}, statDown(){}, blip(){}, select(){} };
const PILLAR_MAP = Object.fromEntries(PILLARS.map((p) => [p.key, p]));

function shuffle(a) {
  const r = [...a];
  for (let i = r.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [r[i], r[j]] = [r[j], r[i]];
  }
  return r;
}

function buildDeck(cardCount) {
  const first = CARDS.find((c) => c.id === "inauguration");
  const rest = shuffle(CARDS.filter((c) => c.id !== "inauguration"));
  return [first, ...rest].slice(0, cardCount);
}

function DictatorPhase({ profile, flags, difficulty, showMath, cardCount, onEnd }) {
  const mult = difficulty === "harsh" ? 1.3 : difficulty === "gentle" ? 0.75 : 1;
  const danger = difficulty === "harsh" ? 22 : 18;

  const deck = useMemoD(() => buildDeck(cardCount), [cardCount]);
  const [pillars, setPillars] = useStateD({ ...profile.seeds });
  const [prev, setPrev] = useStateD({ ...profile.seeds });
  const [turn, setTurn] = useStateD(1);
  const [deckPos, setDeckPos] = useStateD(0);
  const [queue, setQueue] = useStateD([]);
  const [item, setItem] = useStateD({ type: "card", card: deck[0] });
  const [pending, setPending] = useStateD(null);
  const [log, setLog] = useStateD([]);

  function applyDelta(base, d) {
    const out = { ...base };
    for (const k in d) out[k] = clamp(out[k] + d[k]);
    return out;
  }

  function chooseCard(ci) {
    const card = item.card;
    const c = card.choices[ci];
    const d = scaleDelta(c.d, mult);
    const np = applyDelta(pillars, d);
    setPrev(pillars);
    setPillars(np);
    SFX_D().thunk();
    statTones(d);
    let q = queue;
    if (c.enqueue) q = [...queue, { id: c.enqueue.id, fireDay: turn + c.enqueue.after }];
    setQueue(q);
    const read = algorithmRead(c.log, flags || {}, profile.n || {});
    setLog([{ turn, text: c.log }, ...log].slice(0, 8));
    setPending({ log: c.log, read, np, q });
  }

  function statTones(d) {
    let up = 0, down = 0;
    for (const k in d) { if (d[k] > 0) up++; else if (d[k] < 0) down++; }
    if (down >= up) setTimeout(() => SFX_D().statDown(), 120); else setTimeout(() => SFX_D().statUp(), 120);
  }

  function acknowledgeConsequence() {
    const cons = item.cons;
    const d = scaleDelta(cons.d, mult);
    const np = applyDelta(pillars, d);
    setPrev(pillars);
    setPillars(np);
    SFX_D().thunk(); statTones(d);
    setLog([{ turn, text: cons.title + " — " + summarize(d) }, ...log].slice(0, 8));
    setPending({ log: cons.brief, read: null, np, q: queue, isCons: true });
  }

  // alert sting when a consequence surfaces
  useEffectD(() => {
    if (item.type === "consequence" && !pending) SFX_D().alert();
  }, [item]);

  function advance() {
    const np = pending.np;
    const q = pending.q;
    setPending(null);
    // ending check
    const ek = detectEndingLocal(np, q, deckPos, item.type);
    if (ek) { onEnd({ key: ek, pillars: np, turn, log: [{ turn, text: lastLog() }, ...log] }); return; }

    const nextTurn = turn + 1;
    setTurn(nextTurn);
    // consequence due?
    const due = q.find((x) => x.fireDay <= nextTurn);
    if (due) {
      setQueue(q.filter((x) => x !== due));
      setItem({ type: "consequence", cons: CONSEQUENCES[due.id] });
      return;
    }
    // next card
    const nextPos = item.type === "card" ? deckPos + 1 : deckPos;
    if (nextPos >= deck.length) {
      // deck exhausted; if queue still has items, fast-forward to next
      if (q.length) {
        const soonest = q.reduce((a, b) => (a.fireDay < b.fireDay ? a : b));
        setQueue(q.filter((x) => x !== soonest));
        setTurn(Math.max(nextTurn, soonest.fireDay));
        setItem({ type: "consequence", cons: CONSEQUENCES[soonest.id] });
        return;
      }
      onEnd({ key: "survived", pillars: np, turn: nextTurn, log });
      return;
    }
    setDeckPos(nextPos);
    setItem({ type: "card", card: deck[nextPos] });
  }

  function detectEndingLocal(np, q, pos, itemType) {
    for (const k of ["military", "economy", "people", "foreign"]) {
      if (np[k] <= 0) return k + "_0";
      if (np[k] >= 100) return k + "_100";
    }
    return null;
  }
  function lastLog() { return log[0] ? log[0].text : ""; }

  const totalCards = deck.length;
  return (
    <div className="dict">
      {/* status header */}
      <div className="dict__hud">
        <div className="dict__meta">
          <span className="dict__day">DAY {String(turn).padStart(2, "0")}</span>
          <span className="dict__sep">/</span>
          <span className="dict__arch"><Glyph name="eye" size={13} /> {profile.archetype}</span>
          <span className="dict__progress">DOSSIER {Math.min(deckPos + 1, totalCards)}·{totalCards}{queue.length ? ` · ${queue.length} pending` : ""}</span>
        </div>
        <div className="dict__pillars">
          {PILLARS.map((p) => (
            <PillarBar key={p.key} pillar={p} value={pillars[p.key]} prev={prev[p.key]} danger={danger} />
          ))}
        </div>
      </div>

      {/* card */}
      <div className="dict__stage">
        {item.type === "consequence" ? (
          <div className="card card--cons">
            <div className="card__hdr">
              <span className="card__kicker card__kicker--cons">⚠ CONSEQUENCE — A PAST CHOICE RETURNS</span>
              <span className="card__class"><Glyph name="eye" size={11} /> ON FILE</span>
            </div>
            <h2 className="card__title">{item.cons.title}</h2>
            <p className="card__brief">{item.cons.brief}</p>
            {!pending ? (
              <div className="card__choices">
                <div className="cons-effect">
                  {showMath
                    ? <DeltaChips d={scaleDelta(item.cons.d, mult)} pillarMap={PILLAR_MAP} show={true} />
                    : <span className="delta-hidden">the bill comes due</span>}
                </div>
                <button className="btn btn--danger" onClick={acknowledgeConsequence}>Face it ▌</button>
              </div>
            ) : (
              <Aftermath pending={pending} onNext={advance} last={deckPos + 1 >= totalCards && !pending.q.length} />
            )}
          </div>
        ) : (
          <div className="card">
            <div className="card__hdr">
              <span className="card__kicker">{item.card.callback ? "◷ A THREAD FROM BEFORE" : "INCOMING — REQUIRES DISPOSITION"}</span>
              <span className="card__class"><Glyph name="eye" size={11} /> EYES ONLY · HEAD OF STATE</span>
            </div>
            <h2 className="card__title">{item.card.title}</h2>
            <p className="card__brief">{item.card.brief}</p>
            {!pending ? (
              <div className="card__choices">
                {item.card.choices.map((c, i) => (
                  <button key={i} className="choice choice--card" onClick={() => chooseCard(i)} onMouseEnter={() => SFX_D().blip()}>
                    <span className="choice__index">{i + 1}</span>
                    <span className="choice__body">
                      <span className="choice__label">{c.label}</span>
                      <span className="choice__chips">
                        <DeltaChips d={scaleDelta(c.d, mult)} pillarMap={PILLAR_MAP} show={showMath} />
                        {c.enqueue && showMath && <span className="chip chip--delay">◷ delayed cost</span>}
                      </span>
                    </span>
                  </button>
                ))}
              </div>
            ) : (
              <Aftermath pending={pending} onNext={advance} last={deckPos + 1 >= totalCards && !pending.q.length} />
            )}
          </div>
        )}

        {/* log rail */}
        <div className="dict__log">
          <div className="dict__log-head">RECORD OF DECISIONS</div>
          {log.length === 0 && <div className="dict__log-empty">No decisions yet. The chair is warm.</div>}
          {log.map((l, i) => (
            <div key={i} className="dict__log-row">
              <span className="dict__log-day">D{String(l.turn).padStart(2, "0")}</span>
              <span className="dict__log-text">{l.text}</span>
            </div>
          ))}
        </div>
      </div>
    </div>
  );
}

function Aftermath({ pending, onNext, last }) {
  return (
    <div className="aftermath aftermath--card">
      <div className="aftermath__log">{pending.log}</div>
      {pending.read && (
        <div className="analysis">
          <span className="analysis__tag"><Glyph name="eye" size={12} /> ANALYSIS</span>
          <span className="analysis__text">{pending.read}</span>
        </div>
      )}
      <button className="btn btn--ghost" onClick={onNext}>
        {last ? "See where it leaves you →" : "Next ▌"}
      </button>
    </div>
  );
}

function summarize(d) {
  return Object.keys(d).filter((k) => d[k]).map((k) => `${PILLAR_MAP[k].label} ${d[k] > 0 ? "+" : ""}${d[k]}`).join(", ");
}

window.DictatorPhase = DictatorPhase;