import { beforeEach, describe, expect, it, vi } from 'vitest';
import type { IdCard, Patron, Verdict } from '../src/data/types';
import type { JudgeContext } from '../src/rules/doorTypes';

// dressCode and idCheck are mocked: judge's job is scoring, and pinning their
// outputs is the only way to construct the cases that matter (a flawless fake on
// a 17-year-old, four simultaneous rule breaches). Their own tests cover them.
const mocks = vi.hoisted(() => ({ violations: vi.fn(), idVerdict: vi.fn() }));
vi.mock('../src/rules/dressCode', () => ({ violations: mocks.violations }));
vi.mock('../src/rules/idCheck', () => ({ idVerdict: mocks.idVerdict }));

const { LOCKOUT_MIN, judge, JUDGE_TUNING: T } = await import('../src/rules/judge');

// The REAL rule labels, pulled past the mock. Hand-written shorts in a test are
// how a broken player-facing string ships: every shipped `short` is a caps
// prohibition ("NO VISIBLE LOGOS"), so any Dazza line built from one has to read
// correctly against that phrasing, not against a tidy lowercase invention.
const { DRESS_CODE_RULES } =
  await vi.importActual<typeof import('../src/rules/dressCode')>('../src/rules/dressCode');
const REAL_SHORTS: string[] = DRESS_CODE_RULES.map((r) => r.short);

const NIGHT = new Date('2026-07-18T00:00:00');
const VERDICTS: Verdict[] = ['admit', 'deny', 'sobrietyTest', 'patDown', 'wait'];

const rule = (short: string) => ({
  id: short,
  text: `mate ${short}`,
  short,
  activeFrom: 30,
  violates: () => true,
});

const idFor = (claimedAge: number, over: Partial<ReturnType<typeof cleanId>> = {}) => ({
  ...cleanId(claimedAge),
  ...over,
});

function cleanId(claimedAge: number) {
  return {
    claimedAge,
    underage: claimedAge < 18,
    expired: false,
    expiresTonight: false,
    turnsEighteenTonight: false,
    tells: [] as string[],
    looksFake: false,
  };
}

const card = (over: Partial<IdCard> = {}): IdCard => ({
  name: 'Shazza Nguyen',
  dob: '2001-01-01',
  expiry: '2029-01-01',
  photoSeed: 1234,
  ...over,
});

const makePatron = (over: Partial<Patron> = {}): Patron => ({
  id: 'p7',
  dollSeed: 1234,
  archetype: 'punter',
  age: 25,
  idCard: card(),
  outfit: [
    { slot: 'shoes', type: 'boot', colour: 'black' },
    { slot: 'legs', type: 'jeans', colour: 'denim' },
    { slot: 'top', type: 'shirt', colour: 'blue' },
    { slot: 'outer', type: 'none', colour: 'black' },
    { slot: 'hair', type: 'short', colour: 'brown' },
    { slot: 'accessory', type: 'none', colour: 'black' },
  ],
  intoxication: 0.1,
  tolerance: 0.6,
  flags: {},
  ...over,
});

const ctx = (over: Partial<JudgeContext> = {}): JudgeContext => ({
  clockMin: 120,
  nightDate: NIGHT,
  lapRoll: 0.5,
  insideCount: 40,
  licensed: 200,
  ...over,
});

/** Pin what the (mocked) inspection surface reports for the next judge() call. */
const scene = (broken: string[], id = cleanId(25)): void => {
  mocks.violations.mockReturnValue(broken.map(rule));
  mocks.idVerdict.mockReturnValue(id);
};

beforeEach(() => {
  vi.clearAllMocks();
  scene([]);
});

