import assert from 'node:assert/strict';
import test from 'node:test';
import { viewGame } from '../game/engine';
import { basicNativeLeaderlessOccupy, basicOccupyNoRicheseLeaderless, finishOccupyLeaderlessPreparation } from './fixture-basic-native-leaderless-occupy';

for (const lead of ['ecaz', 'ally'] as const) for (const dead of ['selected', 'opponent'] as const)
  void test(`Basic Ecaz Occupy ${lead} lead opens public dead-leader preparation for ${dead} after lead settles`, () => {
    const f = basicNativeLeaderlessOccupy({ lead, dead });
    const b = f.game.battle!;
    assert.equal(b.ecazOccupy?.lead, f.selected);
    assert.ok([b.attacker, b.defender].includes(f.selected));
    assert.ok(![b.attacker, b.defender].includes(f.unselected));
    assert.equal(b.basicEarlyLeaderlessVersion, 1);
    assert.equal(b.basicDeadLeaderPreparation, true);
    assert.ok(b.preLeader && !b.preLeader.closed);
    assert.ok(!b.preLeader.ready.includes(f.dead!));
    assert.ok(b.preLeader.ready.every(id => [b.attacker, b.defender].includes(id)));
    assert.deepEqual(b.plans, {});
    const game = finishOccupyLeaderlessPreparation(f.game);
    assert.ok(game.battle);
    assert.deepEqual(game.battle.plans, {});
    assert.ok(game.battle.basicEarlyLeaderless?.includes(f.dead!));
    for (const viewer of game.players)
      assert.ok(viewGame(game, viewer.id).battle!.earlyLeaderless?.includes(f.dead!));
  });

for (const lead of ['ecaz', 'ally'] as const)
  void test(`Basic Ecaz Occupy ${lead} lead does not open dead-leader preparation for a nonleading ally`, () => {
    const f = basicNativeLeaderlessOccupy({ lead, dead: 'unselected' });
    assert.ok(f.game.battle);
    assert.equal(f.game.battle.basicDeadLeaderPreparation, undefined);
    assert.ok(f.game.battle.preLeader && !f.game.battle.preLeader.closed,
      'The original Richese shared preparation is retained');
    const game = finishOccupyLeaderlessPreparation(f.game);
    assert.ok(game.battle?.basicEarlyLeaderless?.includes(f.selected));
    assert.ok(!game.battle?.basicEarlyLeaderless?.includes(f.unselected));
  });

void test('An available shared Duke prevents the Ecaz lead from announcing no leader', () => {
  const f = basicNativeLeaderlessOccupy({ lead: 'ecaz', dead: 'none', duke: true });
  const game = finishOccupyLeaderlessPreparation(f.game);
  assert.equal(game.dukeVidal?.controller, f.fixture.ecaz);
  assert.ok(!game.battle?.basicEarlyLeaderless?.includes(f.fixture.ecaz));
  assert.ok(game.battle?.basicEarlyLeaderless?.includes(f.fixture.opponent));
});

void test('An available Duke still prevents a notice when every Ecaz native leader is dead', () => {
  const f = basicNativeLeaderlessOccupy({ lead: 'ecaz', dead: 'selected', duke: true });
  assert.ok(f.game.battle?.preLeader && !f.game.battle.preLeader.closed,
    'The original Richese shared preparation remains available');
  const game = finishOccupyLeaderlessPreparation(f.game);
  assert.ok(!game.battle?.basicEarlyLeaderless?.includes(f.fixture.ecaz));
  assert.ok(game.battle?.basicEarlyLeaderless?.includes(f.fixture.opponent));
});

void test('Canceled Ecaz Occupy retains the selected lead and its pre-leader opportunity', () => {
  const f = basicNativeLeaderlessOccupy({ lead: 'ally', dead: 'selected', cancel: true });
  assert.equal(f.game.battle?.ecazOccupy?.canceled, true);
  assert.equal(f.game.battle?.ecazOccupy?.lead, f.selected);
  assert.equal(f.game.battle?.basicDeadLeaderPreparation, true);
  const game = finishOccupyLeaderlessPreparation(f.game);
  assert.ok(game.battle?.basicEarlyLeaderless?.includes(f.selected));
});

void test('Audit-entry Basic Occupy without Richese creates neutral preparation for the final dead-leader combatant', () => {
  const f = basicOccupyNoRicheseLeaderless();
  const b = f.game.battle!;
  assert.equal(b.saphoTimingVersion, undefined);
  assert.equal(b.ecazOccupy?.lead, f.fixture.ecaz);
  assert.equal(b.basicDeadLeaderPreparation, true);
  assert.ok(b.preLeader && !b.preLeader.closed);
  assert.ok(!b.preLeader.ready.includes(f.fixture.ecaz));
  assert.ok(b.preLeader.ready.includes(f.fixture.opponent));
  const game = finishOccupyLeaderlessPreparation(f.game);
  assert.ok(game.battle?.basicEarlyLeaderless?.includes(f.fixture.ecaz));
});

void test('Audit-entry Occupy with an available Duke does not add an unnecessary dead-leader preparation', () => {
  const f = basicOccupyNoRicheseLeaderless(true);
  assert.equal(f.game.battle?.ecazOccupy?.lead, f.fixture.ecaz);
  assert.equal(f.game.battle?.basicDeadLeaderPreparation, undefined);
  assert.equal(f.game.battle?.preLeader, undefined);
  assert.ok(!f.game.battle?.basicEarlyLeaderless?.includes(f.fixture.ecaz));
});