import assert from 'node:assert/strict';
import test from 'node:test';
import { applyAction, viewGame, type Game } from '../game/engine';
import { leaders, spiceDeck, treacheryDeck } from '../game/cards';
import { NEXUS_FACTIONS } from '../game/nexus-cards';
import { DISCOVERY_SPICE_CARDS, DISCOVERY_TOKENS } from '../game/discoveries';
import { LEADER_SKILL_CARDS } from '../game/leader-skill-cards';
import { createOccupiedPercentageState } from '../game/homeworld-occupied-percentage';
import {
  createMixedPhaseModulesFixture, mixedPhaseModulesInventory, type MixedPhaseModulesOptions,
} from './fixture-mixed-phase-modules';

function originalOccupation(game: Game) {
  assert.equal(game.homeworldOccupationPreview, true);
  assert.equal(game.pendingHomeworldOccupiedIncome, null);
  assert.deepEqual(game.homeworldOccupiedIncomeHistory, []);
  assert.ok(game.homeworldOccupiedPercentageLedger);
  assert.deepEqual(game.homeworldOccupiedPercentageLedger.receipts, []);
  if (game.players.some(player => player.faction === 'ecaz')) {
    assert.equal(game.homeworldEcazVictoryPreview, true); assert.equal(game.ecazOccupyPreview, true);
  }
}
function originalModules(game: Game, options: MixedPhaseModulesOptions) {
  if (options.nexus) {
    const cards = game.nexusCards?.cards; assert.ok(cards);
    assert.deepEqual([...cards.deck, ...cards.discard, ...Object.values(cards.hands).filter(card => card !== null)].sort(),
      [...NEXUS_FACTIONS].sort());
  } else assert.ok(!game.nexusCards);
  if (options.discoveries) {
    assert.equal(game.discoveryEnabled, true); assert.ok(game.discoveries);
    assert.deepEqual(game.discoveries.tokens.map(token => token.face).sort(), DISCOVERY_TOKENS.map(token => token.id).sort());
    assert.equal(new Set(game.discoveries.tokens.map(token => token.id)).size, 8);
    const cards = [...game.spiceDeck, ...game.spiceDiscard.flat(),
      ...(game.spiceResolution?.skipped ?? []), ...(game.spiceSequence?.skipped ?? [])];
    assert.equal(cards.length, spiceDeck(game.expansions.includes('ix')).length + 7);
    assert.deepEqual(cards.flatMap(card => 'territory' in card && card.discovery ? [card.discovery] : []).sort(),
      DISCOVERY_SPICE_CARDS.map(card => card.discovery).sort());
    assert.equal(cards.filter(card => 'worm' in card && card.greatMaker).length, 1);
  } else assert.ok(!game.discoveryEnabled && !game.discoveries);
  if (options.skills) {
    const skills = game.leaderSkills; assert.ok(skills);
    assert.deepEqual([...skills.deck, ...Object.values(skills.offers).flatMap(offer => offer.cards),
      ...skills.assignments.map(assignment => assignment.skill)].sort(), LEADER_SKILL_CARDS.map(card => card.id).sort());
  } else assert.ok(!game.leaderSkills);
}
function entry(options: MixedPhaseModulesOptions) {
  const f = createMixedPhaseModulesFixture({ ...options, homeworlds: true });
  assert.equal(f.setup.status, 'setup'); originalOccupation(f.setup);
  assert.equal(f.game.status, 'playing'); assert.equal(f.game.turn, 1); assert.equal(f.game.phase, 1);
  originalModules(f.setup, options); originalModules(f.game, options);
  assert.equal(f.nexus, !!options.nexus); assert.equal(f.discoveries, !!options.discoveries);
  assert.equal(f.originalInventory.length, treacheryDeck(options.expansions).length);
  assert.deepEqual(mixedPhaseModulesInventory(f.game), f.originalInventory);
  const firstReady = f.actions.findIndex(step => step.action.type === 'ready');
  for (const [enabled, module] of [[options.nexus, 'nexusCards'], [options.discoveries, 'discoveries']] as const) {
    if (!enabled) continue;
    const selected = f.actions.findIndex(step => step.action.type === 'moduleOption' && step.action.module === module && step.action.enabled === true);
    assert.ok(selected >= 0 && selected < firstReady); assert.equal(f.actions[selected].actor, f.initial.host);
  }
  for (const player of f.afterSetup.players) {
    assert.deepEqual(player.leaders.map(leader => leader.id).sort(), leaders(player.faction).map(leader => leader.id).sort());
    assert.ok(viewGame(f.game, player.id).homeworlds?.worlds?.some(world => world.native === player.id));
    const requested = options.training?.[player.faction];
    if (requested) {
      const assignment = f.afterSetup.leaderSkills!.assignments.find(assignment => assignment.owner === player.id);
      assert.ok(assignment); assert.equal(assignment.skill, requested);
      assert.ok(player.leaders.some(leader => leader.id === assignment.leader));
      assert.ok(f.actions.some(step => step.actor === player.id && step.action.type === 'leaderSkill' &&
        step.action.skill === requested && step.action.leader === assignment.leader));
    }
  }
  assert.ok(!f.game.semutaPreview && !f.game.ecazTreachery);
  assert.deepEqual(f.staging, []); assert.equal(f.sourceActionCount, f.actions.length);
  return f;
}

// These recipes exercise previously registered original World envelopes. They
// do not assert new roster or overlay admission.
void test('public original classic World Nexus and Discovery starts retain ordinary occupation and physical components', () => {
  entry({ factions: ['atreides', 'emperor', 'fremen'], expansions: [], nexus: true, tech: true });
  entry({ factions: ['atreides', 'emperor'], expansions: [], discoveries: true });
});

void test('public original Advanced World Nexus plus Discovery keeps real fourteen-card training and phase modules', () => {
  entry({ factions: ['atreides', 'emperor', 'fremen'], expansions: [], advanced: true,
    nexus: true, discoveries: true, skills: true, tech: true, strongholds: true,
    training: { atreides: 'warmaster', emperor: 'mentat', fremen: 'swordmaster-of-ginaz' } });
});

void test('public admitted paired E1 Nexus and standalone Ecaz Discovery retain original Worlds and occupation state', () => {
  entry({ factions: ['ixians', 'tleilaxu', 'guild'], expansions: ['ix'], nexus: true, tech: true });
  entry({ factions: ['ecaz', 'emperor', 'guild'], expansions: ['ecaz'], discoveries: true });
});

void test('an original World Nexus lobby rejects a pre-existing occupation ledger without overwriting it', () => {
  const f = createMixedPhaseModulesFixture({ factions: ['atreides', 'emperor', 'fremen'], expansions: [],
    homeworlds: true, nexus: true });
  // Controlled negative input only: this otherwise valid original ready lobby
  // has an existing typed ledger before fresh setup is allowed to create one.
  const game = structuredClone(f.lobby);
  game.homeworldOccupiedPercentageLedger = createOccupiedPercentageState();
  const before = structuredClone(game);
  assert.throws(() => applyAction(game, game.host, { type: 'start' }));
  assert.deepEqual(game, before);
});