// 0.2.0 补位 — client side (the approved plan, owner's decision 2026-10-05): the 干员持有 tab's model (storage, toggles,
// the roster by tier, export / import) and its server sync (room.ownership), and the match UI of a not-owned chess —
// the shop / reward card keeps the chess (name, bonds, price) with a 「替补：X」 badge and the stand-in's skill, the own
// pieces' tags, the board / deploy rules of the stand-in's body (position, range), and the detail card's body (portrait,
// class, skill, talents) from the stand-in for the player's own pieces (m.private.standIns) and any unit carrying
// UnitInfo `standInFor`.
import { test, describe } from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
globalThis.fetch = async (url) => {
  const name = String(url).split('/').pop();
  try {
    const body = readFileSync(path.join(ROOT, 'data', name), 'utf8');
    return { ok: true, status: 200, json: async () => JSON.parse(body) };
  } catch {
    return { ok: false, status: 404, json: async () => ({}) };
  }
};

const M = await import('../../public/js/ui/ownershipModel.js');
const { installOwnershipSync, SYNC_DEBOUNCE_MS } = await import('../../public/js/ui/loadoutSync.js');
const { createStore } = await import('../../public/js/store.js');
const G = await import('../../public/js/ui/gameLogic.js');
const { ChessCard } = await import('../../public/js/ui/shopBar.js');
const { ChessDetail, resolveDetail } = await import('../../public/js/ui/detailPanel.js');
const { standInPieces } = await import('../../public/js/screens/game/standInTags.js');
const { OwnCard } = await import('../../public/js/screens/ownership.js');
const { data } = await import('../../public/js/data.js');
const { DATA } = await import('../match/harness.js');

await data.loadAll('chess', 'bonds', 'assets', 'garrisons', 'items', 'backups');

const getChess = (id) => (Object.hasOwn(DATA.chess, id) ? DATA.chess[id] : null);
const BACKUPS = DATA.backups;
const SILVER = 'chess_char_4_22_a'; // 银灰 → Sharp (S2 亮剑)
const MLYSS = 'chess_char_6_11_a'; // 缪尔赛思 (RANGED) → 郁金香 (MELEE)
const SARIA = 'chess_char_5_11_a'; // 塞雷娅 (MELEE) → Touch (RANGED)
const CATHY = 'chess_char_4_11_a'; // 凯瑟琳 (PRESET)

function* walk(v) {
  if (Array.isArray(v)) { for (const x of v) yield* walk(x); return; }
  if (!v || typeof v !== 'object') return;
  yield v;
  yield* walk(v.props?.children);
}
const hasClass = (v, c) => typeof v?.props?.class === 'string' && v.props.class.split(/\s+/).includes(c);
const textOf = (v) => [...walk(v)].flatMap((n) => (Array.isArray(n.props?.children) ? n.props.children : [n.props?.children])).filter((x) => typeof x === 'string' || typeof x === 'number').join('');

