// FlatBuffers payload builders for the Phase 14 / Phase 15 Playwright
// suites. Mirrors what `pkg/transcoder/order.go` produces in production
// for the `user.games.order` POST response and the
// `user.games.order.get` GET response. Phase 15 extends the fixture
// with a `setProductionType` variant so a single mocked gateway can
// echo either rename or production-switch commands back to the client.

import { Builder } from "flatbuffers";

import { uuidToHiLo } from "../../../src/api/game-state";
import { UUID } from "../../../src/proto/galaxy/fbs/common";
import {
	CommandItem,
	CommandPayload,
	CommandPlanetProduce,
	CommandPlanetRename,
	PlanetProduction,
	UserGamesOrder,
	UserGamesOrderGetResponse,
	UserGamesOrderResponse,
} from "../../../src/proto/galaxy/fbs/order";

interface CommandResultFixtureBase {
	cmdId: string;
	applied: boolean | null;
	errorCode: number | null;
}

export interface PlanetRenameResultFixture extends CommandResultFixtureBase {
	kind: "planetRename";
	planetNumber: number;
	name: string;
}

export interface SetProductionTypeResultFixture
	extends CommandResultFixtureBase {
	kind: "setProductionType";
	planetNumber: number;
	productionType:
		| "MAT"
		| "CAP"
		| "DRIVE"
		| "WEAPONS"
		| "SHIELDS"
		| "CARGO"
		| "SCIENCE"
		| "SHIP";
	subject: string;
}

export type CommandResultFixture =
	| PlanetRenameResultFixture
	| SetProductionTypeResultFixture;

export function buildOrderResponsePayload(
	gameId: string,
	commands: CommandResultFixture[],
	updatedAt: number,
): Uint8Array {
	const builder = new Builder(256);
	const itemOffsets = commands.map((c) => encodeItem(builder, c));
	const commandsVec = UserGamesOrderResponse.createCommandsVector(
		builder,
		itemOffsets,
	);
	const [hi, lo] = uuidToHiLo(gameId);
	const gameIdOffset = UUID.createUUID(builder, hi, lo);
	UserGamesOrderResponse.startUserGamesOrderResponse(builder);
	UserGamesOrderResponse.addGameId(builder, gameIdOffset);
	UserGamesOrderResponse.addUpdatedAt(builder, BigInt(updatedAt));
	UserGamesOrderResponse.addCommands(builder, commandsVec);
	const offset = UserGamesOrderResponse.endUserGamesOrderResponse(builder);
	builder.finish(offset);
	return builder.asUint8Array();
}

export function buildOrderGetResponsePayload(
	gameId: string,
	commands: CommandResultFixture[],
	updatedAt: number,
	found = true,
): Uint8Array {
	const builder = new Builder(256);

	let orderOffset = 0;
	if (found) {
		const itemOffsets = commands.map((c) => encodeItem(builder, c));
		const commandsVec = UserGamesOrder.createCommandsVector(
			builder,
			itemOffsets,
		);
		const [hi, lo] = uuidToHiLo(gameId);
		const gameIdOffset = UUID.createUUID(builder, hi, lo);
		UserGamesOrder.startUserGamesOrder(builder);
		UserGamesOrder.addGameId(builder, gameIdOffset);
		UserGamesOrder.addUpdatedAt(builder, BigInt(updatedAt));
		UserGamesOrder.addCommands(builder, commandsVec);
		orderOffset = UserGamesOrder.endUserGamesOrder(builder);
	}

	UserGamesOrderGetResponse.startUserGamesOrderGetResponse(builder);
	UserGamesOrderGetResponse.addFound(builder, found);
	if (orderOffset !== 0) {
		UserGamesOrderGetResponse.addOrder(builder, orderOffset);
	}
	const offset =
		UserGamesOrderGetResponse.endUserGamesOrderGetResponse(builder);
	builder.finish(offset);
	return builder.asUint8Array();
}

function encodeItem(builder: Builder, c: CommandResultFixture): number {
	const cmdIdOffset = builder.createString(c.cmdId);
	let payloadType: CommandPayload;
	let inner: number;
	switch (c.kind) {
		case "planetRename": {
			const nameOffset = builder.createString(c.name);
			inner = CommandPlanetRename.createCommandPlanetRename(
				builder,
				BigInt(c.planetNumber),
				nameOffset,
			);
			payloadType = CommandPayload.CommandPlanetRename;
			break;
		}
		case "setProductionType": {
			const subjectOffset = builder.createString(c.subject);
			inner = CommandPlanetProduce.createCommandPlanetProduce(
				builder,
				BigInt(c.planetNumber),
				productionTypeToFBS(c.productionType),
				subjectOffset,
			);
			payloadType = CommandPayload.CommandPlanetProduce;
			break;
		}
	}
	CommandItem.startCommandItem(builder);
	CommandItem.addCmdId(builder, cmdIdOffset);
	if (c.applied !== null) CommandItem.addCmdApplied(builder, c.applied);
	if (c.errorCode !== null) {
		CommandItem.addCmdErrorCode(builder, BigInt(c.errorCode));
	}
	CommandItem.addPayloadType(builder, payloadType);
	CommandItem.addPayload(builder, inner);
	return CommandItem.endCommandItem(builder);
}

function productionTypeToFBS(
	value: SetProductionTypeResultFixture["productionType"],
): PlanetProduction {
	switch (value) {
		case "MAT":
			return PlanetProduction.MAT;
		case "CAP":
			return PlanetProduction.CAP;
		case "DRIVE":
			return PlanetProduction.DRIVE;
		case "WEAPONS":
			return PlanetProduction.WEAPONS;
		case "SHIELDS":
			return PlanetProduction.SHIELDS;
		case "CARGO":
			return PlanetProduction.CARGO;
		case "SCIENCE":
			return PlanetProduction.SCIENCE;
		case "SHIP":
			return PlanetProduction.SHIP;
	}
}