describe('judge — denials', () => {
  it('denying a genuine violator pays meaningful vibe for a small aggro bump', () => {
    scene(['no thongs']);
    const o = judge(makePatron(), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyViolatorVibe);
    expect(o.vibeDelta).toBeGreaterThan(0);
    expect(o.aggroDelta).toBe(T.denyViolatorAggro);
    expect(o.aggroDelta).toBeGreaterThan(0);
  });

  it('denying a clean patron pays less vibe and costs more aggro than denying a violator', () => {
    const violator = (scene(['no logos']), judge(makePatron(), 'deny', ctx()));
    const clean = (scene([]), judge(makePatron(), 'deny', ctx()));
    expect(clean.vibeDelta).toBeGreaterThan(0);
    expect(clean.vibeDelta).toBeLessThan(violator.vibeDelta);
    expect(clean.aggroDelta).toBeGreaterThan(violator.aggroDelta);
  });

  it('a card that reads underage justifies the denial on its own', () => {
    scene([], idFor(17));
    expect(judge(makePatron(), 'deny', ctx()).vibeDelta).toBe(T.denyViolatorVibe);
  });

  it('a fake-looking card justifies the denial on its own', () => {
    scene([], idFor(19, { looksFake: true, tells: ['peelingLaminate'] }));
    expect(judge(makePatron(), 'deny', ctx()).vibeDelta).toBe(T.denyViolatorVibe);
  });

  it('a real minor holding a flawless card is still a justified denial', () => {
    scene([], cleanId(19));
    expect(judge(makePatron({ age: 17 }), 'deny', ctx()).vibeDelta).toBe(T.denyViolatorVibe);
  });

  it("denying the owner's mate hits vibe hard, fires immediately, and gets a text", () => {
    const o = judge(makePatron({ flags: { knowsOwner: true } }), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyOwnersMateVibe);
    expect(o.vibeDelta).toBeLessThan(0);
    expect(o.aggroDelta).toBeGreaterThan(0);
    expect(o.dazzaText).toBeTruthy();
    expect(o.deferred).toBeUndefined();
  });

  it("the owner's mate outranks anything else wrong with him", () => {
    scene(['no thongs', 'no logos'], idFor(19, { looksFake: true, tells: ['jokeName'] }));
    const o = judge(makePatron({ flags: { knowsOwner: true } }), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyOwnersMateVibe);
  });

  it("denying the owner's mate is the single worst vibe outcome in the table", () => {
    const cases: Array<[string[], Patron, Partial<JudgeContext>]> = [
      [[], makePatron(), {}],
      [['no logos'], makePatron(), {}],
      [['a', 'b', 'c', 'd', 'e'], makePatron(), {}],
      [[], makePatron({ archetype: 'influencer' }), {}],
      [[], makePatron({ archetype: 'regular', flags: { timesDeniedBefore: 4 } }), {}],
      [['a'], makePatron({ archetype: 'regular', flags: { timesDeniedBefore: 9 } }), {}],
      [[], makePatron({ age: 17 }), { insideCount: 300, licensed: 200 }],
    ];
    const worstElsewhere = Math.min(
      ...cases.flatMap(([broken, p, c]) =>
        (['admit', 'deny', 'sobrietyTest', 'patDown', 'wait'] as Verdict[]).flatMap((v) => {
          scene(broken, idFor(19, { looksFake: broken.length > 0 }));
          const o = judge(p, v, ctx(c));
          return [o.vibeDelta, ...(o.deferred ?? []).map((d) => d.vibeDelta ?? 0)];
        }),
      ),
    );
    scene([]);
    const mate = judge(makePatron({ flags: { knowsOwner: true } }), 'deny', ctx()).vibeDelta;
    expect(mate).toBeLessThan(worstElsewhere);
  });

  it('denying an influencer gains extra vibe AND extra aggro over the same call on a punter', () => {
    const punter = judge(makePatron(), 'deny', ctx());
    const influencer = judge(makePatron({ archetype: 'influencer' }), 'deny', ctx());
    expect(influencer.vibeDelta).toBe(punter.vibeDelta + T.denyInfluencerVibe);
    expect(influencer.aggroDelta).toBe(punter.aggroDelta + T.denyInfluencerAggro);
    expect(T.denyInfluencerVibe).toBeGreaterThan(0);
    expect(T.denyInfluencerAggro).toBeGreaterThan(0);
  });

  it('a regular with a grudge costs extra vibe and gets a note', () => {
    const fresh = judge(makePatron({ archetype: 'regular' }), 'deny', ctx());
    const grudged = judge(
      makePatron({ archetype: 'regular', flags: { timesDeniedBefore: 2 } }),
      'deny',
      ctx(),
    );
    expect(T.denyGrudgedRegularVibe).toBeLessThan(0);
    expect(grudged.vibeDelta).toBe(fresh.vibeDelta + T.denyGrudgedRegularVibe);
    expect(grudged.note).toBeTruthy();
  });

  it('a regular denied for the first time carries no grudge penalty', () => {
    const o = judge(makePatron({ archetype: 'regular', flags: { timesDeniedBefore: 0 } }), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyCleanVibe);
    expect(o.note).toBeUndefined();
  });

  it('denying a clean fresh18 costs nothing extra but leaves a note', () => {
    const o = judge(makePatron({ archetype: 'fresh18', age: 18 }), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyCleanVibe);
    expect(o.aggroDelta).toBe(T.denyCleanAggro);
    expect(o.note).toBeTruthy();
  });

  it('a fresh18 who actually broke a rule gets the violator score and no conscience note', () => {
    scene(['no white sneakers']);
    const o = judge(makePatron({ archetype: 'fresh18', age: 18 }), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyViolatorVibe);
    expect(o.note).toBeUndefined();
  });

  it('the inspector scores identically to a punter — detectable meters would kill the mechanic', () => {
    for (const v of VERDICTS) {
      scene([]);
      const punter = judge(makePatron({ archetype: 'punter' }), v, ctx());
      scene([]);
      const inspector = judge(makePatron({ archetype: 'inspector' }), v, ctx());
      expect(inspector).toEqual(punter);
    }
  });
});

