import test from 'node:test';
import assert from 'node:assert/strict';
import { createGame, initializeDiscoveryGameForAudit, initializeLeaderSkillsGameForAudit, initializeNexusGameForAudit, joinGame, newPlayer, RuleError, type Game } from '../game/engine';
import type { FactionId } from '../game/catalog';
import { createTechTokens } from '../game/tech-tokens';
import { createStrongholdCards } from '../game/stronghold-cards';

function lobby(roster: FactionId[], expansions: string[], advanced = true): Game {
  const game = createGame('DISCINIT', newPlayer(roster[0], roster[0], roster[0]), advanced, expansions);
  for (const faction of roster.slice(1)) joinGame(game, newPlayer(faction, faction, faction));
  for (const player of game.players) player.ready = true;
  game.discoveryEnabled = true;
  return game;
}

void test('Discovery requires the selected native family and does not admit unsupported mixed E3', () => {
  const unsupported = [
    lobby(['ixians', 'guild'], []),
    lobby(['richese', 'guild'], ['ix']),
    lobby(['ixians', 'guild'], ['ecaz']),
    lobby(['moritani', 'harkonnen', 'guild'], ['ecaz']),
  ];
  for (const game of unsupported) assert.throws(() => initializeDiscoveryGameForAudit(game), RuleError);
  for (const advanced of [false, true]) {
    const paired = initializeDiscoveryGameForAudit(lobby(['ecaz', 'moritani', 'guild'], ['ecaz'], advanced));
    assert.equal(paired.discoveries?.tokens.length, 8);
    assert.equal(paired.status, 'setup');
    assert.deepEqual(paired.players.map(player => player.faction), ['ecaz', 'moritani', 'guild']);
    assert.equal(paired.nexusCards, undefined);
    assert.equal(paired.ecazTreachery, undefined);
  }
  // The Advanced Moritani/Harkonnen restriction is not a new Basic restriction.
  const basic = initializeDiscoveryGameForAudit(lobby(['moritani', 'harkonnen', 'guild'], ['ecaz'], false));
  assert.equal(basic.moritaniAssassinatePreview, undefined);
  assert.equal(basic.discoveries?.tokens.length, 8);
});

void test('Discovery accepts mixed selected decks without requiring a native seat from each', () => {
  for (const advanced of [false, true]) for (const expansions of [
    ['ecaz','ix'], ['ecaz','choam'], ['ecaz','ix','choam'],
  ]) {
    const game = lobby(['ecaz','moritani','guild'], expansions, advanced);
    const started = initializeDiscoveryGameForAudit(game);
    assert.equal(started.discoveries?.tokens.length, 8);
    assert.equal(started.nexusCards, undefined);
    assert.equal(started.ecazTreachery, undefined);
    assert.ok(initializeDiscoveryGameForAudit(lobby(['guild','atreides'], expansions, advanced)).discoveries);
  }
  assert.throws(() => initializeDiscoveryGameForAudit(
    lobby(['ecaz','moritani','harkonnen'], ['ecaz','ix'], true)), RuleError);
});

void test('Discovery Tech requires three seats and untouched physical tokens', () => {
  const two = lobby(['ixians', 'tleilaxu'], ['ix']); two.techTokens = createTechTokens();
  assert.throws(() => initializeDiscoveryGameForAudit(two), RuleError);
  const used = lobby(['choam', 'richese', 'guild'], ['choam']); used.techTokens = createTechTokens();
  used.techTokens.production.owner = 'choam';
  assert.throws(() => initializeDiscoveryGameForAudit(used), RuleError);
  const fresh = lobby(['ixians', 'tleilaxu', 'guild'], ['ix']); fresh.techTokens = createTechTokens();
  const initialized = initializeDiscoveryGameForAudit(fresh);
  assert.equal(initialized.techTokens?.heighliners.owner, 'ixians');
  assert.equal(initialized.techTokens?.axlotl.owner, 'tleilaxu');
  assert.equal(initialized.discoveryEnabled, true);
});

