import type { FactionId } from './catalog';
import {
  HomeworldCustodyError,
  homeworldForceGroups,
  homeworldLocations,
  type HomeworldCustody,
  type HomeworldCustodyContext,
} from './homeworld-custody';

type Cause = 'change' | 'turnStart' | 'turnEnd';
type Source = {
  event: string;
  turn: number;
  cause: Cause | 'setup';
  snapshot: number;
  signature: string;
};
export type HomeworldOccupationQualification = {
  event: string;
  world: string;
  player: string;
  faction: FactionId;
  turn: number;
  cause: 'sole' | 'turnStart' | 'turnEnd';
};
export type HomeworldOccupationHistory = {
  version: 1;
  coverage: 'setup';
  advanced: boolean;
  seats: [string, FactionId][];
  /** Interned canonical public typed force groups, shared across event receipts. */
  snapshots: string[];
  sources: Source[];
  qualifications: HomeworldOccupationQualification[];
  signature: string;
};
type Snapshot = [string, [string, number, number][]][];
const validText = (s: unknown): s is string =>
  typeof s === 'string' && s.trim().length > 0;
const whole = (n: unknown): n is number =>
  Number.isSafeInteger(n) && (n as number) >= 0;
function requireHistory(
  condition: unknown,
  message: string,
): asserts condition {
  if (!condition)
    throw new HomeworldCustodyError(`Homeworld occupation history: ${message}`);
}
function keys(value: unknown, expected: string[]): boolean {
  return (
    !!value &&
    typeof value === 'object' &&
    !Array.isArray(value) &&
    Object.keys(value).length === expected.length &&
    expected.every((key) => Object.hasOwn(value, key))
  );
}
function seats(context: HomeworldCustodyContext): [string, FactionId][] {
  homeworldLocations(context);
  return context.players
    .map((p): [string, FactionId] => [p.id, p.faction])
    .sort((a, b) => a[0].localeCompare(b[0]));
}
function sourceSnapshot(
  context: HomeworldCustodyContext,
  custody: HomeworldCustody,
): string {
  const snapshot: Snapshot = homeworldForceGroups(context, custody).map(
    (home) => [
      home.id,
      Object.entries(home.forces)
        .filter(
          ([player, forces]) =>
            player === home.native || forces.normal + forces.elite > 0,
        )
        .map(([player, forces]): [string, number, number] => [
          player,
          forces.normal,
          forces.elite,
        ])
        .sort((a, b) => a[0].localeCompare(b[0])),
    ],
  );
  snapshot.sort((a, b) => a[0].localeCompare(b[0]));
  return JSON.stringify(snapshot);
}
function readSnapshot(
  value: string,
  context: HomeworldCustodyContext,
): Snapshot {
  requireHistory(typeof value === 'string', 'a source snapshot is missing.');
  let raw: unknown;
  try {
    raw = JSON.parse(value);
  } catch {
    requireHistory(false, 'a source snapshot is malformed.');
  }
  const homes = homeworldLocations(context);
  requireHistory(
    Array.isArray(raw) && raw.length === homes.length,
    'a source snapshot needs every seated world.',
  );
  const visited = new Set<string>();
  const reserves = new Map(
    context.players.map((p) => [p.id, { normal: 0, elite: 0 }]),
  );
  const custody: HomeworldCustody = { visitors: {}, salusa: null };
  for (const row of raw) {
    requireHistory(
      Array.isArray(row) &&
        row.length === 2 &&
        validText(row[0]) &&
        Array.isArray(row[1]),
      'invalid world source row.',
    );
    const home = homes.find((h) => h.id === row[0]);
    requireHistory(
      home && !visited.has(home.id),
      'a source world is unknown or repeated.',
    );
    visited.add(home.id);
    const players = new Set<string>();
    for (const group of row[1]) {
      requireHistory(
        Array.isArray(group) &&
          group.length === 3 &&
          validText(group[0]) &&
          reserves.has(group[0]) &&
          !players.has(group[0]) &&
          whole(group[1]) &&
          whole(group[2]),
        'invalid typed source army.',
      );
      const [player, normal, elite] = group as [string, number, number];
      players.add(player);
      if (player === home.native) {
        const total = reserves.get(player)!;
        total.normal += normal;
        total.elite += elite;
        if (home.secondary) custody.salusa = { normal, elite };
      } else (custody.visitors[home.id] ??= {})[player] = { normal, elite };
    }
    requireHistory(
      players.has(home.native),
      'the native physical pool is missing.',
    );
  }
  const historical: HomeworldCustodyContext = {
    advanced: context.advanced,
    players: context.players.map((p) => {
      const total = reserves.get(p.id)!;
      return {
        id: p.id,
        faction: p.faction,
        reserves: total.normal + total.elite,
        eliteReserves: total.elite,
      };
    }),
  };
  requireHistory(
    sourceSnapshot(historical, custody) === value,
    'source armies are not canonical or physically valid.',
  );
  return raw as Snapshot;
}
function sourceSignature(
  source: Omit<Source, 'signature'>,
  snapshot: string,
): string {
  return JSON.stringify([
    'homeworldOccupationSource',
    source.event,
    source.turn,
    source.cause,
    snapshot,
  ]);
}
function historySignature(history: HomeworldOccupationHistory): string {
  return JSON.stringify([
    'homeworldOccupationHistory',
    history.version,
    history.coverage,
    history.advanced,
    history.seats,
    history.snapshots,
    history.sources,
    history.qualifications,
  ]);
}
function facts(
  source: Source,
  snapshot: Snapshot,
  context: HomeworldCustodyContext,
): HomeworldOccupationQualification[] {
  if (source.cause === 'setup') return [];
  const homes = homeworldLocations(context);
  const result: HomeworldOccupationQualification[] = [];
  for (const [world, groups] of snapshot) {
    const native = homes.find((home) => home.id === world)!.native;
    const present = groups.filter(([, normal, elite]) => normal + elite > 0);
    const foreign =
      source.cause === 'change'
        ? present.length === 1 && present[0][0] !== native
          ? present
          : []
        : present.filter(([player]) => player !== native);
    for (const [player] of foreign)
      result.push({
        event: source.event,
        world,
        player,
        faction: context.players.find((p) => p.id === player)!.faction,
        turn: source.turn,
        cause: source.cause === 'change' ? 'sole' : source.cause,
      });
  }
  return result;
}
const factKey = (fact: HomeworldOccupationQualification) =>
  JSON.stringify([fact.world, fact.player, fact.turn, fact.cause]);