describe('judge — admissions', () => {
  it('admitting a clean patron nudges vibe up and lets the queue breathe', () => {
    const o = judge(makePatron(), 'admit', ctx());
    expect(o.vibeDelta).toBe(T.admitCleanVibe);
    expect(o.vibeDelta).toBeGreaterThan(0);
    expect(o.aggroDelta).toBe(T.admitCleanAggro);
    expect(o.aggroDelta).toBeLessThan(0);
  });

  it('admitting a clean 25-year-old yields no heat strike and no deferred tail', () => {
    const o = judge(makePatron({ age: 25 }), 'admit', ctx());
    expect(o.deferred).toBeUndefined();
    // Checked in both places: `outcome.heatStrike` alone is vacuous, because
    // judge never populates the top-level channel at all (see below).
    expect(o.heatStrike).toBeUndefined();
    expect((o.deferred ?? []).some((d) => d.heatStrike)).toBe(false);
  });

  it('heat strikes ride ONLY in deferred[], never top-level — one wiring, one application', () => {
    // Load-bearing for the integrator: whoever wires door:verdict -> heat:strike
    // must read the deferred array. If a strike ever appeared in both channels a
    // naive wiring would burn two of the three licences for one mistake.
    scene([], idFor(17));
    const o = judge(makePatron({ age: 16 }), 'admit', ctx({ insideCount: 300, licensed: 200 }));
    expect(o.heatStrike).toBeUndefined();
    expect((o.deferred ?? []).filter((d) => d.heatStrike)).toHaveLength(2);
  });

  it('admitting a dress-code violator buys immediate queue relief and defers the pain', () => {
    scene(['no thongs']);
    const o = judge(makePatron(), 'admit', ctx());
    expect(o.vibeDelta).toBe(0);
    expect(o.aggroDelta).toBe(T.admitViolatorAggro);
    expect(o.aggroDelta).toBeLessThan(0);
    expect(o.deferred).toHaveLength(1);
    expect(o.deferred?.[0]?.vibeDelta).toBeLessThan(0);
  });

  it('lapRoll 0 lands the lap at +2 minutes, lapRoll 1 at +5', () => {
    scene(['no logos']);
    const early = judge(makePatron(), 'admit', ctx({ clockMin: 100, lapRoll: 0 }));
    scene(['no logos']);
    const late = judge(makePatron(), 'admit', ctx({ clockMin: 100, lapRoll: 1 }));
    expect(early.deferred?.[0]?.atClockMin).toBe(102);
    expect(late.deferred?.[0]?.atClockMin).toBe(105);
  });

  it('the lap hit scales with rule count and stops at the cap', () => {
    scene(['a']);
    const one = judge(makePatron(), 'admit', ctx()).deferred?.[0]?.vibeDelta;
    scene(['a', 'b']);
    const two = judge(makePatron(), 'admit', ctx()).deferred?.[0]?.vibeDelta;
    scene(['a', 'b', 'c', 'd', 'e', 'f']);
    const many = judge(makePatron(), 'admit', ctx()).deferred?.[0]?.vibeDelta;
    expect(one).toBe(T.lapVibePerRule);
    expect(two).toBe(T.lapVibePerRule * 2);
    expect(many).toBe(T.lapVibeCap);
  });

  it('the lap text names the rule that was broken', () => {
    scene(['bucket hats']);
    const hit = judge(makePatron(), 'admit', ctx()).deferred?.[0];
    expect(hit?.dazzaText).toContain('bucket hats');
    expect(hit?.reason).toContain('bucket hats');
  });

  it('the lap text QUOTES the sign rather than claiming to see it, for every real rule', () => {
    // Regression: the line was "i can see ${short} from HERE", which against the
    // real labels renders "i can see NO VISIBLE LOGOS from HERE" — an
    // exoneration, not an accusation, for all eight rules. Quoting the sign is
    // the invariant; narrating sight of a prohibition inverts the meaning.
    expect(REAL_SHORTS.length).toBeGreaterThan(0);
    for (const short of REAL_SHORTS) {
      scene([short]);
      const hit = judge(makePatron(), 'admit', ctx()).deferred?.[0];
      expect(hit?.dazzaText).toContain(`"${short}"`);
      expect(hit?.dazzaText).not.toMatch(/(?:can |could |i )see\s+NO\b/i);
    }
  });

  it('a lap rolled near last drinks still lands inside the night', () => {
    // At 2:58 AM an unclamped +2..5 lands at 360..363. Anything past 360 never
    // fires, which would make the last minutes of every night consequence-free.
    for (const lapRoll of [0, 0.5, 1]) {
      scene(['no thongs']);
      const hit = judge(makePatron(), 'admit', ctx({ clockMin: 358, lapRoll })).deferred?.[0];
      expect(hit?.atClockMin).toBeLessThanOrEqual(T.auditClockMin);
      expect(hit?.atClockMin).toBeGreaterThan(358);
    }
  });

  it('a junk lapRoll still schedules a finite lap', () => {
    for (const lapRoll of [NaN, Infinity, -Infinity, -3, 7]) {
      scene(['no logos']);
      const hit = judge(makePatron(), 'admit', ctx({ clockMin: 100, lapRoll })).deferred?.[0];
      expect(Number.isFinite(hit?.atClockMin)).toBe(true);
      expect(hit?.atClockMin).toBeGreaterThanOrEqual(100 + T.lapDelayMin);
      expect(hit?.atClockMin).toBeLessThanOrEqual(100 + T.lapDelayMin + T.lapDelaySpread);
    }
  });

  it('admitting an underage card feels good now and strikes at the audit', () => {
    scene([], idFor(17));
    const o = judge(makePatron({ age: 25 }), 'admit', ctx());
    expect(o.vibeDelta).toBe(T.admitBadIdVibe);
    expect(o.vibeDelta).toBeGreaterThan(0);
    expect(o.deferred).toHaveLength(1);
    expect(o.deferred?.[0]?.atClockMin).toBe(T.auditClockMin);
    expect(o.deferred?.[0]?.heatStrike?.deferred).toBe(true);
  });

  it('admitting a card that looks fake strikes at the audit too', () => {
    scene([], idFor(19, { looksFake: true, tells: ['wrongHologram'] }));
    const o = judge(makePatron({ age: 22 }), 'admit', ctx());
    expect(o.vibeDelta).toBe(T.admitBadIdVibe);
    expect(o.deferred?.[0]?.heatStrike).toBeDefined();
  });

  it('admitting a minor on a FLAWLESS fake still strikes — and feels like a clean admit', () => {
    // Card says 19, no tells, expiry years away. The player could not have seen
    // it. The licence goes anyway.
    scene([], cleanId(19));
    const kid = makePatron({ age: 17, idCard: card({ dob: '2007-01-01', expiry: '2030-01-01' }) });
    const o = judge(kid, 'admit', ctx());
    expect(o.vibeDelta).toBe(T.admitCleanVibe);
    expect(o.aggroDelta).toBe(T.admitCleanAggro);
    expect(o.deferred).toHaveLength(1);
    expect(o.deferred?.[0]?.heatStrike?.deferred).toBe(true);
    expect(o.deferred?.[0]?.reason).toContain('17');
  });

  it('a bad card AND a real minor produce exactly one strike, not two', () => {
    scene([], idFor(17, { looksFake: true, tells: ['jokeName'] }));
    const o = judge(makePatron({ age: 16 }), 'admit', ctx());
    const strikes = (o.deferred ?? []).filter((d) => d.heatStrike);
    expect(strikes).toHaveLength(1);
    expect(strikes[0]?.reason).toContain('16');
    expect(strikes[0]?.reason).toContain('jokeName');
  });

  it('an expired but genuine licence is logged as expired, not as a forgery', () => {
    // idCheck folds 'expired' into tells, so looksFake is true for a real card
    // that merely lapsed. The strike is fair; calling it fake in the log is not.
    scene([], idFor(40, { looksFake: true, expired: true, tells: ['expired'] }));
    const o = judge(makePatron({ age: 40 }), 'admit', ctx());
    const reason = o.deferred?.[0]?.reason ?? '';
    expect(reason).toContain('expired');
    expect(reason).not.toContain('dodgy');
    expect(reason).not.toMatch(/fake|minor/i);
  });

  it('admitting at or over licensed capacity adds its own deferred strike', () => {
    const under = judge(makePatron(), 'admit', ctx({ insideCount: 199, licensed: 200 }));
    const at = judge(makePatron(), 'admit', ctx({ insideCount: 200, licensed: 200 }));
    expect(under.deferred).toBeUndefined();
    expect(at.deferred).toHaveLength(1);
    expect(at.deferred?.[0]?.atClockMin).toBe(T.auditClockMin);
    expect(at.deferred?.[0]?.heatStrike?.reason).toContain('capacity');
  });

  it('a bad ID admitted over capacity is two separate strikes', () => {
    scene([], idFor(17));
    const o = judge(makePatron({ age: 17 }), 'admit', ctx({ insideCount: 250, licensed: 200 }));
    expect((o.deferred ?? []).filter((d) => d.heatStrike)).toHaveLength(2);
  });
});