describe('干员持有 model (ui/ownershipModel.js)', () => {
  test('storage: tolerant parse, clean sorted ids, round trip; hostile keys dropped', () => {
    assert.deepEqual(M.parseStoredOwnership(null), []);
    assert.deepEqual(M.parseStoredOwnership({ v: 1, notOwned: [SILVER, 'bad id', SILVER, '__proto__', 7, SARIA] }), [SILVER, SARIA].sort());
    assert.deepEqual(M.parseStoredOwnership([MLYSS]), [MLYSS], 'a bare array of an older build');
    assert.deepEqual(M.toStoredOwnership([SARIA, SILVER]), { v: M.OWNERSHIP_VERSION, notOwned: [SILVER, SARIA].sort() });
    assert.deepEqual(M.sanitizeNotOwned([SILVER, CATHY, 'chess_char_9_99_a', getChess(SILVER).goldenId], getChess), [SILVER], 'droppable chess only');
  });
  test('toggles: setOwned / isOwned return new sorted lists', () => {
    let list = [];
    list = M.setOwned(list, SARIA, false);
    list = M.setOwned(list, SILVER);
    assert.deepEqual(list, [SILVER, SARIA].sort());
    assert.equal(M.isOwned(list, SILVER), false);
    assert.equal(M.isOwned(list, MLYSS), true);
    assert.deepEqual(M.setOwned(list, SILVER, true), [SARIA]);
    assert.deepEqual(list, [SILVER, SARIA].sort(), 'input unchanged');
  });
  test('roster: the 53 NORMAL chess of the shop by tier (6 / 13 / 17 / 17); each has its stand-in summary', () => {
    const roster = M.ownershipRoster(data.list('chess'));
    assert.equal(roster.length, 53);
    assert.ok(!roster.some((c) => c.chessType !== 'NORMAL' || c.isGolden || !c.visible));
    assert.deepEqual(M.rosterByTier(roster).map((g) => [g.tier, g.list.length]), [[3, 6], [4, 13], [5, 17], [6, 17]]);
    for (const c of roster) {
      const si = M.standInSummary(c, BACKUPS);
      assert.ok(si && si.charId === c.backup.charId && si.skill.index === c.backup.skillIndex, c.chessId);
    }
    assert.equal(M.standInSummary(getChess(SILVER), BACKUPS).name, 'Sharp');
    assert.equal(M.notOwnedCount([SILVER, CATHY, 'chess_char_6_10_a'], roster), 1, 'PRESET / retired ids do not count');
  });
  test('export / import: versioned envelope, bare arrays and text; junk, newer versions and other kinds refused', () => {
    const text = M.serializeOwnership([SARIA, SILVER], { now: 0 });
    const env = JSON.parse(text);
    assert.deepEqual([env.kind, env.v, env.count, env.notOwned], [M.OWNERSHIP_EXPORT_KIND, 1, 2, [SILVER, SARIA].sort()]);
    assert.deepEqual(M.parseOwnershipImport(text), { ok: true, notOwned: [SILVER, SARIA].sort() });
    assert.deepEqual(M.parseOwnershipImport([MLYSS]), { ok: true, notOwned: [MLYSS] });
    assert.deepEqual(M.parseOwnershipImport({ v: 1, notOwned: [] }), { ok: true, notOwned: [] }, 'an empty list = everything owned');
    assert.equal(M.parseOwnershipImport('').ok, false);
    assert.equal(M.parseOwnershipImport('{nope').ok, false);
    assert.equal(M.parseOwnershipImport({ v: 9, notOwned: [] }).ok, false);
    assert.equal(M.parseOwnershipImport({ kind: 'stronghold.loadout', v: 1, entries: {} }).ok, false);
    assert.equal(M.parseOwnershipImport('x'.repeat(M.OWNERSHIP_IMPORT_MAX_BYTES + 1)).ok, false);
  });
  test('the 干员持有 card is a switch: operator → stand-in; a tap asks for the other state', () => {
    const calls = [];
    const card = OwnCard({ m: data.get('assets'), chess: getChess(SILVER), backups: BACKUPS, owned: true, onToggle: (id, owned) => calls.push([id, owned]) });
    assert.equal(card.props.role, 'switch');
    assert.equal(card.props['aria-checked'], 'true');
    assert.ok(textOf(card).includes('银灰') && textOf(card).includes('Sharp') && textOf(card).includes('S2'));
    card.props.onClick();
    assert.deepEqual(calls, [[SILVER, false]]);
    const off = OwnCard({ m: null, chess: getChess(SILVER), backups: BACKUPS, owned: false, onToggle() {} });
    assert.ok(hasClass(off, 'is-off'));
    assert.equal(off.props['aria-checked'], 'false');
  });
});

// ---- sync -------------------------------------------------------------------------------------------------------------

function fakeNet() {
  const listeners = new Map();
  const net = {
    status: 'online', sent: [], replies: [],
    on(t, fn) { if (!listeners.has(t)) listeners.set(t, new Set()); listeners.get(t).add(fn); return () => listeners.get(t).delete(fn); },
    emit(t, msg) { for (const fn of listeners.get(t) || []) fn(msg); },
    request(t, fields) {
      net.sent.push({ t, ...fields });
      const r = net.replies.shift();
      return r && r.error ? Promise.reject(Object.assign(new Error(r.error), { code: r.error })) : Promise.resolve({ t: 'ok' });
    },
  };
  return net;
}
function fakeTimers() {
  let now = 0;
  let seq = 0;
  const q = new Map();
  return {
    setTimeout: (fn, ms) => { const id = ++seq; q.set(id, { at: now + ms, fn }); return id; },
    clearTimeout: (id) => q.delete(id),
    async advance(ms) {
      const end = now + ms;
      for (;;) {
        const next = [...q.entries()].filter(([, t]) => t.at <= end).sort((a, b) => a[1].at - b[1].at)[0];
        if (!next) break;
        q.delete(next[0]);
        now = next[1].at;
        next[1].fn();
        for (let i = 0; i < 5; i++) await Promise.resolve();
      }
      now = end;
      for (let i = 0; i < 5; i++) await Promise.resolve();
    },
  };
}