/** Validate stored evidence independently of today's physical garrisons. This
 * proves recorded qualification, never current entitlement or a spice award. */
export function validateHomeworldOccupationHistory(
  history: HomeworldOccupationHistory,
  context: HomeworldCustodyContext,
  currentTurn?: number,
): void {
  requireHistory(
    keys(history, [
      'version',
      'coverage',
      'advanced',
      'seats',
      'snapshots',
      'sources',
      'qualifications',
      'signature',
    ]) &&
      history.version === 1 &&
      history.coverage === 'setup' &&
      history.advanced === context.advanced &&
      JSON.stringify(history.seats) === JSON.stringify(seats(context)) &&
      Array.isArray(history.snapshots) &&
      history.snapshots.length > 0 &&
      Array.isArray(history.sources) &&
      history.sources.length > 0 &&
      Array.isArray(history.qualifications),
    'the initialized record or seated world roster is invalid.',
  );
  if (currentTurn !== undefined)
    requireHistory(
      whole(currentTurn) && currentTurn > 0,
      'invalid current turn.',
    );
  requireHistory(
    new Set(history.snapshots).size === history.snapshots.length,
    'source snapshots must be interned.',
  );
  const snapshots = history.snapshots.map((value) =>
    readSnapshot(value, context),
  );
  const events = new Set<string>(),
    used = new Set<number>(),
    seenFacts = new Set<string>();
  const expected: HomeworldOccupationQualification[] = [];
  let lastTurn = 0;
  for (const [index, source] of history.sources.entries()) {
    requireHistory(
      keys(source, ['event', 'turn', 'cause', 'snapshot', 'signature']) &&
        validText(source.event) &&
        !events.has(source.event) &&
        whole(source.turn) &&
        source.turn > 0 &&
        source.turn >= lastTurn &&
        (currentTurn === undefined || source.turn <= currentTurn) &&
        (index === 0
          ? source.cause === 'setup'
          : ['change', 'turnStart', 'turnEnd'].includes(source.cause)) &&
        whole(source.snapshot) &&
        source.snapshot < snapshots.length,
      'a source event is duplicated, stale, future or malformed.',
    );
    events.add(source.event);
    used.add(source.snapshot);
    lastTurn = source.turn;
    requireHistory(
      source.signature ===
        sourceSignature(source, history.snapshots[source.snapshot]),
      'source event physical facts changed.',
    );
    if (index === 0) {
      const homes = homeworldLocations(context);
      requireHistory(
        snapshots[source.snapshot].every(([world, groups]) =>
          groups.every(
            ([player]) =>
              player === homes.find((home) => home.id === world)!.native,
          ),
        ),
        'setup cannot prove history while foreign armies are present.',
      );
    }
    for (const fact of facts(source, snapshots[source.snapshot], context)) {
      const key = factKey(fact);
      if (!seenFacts.has(key)) {
        expected.push(fact);
        seenFacts.add(key);
      }
    }
  }
  requireHistory(
    used.size === snapshots.length,
    'unreferenced source snapshots are invalid.',
  );
  requireHistory(
    history.qualifications.every((fact) =>
      keys(fact, ['event', 'world', 'player', 'faction', 'turn', 'cause']),
    ) && JSON.stringify(history.qualifications) === JSON.stringify(expected),
    'qualification evidence no longer matches the independent source facts.',
  );
  requireHistory(
    history.signature === historySignature(history),
    'the signed history was changed.',
  );
}