describe('judge — the 1:30 lockout', () => {
  it('denying a clean patron after lockout is justified — the law is the reason', () => {
    const after = judge(makePatron(), 'deny', ctx({ clockMin: LOCKOUT_MIN }));
    const before = judge(makePatron(), 'deny', ctx({ clockMin: LOCKOUT_MIN - 1 }));
    // Justified denial pays violator-rate vibe; an unjustified clean denial doesn't.
    expect(after.vibeDelta).toBe(T.denyViolatorVibe);
    expect(before.vibeDelta).not.toBe(after.vibeDelta);
  });

  it('admitting after lockout defers exactly one strike, with a stable reason', () => {
    const o = judge(makePatron(), 'admit', ctx({ clockMin: LOCKOUT_MIN + 10 }));
    const strikes = (o.deferred ?? []).filter((d) => d.heatStrike);
    expect(strikes).toHaveLength(1);
    // STABLE — no patron id baked in — so dedupe holds it to one write-up a night
    // (the over-capacity strike learned this the hard way).
    expect(strikes[0]!.heatStrike!.reason).toBe('admission after the 1:30 lockout');
  });

  it('admitting one minute before lockout carries no lockout strike', () => {
    const o = judge(makePatron(), 'admit', ctx({ clockMin: LOCKOUT_MIN - 1 }));
    expect((o.deferred ?? []).some((d) => d.heatStrike)).toBe(false);
  });
});

