// INVARIANT test: ONE list. turnOrderIds === participants.map(id) always.
// No re-sort after startEncounter. nextTurn follows list order, skipping inactive.
// Drag (reorder) overrides initiative — cross-init drag allowed + reflected.
// Display === rotation by construction (same array).
//
// RED now: current code has two lists (sort on display, frozen turnOrderIds),
// reorder throws on cross-init. Refactor (1-list model) greens these.
//
// New API: mutating funcs are async, take ctx last, write encounter + log
// internally, return newEnc. Chained calls become `e = await fn(e, ctx)`.
// No-ops (reorder blocked) return the same enc ref.

'use strict';

const shared = require('@ttrpg/shared');
const {
  makeParticipant,
  startEncounter, nextTurn, addParticipant, removeParticipant,
  toggleParticipantActive, togglePause, applyHpChange,
  reorderParticipants, endEncounter,
} = shared;
const { mockCtx } = require('./_helpers');

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

describe('1-list model: turnOrderIds === participants.map(id), no re-sort', () => {
  test('startEncounter: list = sorted-active participants order', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',3),p('b',10),p('c',5)]);
    e = await startEncounter(e, ctx);
    expect(e.turnOrderIds).toEqual(['b','c','a']); // 10,5,3
    expect(e.turnOrderIds).toEqual(e.participants.map(x => x.id));
  });

  test('startEncounter: inactive stays in list slot (skipped by nextTurn)', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('b',5,{isActive:false}),p('c',3)]);
    e = await startEncounter(e, ctx);
    // 1-list: inactive b stays in slot, nextTurn skips it
    expect(e.turnOrderIds).toEqual(['a','b','c']);
    expect(e.turnOrderIds).toEqual(e.participants.map(x => x.id));
    expect(e.currentTurnParticipantId).toBe('a'); // b inactive, skipped on start
  });

  test('addParticipant mid-encounter: inserted by init, list synced', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('c',3)]);
    e = await startEncounter(e, ctx); // [a,c]
    e = await addParticipant(e, p('b',7), ctx); // insert between a,c
    expect(e.turnOrderIds).toEqual(['a','b','c']);
    expect(e.turnOrderIds).toEqual(e.participants.map(x => x.id));
  });

  test('addParticipant: list === participants.map(id) after add', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10)]);
    e = await startEncounter(e, ctx);
    e = await addParticipant(e, p('b',5), ctx);
    expect(e.turnOrderIds).toEqual(e.participants.map(x => x.id));
  });

  test('removeParticipant: list synced, order preserved', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('b',7),p('c',3)]);
    e = await startEncounter(e, ctx);
    e = await removeParticipant(e, 'b', ctx);
    expect(e.turnOrderIds).toEqual(['a','c']);
    expect(e.turnOrderIds).toEqual(e.participants.map(x => x.id));
  });

  test('reorder cross-init: blocked (no-op)', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('b',7),p('c',3)]);
    e = await startEncounter(e, ctx); // [a,b,c]
    const newEnc = await reorderParticipants(e, 'c', 'a', ctx); // cross-init
    expect(newEnc).toBe(e); // same ref = no write
    expect(e.turnOrderIds).toEqual(['a','b','c']); // unchanged
  });

  test('reorder same-init: within upcoming side of pointer follows new order', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('b',10),p('c',10),p('d',3)]); // a,b,c tie
    e = await startEncounter(e, ctx); // [a,b,c,d], cur=a (idx0)
    // Reorder c before b (both upcoming idx1,2). Within same side = allowed.
    e = await reorderParticipants(e, 'c', 'b', ctx); // [a,c,b,d], cur=a
    expect(e.turnOrderIds).toEqual(['a','c','b','d']);
    // walk: a current, next c, next b, next d, wrap a
    e = await nextTurn(e, ctx);
    expect(e.currentTurnParticipantId).toBe('c');
  });

  test('toggle inactive: list unchanged (stays in rotation slot)', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('b',7),p('c',3)]);
    e = await startEncounter(e, ctx); // [a,b,c]
    e = await toggleParticipantActive(e, 'b', ctx); // b off
    expect(e.turnOrderIds).toEqual(['a','b','c']); // b stays in slot
  });

  test('toggle inactive: nextTurn skips b, visits a→c', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('b',7),p('c',3)]);
    e = await startEncounter(e, ctx); // cur=a
    e = await toggleParticipantActive(e, 'b', ctx); // b inactive
    e = await nextTurn(e, ctx); // skip b → c
    expect(e.currentTurnParticipantId).toBe('c');
  });

  test('hp death + revive: list unchanged', async () => {
    const { ctx } = mockCtx();
    let e = enc([p('a',10),p('b',7),p('c',3)]);
    e = await startEncounter(e, ctx);
    e = await applyHpChange(e, 'b', 'damage', 100, ctx); // b dies
    expect(e.turnOrderIds).toEqual(['a','b','c']);
    e = await applyHpChange(e, 'b', 'heal', 50, ctx); // b revive
    expect(e.turnOrderIds).toEqual(['a','b','c']);
    expect(e.turnOrderIds).toEqual(e.participants.map(x => x.id));
  });
});
