// Death saves: broken model. Current = single counter, 3=dying. D&D 5e needs
// separate success/fail tracking:
//   3 successes = stable (0hp unconscious, safe until healed)
//   3 failures  = dead
// Current tracks "saves" (really fails via red X UI), no successes at all.
// "Stable" state doesn't exist.
//
// RED was: prove current can't model 3-success stability.
//
// New API: deathSave is async, takes ctx, returns { enc, status, isDying }.
// applyHpChange + startEncounter are async, take ctx, return newEnc.

'use strict';

const { makeParticipant, startEncounter, applyHpChange, deathSave } = require('@ttrpg/shared');
const { mockCtx } = require('./_helpers');

function p(id) {
  return makeParticipant({ id, name: id, type: 'character',
    initiative: 10, maxHp: 100, currentHp: 100 });
}
function enc(ps, extra = {}) {
  return { name:'t', participants:ps, isStarted:false, isPaused:false,
    round:0, currentTurnParticipantId:null, turnOrderIds:[], ...extra };
}

describe('death saves: missing success/stable model', () => {
  test('3 successes makes character stable (not dead, not dying)', async () => {
    const { ctx } = mockCtx();
    // Character at 0hp. Roll 3 successful death saves.
    let e = enc([p('a')]);
    e = await startEncounter(e, ctx);
    e = await applyHpChange(e, 'a', 'damage', 100, ctx); // 0hp
    expect(e.participants[0].currentHp).toBe(0);

    // Roll 3 successful saves. Should mark stable.
    let res;
    res = await deathSave(e, 'a', 'success', 1, ctx); e = res.enc;
    res = await deathSave(e, 'a', 'success', 2, ctx); e = res.enc;
    res = await deathSave(e, 'a', 'success', 3, ctx); e = res.enc;

    expect(res.status).toBe('stable');
    expect(e.participants[0].isDying).toBe(false);
    expect(e.participants[0].isStable).toBe(true);
    expect(e.participants[0].deathFails).toBe(0);
  });

  test('3 failures makes character dead (isDying for removal)', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a')]);
    e = await startEncounter(e, ctx);
    e = await applyHpChange(e, 'a', 'damage', 100, ctx);

    let res;
    res = await deathSave(e, 'a', 'fail', 1, ctx); e = res.enc;
    res = await deathSave(e, 'a', 'fail', 2, ctx); e = res.enc;
    res = await deathSave(e, 'a', 'fail', 3, ctx); e = res.enc;

    expect(res.status).toBe('dead');
    expect(e.participants[0].isDying).toBe(true);
    expect(e.participants[0].deathFails).toBe(3);
  });

  test('successes and fails tracked independently', async () => {
    const { ctx } = mockCtx();
    // Mixed: 1 success, 2 fails, then 2 more successes = stable.
    let e = enc([p('a')]);
    e = await startEncounter(e, ctx);
    e = await applyHpChange(e, 'a', 'damage', 100, ctx);

    let res;
    res = await deathSave(e, 'a', 'success', 1, ctx); e = res.enc;
    expect(e.participants[0].deathSaves).toBe(1);
    expect(e.participants[0].deathFails).toBe(0);

    res = await deathSave(e, 'a', 'fail', 1, ctx); e = res.enc;
    res = await deathSave(e, 'a', 'fail', 2, ctx); e = res.enc;
    expect(e.participants[0].deathSaves).toBe(1);
    expect(e.participants[0].deathFails).toBe(2);

    // 2 more successes → total 3 successes → stable
    res = await deathSave(e, 'a', 'success', 2, ctx); e = res.enc;
    res = await deathSave(e, 'a', 'success', 3, ctx);
    expect(res.status).toBe('stable');
    expect(e.participants[0].deathFails).toBe(2); // fails unchanged
  });

  test('deathSave signature: (enc, id, type, n)', async () => {
    // type = 'success' | 'fail'. n = 1|2|3. ctx appended by async refactor.
    expect(deathSave.length).toBe(5);
  });
});