export function createHomeworldOccupationHistory(
  context: HomeworldCustodyContext,
  custody: HomeworldCustody,
  turn: number,
  event: string,
): HomeworldOccupationHistory {
  requireHistory(
    Object.keys(custody.visitors).length === 0,
    'setup requires empty foreign custody.',
  );
  const snapshot = sourceSnapshot(context, custody);
  const source: Source = {
    event,
    turn,
    cause: 'setup',
    snapshot: 0,
    signature: '',
  };
  source.signature = sourceSignature(source, snapshot);
  const history: HomeworldOccupationHistory = {
    version: 1,
    coverage: 'setup',
    advanced: context.advanced,
    seats: seats(context),
    snapshots: [snapshot],
    sources: [source],
    qualifications: [],
    signature: '',
  };
  history.signature = historySignature(history);
  validateHomeworldOccupationHistory(history, context, turn);
  return history;
}

/** Observe only committed semantic changes. Simultaneous destruction belongs to
 * one caller event; separately ordered loser/winner losses need separate events. */
export function observeHomeworldOccupation(
  history: HomeworldOccupationHistory,
  context: HomeworldCustodyContext,
  custody: HomeworldCustody,
  turn: number,
  cause: Cause,
  event: string,
): HomeworldOccupationHistory {
  validateHomeworldOccupationHistory(history, context, turn);
  requireHistory(
    whole(turn) &&
      turn > 0 &&
      validText(event) &&
      ['change', 'turnStart', 'turnEnd'].includes(cause),
    'invalid observation event.',
  );
  const snapshot = sourceSnapshot(context, custody);
  const prior = history.sources.find((source) => source.event === event);
  if (prior) {
    requireHistory(
      prior.turn === turn &&
        prior.cause === cause &&
        history.snapshots[prior.snapshot] === snapshot,
      'a repeated source event has different physical facts.',
    );
    return structuredClone(history);
  }
  const latest = history.sources.at(-1)!;
  requireHistory(
    turn >= latest.turn,
    'observations cannot move backwards in time.',
  );
  if (
    cause === 'change' &&
    latest.turn === turn &&
    history.snapshots[latest.snapshot] === snapshot
  )
    return structuredClone(history);
  const result = structuredClone(history);
  let index = result.snapshots.indexOf(snapshot);
  if (index < 0) {
    index = result.snapshots.length;
    result.snapshots.push(snapshot);
  }
  const source: Source = { event, turn, cause, snapshot: index, signature: '' };
  source.signature = sourceSignature(source, snapshot);
  result.sources.push(source);
  const existing = new Set(result.qualifications.map(factKey));
  for (const fact of facts(source, readSnapshot(snapshot, context), context)) {
    if (!existing.has(factKey(fact))) {
      result.qualifications.push(fact);
      existing.add(factKey(fact));
    }
  }
  result.signature = historySignature(result);
  return result;
}

/** No qualification since proven setup is affirmative evidence. A past qualifier
 * or absent legacy history needs the pending entitlement/expiry ruling. */
export function tupileOccupationStatus(
  history: HomeworldOccupationHistory | undefined,
  context: HomeworldCustodyContext,
  currentTurn?: number,
): 'unoccupied' | 'unknown' {
  if (history === undefined) return 'unknown';
  validateHomeworldOccupationHistory(history, context, currentTurn);
  const native = context.players.find((p) => p.faction === 'choam');
  if (!native) return 'unknown';
  return history.qualifications.some((fact) => fact.world === 'homeworld:choam')
    ? 'unknown'
    : 'unoccupied';
}