describe('judge — stalls and structure', () => {
  it('sobriety tests and pat-downs only cost queue patience', () => {
    for (const v of ['sobrietyTest', 'patDown'] as Verdict[]) {
      const o = judge(makePatron(), v, ctx());
      expect(o.vibeDelta).toBe(0);
      expect(o.aggroDelta).toBe(T.stallAggro);
      expect(o.aggroDelta).toBeGreaterThan(0);
      expect(o.deferred).toBeUndefined();
    }
  });

  it('stalling never scores the underlying patron — that waits for the real verdict', () => {
    scene(['no thongs'], idFor(17, { looksFake: true }));
    const o = judge(makePatron({ age: 17 }), 'sobrietyTest', ctx());
    expect(o.vibeDelta).toBe(0);
    expect(o.heatStrike).toBeUndefined();
    expect(o.deferred).toBeUndefined();
  });

  it('making them wait is theatre: aggro up, hype up, vibe untouched', () => {
    const o = judge(makePatron(), 'wait', ctx());
    expect(o.vibeDelta).toBe(0);
    expect(o.aggroDelta).toBe(T.waitAggro);
    expect(o.hypeDelta).toBe(T.waitHype);
    expect(T.waitHype).toBeGreaterThan(0);
  });

  it('every verdict returns finite numbers, never NaN or undefined', () => {
    for (const v of VERDICTS) {
      for (const broken of [[], ['a'], ['a', 'b', 'c']]) {
        scene(broken, idFor(17, { looksFake: true, tells: ['expired'] }));
        const o = judge(makePatron({ age: 17 }), v, ctx({ insideCount: 400, licensed: 200 }));
        expect(Number.isFinite(o.vibeDelta)).toBe(true);
        expect(Number.isFinite(o.aggroDelta)).toBe(true);
      }
    }
  });

  it('every deferred hit is attributable and lands in the future (or at the audit)', () => {
    const c = ctx({ clockMin: 200, insideCount: 400, licensed: 200 });
    scene(['no blazers', 'no sunnies'], idFor(17, { looksFake: true, tells: ['expired'] }));
    const o = judge(makePatron({ id: 'p42', age: 17 }), 'admit', c);
    expect(o.deferred?.length).toBeGreaterThan(0);
    for (const d of o.deferred ?? []) {
      expect(d.patronId).toBe('p42');
      expect(d.reason.length).toBeGreaterThan(0);
      expect(d.atClockMin > c.clockMin || d.atClockMin === T.auditClockMin).toBe(true);
    }
  });

  it('is deterministic: identical inputs give a deeply equal outcome', () => {
    const p = makePatron({ archetype: 'influencer', age: 17 });
    const c = ctx({ lapRoll: 0.37, insideCount: 210, licensed: 200 });
    scene(['no logos'], idFor(17));
    const a = judge(p, 'admit', c);
    scene(['no logos'], idFor(17));
    const b = judge(p, 'admit', c);
    expect(a).toEqual(b);
  });
});