test('ownership sync: room.ownership after welcome and after edits (debounced); in a match stored for the next one (told once)', async () => {
  const net = fakeNet();
  const T = fakeTimers();
  const told = [];
  const target = createStore({ notOwned: [SILVER], open: false, ownSync: 'idle' });
  const s = installOwnershipSync({ net, timers: T, target, notify: (t) => told.push(t) });
  net.emit('welcome', {});
  await T.advance(100);
  assert.deepEqual(net.sent, [{ t: 'room.ownership', notOwned: [SILVER] }]);
  assert.equal(target.get().ownSync, 'synced');
  target.set({ notOwned: [SILVER, SARIA].sort() });
  await T.advance(SYNC_DEBOUNCE_MS + 10);
  assert.deepEqual(net.sent[1], { t: 'room.ownership', notOwned: [SILVER, SARIA].sort() });
  // a running match: ROOM_STARTED = stored for the next match, not an error; the edit is told once
  net.replies.push({ error: 'ROOM_STARTED' });
  target.set({ notOwned: [] });
  await T.advance(SYNC_DEBOUNCE_MS + 10);
  assert.equal(target.get().ownSync, 'locked');
  assert.equal(told.length, 1);
  assert.match(told[0], /下一局生效/);
  // back in the lobby: sent again (accepted)
  net.emit('room.state', { inMatch: false });
  await T.advance(SYNC_DEBOUNCE_MS + 10);
  assert.deepEqual(net.sent.at(-1), { t: 'room.ownership', notOwned: [] });
  assert.equal(target.get().ownSync, 'synced');
  s.dispose();
});

// ---- match UI -------------------------------------------------------------------------------------------------------------

