import {createEntityCollection} from "../utils/entity";
import {Part} from "./part";
import {Region} from "./region";
import {
    Command,
    CommandRegistry,
    type CommandRunner, CommandRunnerContext,
    CommandRunnerContextExport, CommandSchema,
    createCommandRunnerContext, parseCommandSchema,
    PromptEvent
} from "../utils/command";
import {AsyncQueue} from "../utils/async-queue";

export interface IGameContext<TState extends {} = {}> {
    parts: ReturnType<typeof createEntityCollection<Part>>;
    regions: ReturnType<typeof createEntityCollection<Region>>;
    commands: CommandRunnerContextExport<IGameContext<TState>>;
    prompts: AsyncQueue<PromptEvent>;
}

export function createGameContext<TState extends {} = {}>(
    commandRegistry: CommandRegistry<IGameContext<TState>>,
    initialState?: TState | (() => TState)
): IGameContext<TState> {
    const parts = createEntityCollection<Part>();
    const regions = createEntityCollection<Region>();
    const prompts = new AsyncQueue<PromptEvent>();
    const state: TState = typeof initialState === 'function' ? (initialState as (() => TState))() : (initialState ?? {} as TState);

    const ctx = {
        parts,
        regions,
        prompts,
        commands: null!,
        state,
    } as IGameContext<TState>

    ctx.commands = createCommandRunnerContext(commandRegistry, ctx);
    ctx.commands.on('prompt', (prompt: PromptEvent) => ctx.prompts.push(prompt));

    return ctx;
}

/**
 * so that we can do `import * as tictactoe from './tic-tac-toe.ts';\n\n createGameContextFromModule(tictactoe);`
 * @param module
 */
export function createGameContextFromModule<TState extends {} = {}>(
    module: {
        registry: CommandRegistry<IGameContext<TState>>,
        createInitialState: () => TState
    },
): IGameContext<TState> {
    return createGameContext(module.registry, module.createInitialState);
}

export function createGameCommand<TState extends {} = {}, TResult = unknown>(
    schema: CommandSchema | string,
    run: (this: CommandRunnerContext<IGameContext<TState>>, command: Command) => Promise<TResult>
): CommandRunner<IGameContext<TState>, TResult> {
    return {
        schema: typeof schema === 'string' ? parseCommandSchema(schema) : schema,
        run,
    };
}