// ---- intoxication & contraband (LANE-CONTENT) --------------------------------
//
// Before this block existed, judge() read neither. Denying someone who could not
// stand up scored exactly like denying a clean punter (+7 aggro), so the game's
// most legible signal — sway, red eyes, an entire sobriety minigame — was worth
// nothing, and the optimal line was to wave the drunk through. These tests pin
// the fix in both directions: refusing a maggot is defensible, and admitting one
// costs you later.

const drunk = (intoxication: number): Patron => makePatron({ intoxication });

describe('judge — intoxication', () => {
  it('denying a messy or maggot patron is scored as justified, not arbitrary', () => {
    for (const x of [0.7, 0.9]) {
      const o = judge(drunk(x), 'deny', ctx());
      expect(o.vibeDelta).toBe(T.denyViolatorVibe);
      expect(o.aggroDelta).toBe(T.denyViolatorAggro);
    }
  });

  it('denying a merely LOOSE patron stays a judgement call, not a free win', () => {
    // 'loose' is deliberately outside the refusable band: a bit merry is the
    // player's call and the game does not get to tell them it was right.
    const o = judge(drunk(0.5), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyCleanVibe);
    expect(o.aggroDelta).toBe(T.denyCleanAggro);
  });

  it('a sober patron is unaffected by the drunk branch', () => {
    const o = judge(drunk(0.05), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyCleanVibe);
  });

  it('admitting anyone already showing tells schedules a ripening hit', () => {
    for (const [x, mult] of [[0.5, 1], [0.7, 2], [0.9, 3]] as const) {
      const o = judge(drunk(x), 'admit', ctx({ clockMin: 100 }));
      const ripen = o.deferred?.find((d) => d.reason.includes('already'));
      expect(ripen, `intoxication ${x}`).toBeDefined();
      expect(ripen!.vibeDelta).toBe(T.ripenVibePerStage * mult);
      expect(ripen!.atClockMin).toBe(100 + T.ripenDelayMin * mult);
      expect(ripen!.dazzaText).toBeTruthy();
      expect(ripen!.patronId).toBe('p7');
    }
  });

  it('admitting a sober patron schedules no ripening hit', () => {
    const o = judge(drunk(0.05), 'admit', ctx());
    expect(o.deferred?.some((d) => d.reason.includes('already'))).toBeFalsy();
  });

  it('the ripening hit never lands after the audit', () => {
    const o = judge(drunk(0.9), 'admit', ctx({ clockMin: 355 }));
    const ripen = o.deferred?.find((d) => d.reason.includes('already'));
    expect(ripen!.atClockMin).toBeLessThanOrEqual(T.auditClockMin);
  });

  it('admitting a visibly drunk patron is NOT strictly better than denying them', () => {
    // The encounters review found `quietBeer` had admit dominating deny on BOTH
    // meters with no heat exposure, which made the humane call secretly optimal —
    // the exact thing design §4.3 forbids. Deferred cost is what buys it back.
    const p = drunk(0.5);
    const admit = judge(p, 'admit', ctx());
    const deny = judge(p, 'deny', ctx());
    const admitDeferredVibe = (admit.deferred ?? []).reduce((s, d) => s + (d.vibeDelta ?? 0), 0);
    const admitNet = admit.vibeDelta + admitDeferredVibe;
    expect(admitNet).toBeLessThan(deny.vibeDelta);
  });
});

describe('judge — contraband', () => {
  it('denying someone carrying a severity-3 item is justified', () => {
    const o = judge(makePatron({ flags: { contraband: ['baggie'] } }), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyViolatorVibe);
    expect(o.aggroDelta).toBe(T.denyViolatorAggro);
  });

  it('a kebab or a warm tinnie is not grounds for anything', () => {
    for (const item of ['kebab', 'tinnies', 'flask']) {
      const o = judge(makePatron({ flags: { contraband: [item] } }), 'deny', ctx());
      expect(o.vibeDelta, item).toBe(T.denyCleanVibe);
    }
  });

  it('an unknown contraband id never throws or counts', () => {
    const o = judge(makePatron({ flags: { contraband: ['budgieOfTheseus'] } }), 'deny', ctx());
    expect(o.vibeDelta).toBe(T.denyCleanVibe);
  });
});