void test('paired E3 Discovery keeps the original optional-module seat and rules limits', () => {
  const factions: FactionId[] = ['ecaz', 'moritani', 'guild', 'atreides', 'emperor', 'beneGesserit'];
  for (const advanced of [false, true]) for (const count of [2, 3, 6]) {
    const game = lobby(factions.slice(0, count), ['ecaz'], advanced);
    if (count >= 3) game.techTokens = createTechTokens();
    if (advanced) game.strongholdCards = createStrongholdCards();
    const started = initializeDiscoveryGameForAudit(game);
    assert.equal(started.discoveries?.tokens.length, 8);
    assert.equal(!!started.techTokens, count >= 3);
    assert.equal(!!started.strongholdCards, advanced);
  }
  const twoWithTech = lobby(factions.slice(0, 2), ['ecaz']);
  twoWithTech.techTokens = createTechTokens();
  assert.throws(() => initializeDiscoveryGameForAudit(twoWithTech), RuleError);
  const basicStrongholds = lobby(factions.slice(0, 3), ['ecaz'], false);
  basicStrongholds.strongholdCards = createStrongholdCards();
  assert.throws(() => initializeDiscoveryGameForAudit(basicStrongholds), RuleError);
  assert.throws(() => initializeDiscoveryGameForAudit(lobby(['ecaz','moritani','harkonnen'], ['ecaz'], true)), RuleError);
  assert.ok(initializeDiscoveryGameForAudit(lobby(['ecaz','moritani','harkonnen'], ['ecaz'], false)).discoveries);
});

void test('Discovery cannot redeal started components or silently remove another module', () => {
  const initial = lobby(['ixians', 'tleilaxu', 'guild'], ['ix']);
  const started = initializeDiscoveryGameForAudit(initial);
  assert.throws(() => initializeDiscoveryGameForAudit(started), RuleError);
  const overlays: Game[] = [structuredClone(initial), structuredClone(initial)];
  overlays[0].nexusCards = { cards: null, phase: null };
  overlays[1].advanced = false; overlays[1].strongholdCards = createStrongholdCards();
  for (const game of overlays) assert.throws(() => initializeDiscoveryGameForAudit(game), RuleError);
});

void test('Discovery Skills cannot silently drop unsupported native families or unrelated modules and previews', () => {
  const unsupported = lobby(['ixians', 'ecaz', 'guild'], ['ix', 'ecaz']);
  assert.throws(() => initializeLeaderSkillsGameForAudit(unsupported), RuleError);
  const basicStrongholds = lobby(['guild', 'emperor', 'harkonnen'], []);
  basicStrongholds.advanced = false; basicStrongholds.strongholdCards = createStrongholdCards();
  assert.throws(() => initializeLeaderSkillsGameForAudit(basicStrongholds), RuleError);
  const two = lobby(['guild', 'emperor'], []); two.techTokens = createTechTokens();
  assert.throws(() => initializeLeaderSkillsGameForAudit(two), RuleError);
});

void test('Discovery Skills cannot replace already initialized Discovery components', () => {
  const started = initializeDiscoveryGameForAudit(lobby(['guild', 'emperor', 'harkonnen'], []));
  assert.throws(() => initializeLeaderSkillsGameForAudit(started), RuleError);
});

void test('Discovery Nexus rejects used components and incompatible prerequisites before redealing', () => {
  const two = lobby(['guild', 'emperor'], []);
  two.nexusCards = { cards: null, phase: null }; two.techTokens = createTechTokens();
  assert.throws(() => initializeNexusGameForAudit(two), RuleError);
  const basic = lobby(['guild', 'emperor', 'fremen'], [], false);
  basic.nexusCards = { cards: null, phase: null }; basic.strongholdCards = createStrongholdCards();
  assert.throws(() => initializeNexusGameForAudit(basic), RuleError);
  const used = lobby(['guild', 'emperor', 'fremen'], []);
  used.nexusCards = { cards: null, phase: null }; used.techTokens = createTechTokens();
  used.techTokens.production.owner = used.host;
  assert.throws(() => initializeNexusGameForAudit(used), RuleError);
  const started = initializeDiscoveryGameForAudit(lobby(['guild', 'emperor', 'fremen'], []));
  started.nexusCards = { cards: null, phase: null };
  assert.throws(() => initializeNexusGameForAudit(started), RuleError);
});

void test('Discovery original Stronghold composition rejects already claimed cards instead of granting or redealing them', () => {
  for (const initialize of [initializeDiscoveryGameForAudit, initializeLeaderSkillsGameForAudit]) {
    const owner = lobby(['guild', 'emperor', 'fremen'], []);
    owner.strongholdCards = createStrongholdCards();
    owner.strongholdCards.owners.arrakeen = 'guild';
    const before = JSON.stringify(owner);
    assert.throws(() => initialize(owner), RuleError);
    assert.equal(JSON.stringify(owner), before);
    const settled = lobby(['guild', 'emperor', 'fremen'], []);
    settled.strongholdCards = createStrongholdCards();
    settled.strongholdCards.claimedTurn = 1;
    assert.throws(() => initialize(settled), RuleError);
  }
});