describe('match UI of a not-owned chess', () => {
  const priv = { standIns: [SILVER, MLYSS, SARIA], loadout: {}, board: [], hand: [], temp: [] };
  test('gameLogic: own pieces by m.private.standIns (normal + elite); the composed record keeps the identity', () => {
    assert.deepEqual(G.standInIds(priv), [SILVER, MLYSS, SARIA]);
    assert.equal(G.fieldsStandIn(priv, getChess(SILVER)), true);
    assert.equal(G.fieldsStandIn(priv, getChess(getChess(SILVER).goldenId)), true, 'the elite too');
    assert.equal(G.fieldsStandIn({ standIns: [] }, getChess(SILVER)), false);
    assert.equal(G.fieldsStandIn(null, getChess(SILVER)), false);
    const si = G.standInOf(getChess(SILVER), BACKUPS);
    assert.deepEqual([si.charId, si.name, si.standInFor, si.chessId, si.price, si.bonds], ['char_609_acguad', 'Sharp', getChess(SILVER).charId, SILVER, getChess(SILVER).price, getChess(SILVER).bonds]);
    assert.equal(G.standInOf(getChess(SILVER), BACKUPS), si, 'cached');
    assert.equal(G.standInOf(getChess(CATHY), BACKUPS), null, 'PRESET');
    assert.equal(G.standInLabel(si), '替补：Sharp');
    const lo = G.standInLoadout(si, getChess, BACKUPS);
    assert.equal(lo.skill.skillId, 'skchr_acguad_2', 'its backup skill (S2), never the player\'s loadout');
    // the deployed record: the stand-in's for a dropped chess, the loadout's otherwise
    assert.equal(G.deployedRecord(getChess(SILVER), priv, getChess, BACKUPS).charId, 'char_609_acguad');
    assert.equal(G.deployedRecord(getChess(SILVER), { standIns: [] }, getChess, BACKUPS).charId, getChess(SILVER).charId);
    const eg = getChess(getChess(MLYSS).goldenId);
    assert.equal(G.deployedModuleId(eg, priv, getChess, BACKUPS), eg.backup.uniEquipId, 'the backup module (SOL-X)');
  });

  test('placement: a dropped chess is placed by its stand-in\'s position (缪尔赛思 → 郁金香 melee, 塞雷娅 → Touch ranged)', () => {
    const stage = null; // (the deploy tiles are not needed for the placement class)
    const ctx = G.placementContext({ priv, stage, editable: true, getChess, backups: BACKUPS });
    assert.equal(G.piecePosition(ctx, { kind: 'chess', id: MLYSS }), 'MELEE');
    assert.equal(G.piecePosition(ctx, { kind: 'chess', id: SARIA }), 'RANGED');
    const own = G.placementContext({ priv: { standIns: [] }, stage, editable: true, getChess, backups: BACKUPS });
    assert.equal(G.piecePosition(own, { kind: 'chess', id: MLYSS }), 'RANGED');
    assert.equal(G.piecePosition(own, { kind: 'chess', id: SARIA }), 'MELEE');
  });

  test('shop / reward card: the chess\'s name, price and bonds stay, the 「替补：X」 badge and the stand-in\'s skill show', () => {
    const slot = { kind: 'chess', id: SILVER, price: 3, basePrice: 3 };
    const card = ChessCard({ slot, idx: 0, priv, onBuy() {}, onDetail() {} });
    const nodes = [...walk(card)];
    const badge = nodes.find((v) => hasClass(v, 'scard__standin'));
    assert.ok(badge, 'badge');
    assert.equal(badge.props['data-standin'], 'char_609_acguad');
    assert.equal(badge.props.children, '替补：Sharp');
    assert.equal(nodes.find((v) => hasClass(v, 'scard__name')).props.children, '银灰', 'the card keeps the chess\'s name');
    const skill = nodes.find((v) => v?.type && v.props?.lo);
    assert.equal(skill.props.lo.skill.skillId, 'skchr_acguad_2');
    const owned = ChessCard({ slot, idx: 0, priv: { standIns: [] }, onBuy() {}, onDetail() {} });
    assert.equal([...walk(owned)].find((v) => hasClass(v, 'scard__standin')), undefined, 'owned: no badge');
  });

  test('detail card: own piece / card → the stand-in\'s body under the chess\'s name; a unit with standInFor likewise', () => {
    const piece = { uid: 41, kind: 'chess', id: SILVER, golden: false, items: [] };
    const pieces = new Map([[41, { piece, area: 'hand', idx: 0 }]]);
    const r = resolveDetail({ kind: 'piece', uid: 41 }, pieces, { priv, backups: BACKUPS });
    assert.equal(r.standIn?.charId, 'char_609_acguad');
    assert.equal(resolveDetail({ kind: 'piece', uid: 41 }, pieces, { priv: { standIns: [] }, backups: BACKUPS }).standIn, null);
    assert.equal(resolveDetail({ kind: 'chess', id: SILVER }, new Map(), { priv, backups: BACKUPS }).standIn?.charId, 'char_609_acguad', 'a shop card');
    const u = resolveDetail({ kind: 'unit', unit: { id: 9, uid: 99, side: 'ally', kind: 'op', defId: SARIA, standInFor: getChess(SARIA).charId } }, new Map(), { priv: null, backups: BACKUPS });
    assert.equal(u.standIn?.charId, 'char_613_acmedc', 'a teammate\'s unit says it itself');
    const blocks = ChessDetail({ chess: r.chess, piece, editable: false, bonds: [], loadout: null, standIn: r.standIn });
    const head = blocks.find((b) => b.key === 'head');
    const tag = [...walk(head)].find((v) => hasClass(v, 'dtag-standin'));
    assert.equal(tag?.props.children, '替补：Sharp');
    assert.equal([...walk(head)].find((v) => hasClass(v, 'dhead__name')).props.children, '银灰');
    const skill = blocks.find((b) => b.key === 'skill');
    assert.ok(JSON.stringify(skill.props).includes(r.standIn.skill.name), 'the stand-in\'s skill');
    const talents = blocks.find((b) => b.key === 'talents');
    for (const t of r.standIn.talents.filter((x) => x.name && !x.hidden)) assert.ok(JSON.stringify(talents.props).includes(t.name), `talent ${t.name}`);
    assert.ok(!JSON.stringify(blocks).includes(getChess(SILVER).skill.name), 'not the replaced operator\'s skill');
  });

  test('own prep pieces with stand-ins get a tag (hand, temp, board); others none', () => {
    const p = {
      standIns: [SILVER],
      hand: [{ uid: 1, kind: 'chess', id: SILVER }, { uid: 2, kind: 'chess', id: CATHY }, null],
      temp: [{ uid: 3, kind: 'chess', id: getChess(SILVER).goldenId }],
      board: [{ uid: 4, kind: 'chess', id: SILVER, row: 10, col: 4 }, { uid: 5, kind: 'token', id: 'x', row: 9, col: 4 }],
    };
    assert.deepEqual(standInPieces(p, getChess, BACKUPS).map((x) => [x.uid, x.area, x.label]), [[1, 'hand', '替补：Sharp'], [3, 'temp', '替补：Sharp'], [4, 'board', '替补：Sharp']]);
    assert.deepEqual(standInPieces({ ...p, standIns: [] }, getChess, BACKUPS), []);
  });

  test('the board model of a dropped chess is the stand-in\'s (render/app.js pieceInfo reads m.private.standIns; the view is rebuilt when its model changes)', () => {
    const src = readFileSync(path.join(ROOT, 'public/js/render/app.js'), 'utf8');
    assert.match(src, /area === 'board' && chess && standInList\.includes\(chess\.baseId \|\| chess\.chessId\) \? data\.standIn\(piece\.id\) : null/);
    assert.match(src, /standInList = Array\.isArray\(src\.standIns\)/);
    assert.match(src, /const sig = `\$\{info\.kind\}\|\$\{info\.defId\}\|\$\{info\.golden \? 1 : 0\}\|\$\{info\.spine \|\| ''\}`/);
    assert.match(readFileSync(path.join(ROOT, 'public/js/render/app/info.js'), 'utf8'), /standInFor: typeof u\.standInFor === 'string'/);
  });
});