boardgame-core/src/core/rule.ts

import {Command, CommandSchema, parseCommand, parseCommandSchema} from "../utils/command";
import { defineSchema, type ParseError } from 'inline-schema';

export type RuleState = 'running' | 'yielded' | 'waiting' | 'invoking' | 'done';

export type InvokeYield = {
    type: 'invoke';
    rule: string;
    command: Command;
};

export type RuleYield = string | CommandSchema | InvokeYield;

export type RuleContext<T = unknown> = {
    type: string;
    schema?: CommandSchema;
    generator: Generator<RuleYield, T, Command | RuleContext<unknown>>;
    parent?: RuleContext<unknown>;
    children: RuleContext<unknown>[];
    state: RuleState;
    resolution?: T;
}

export type RuleDef<T = unknown> = {
    schema: CommandSchema;
    create: (this: GameContextLike, cmd: Command) => Generator<RuleYield, T, Command | RuleContext<unknown>>;
};

export type RuleRegistry = Map<string, RuleDef<unknown>>;

export function createRule<T>(
    schemaStr: string,
    fn: (this: GameContextLike, cmd: Command) => Generator<RuleYield, T, Command | RuleContext<unknown>>
): RuleDef<T> {
    return {
        schema: parseCommandSchema(schemaStr, ''),
        create: fn as RuleDef<T>['create'],
    };
}

function isInvokeYield(value: RuleYield): value is InvokeYield {
    return typeof value === 'object' && value !== null && 'type' in value && (value as InvokeYield).type === 'invoke';
}

function parseYieldedSchema(value: string | CommandSchema): CommandSchema {
    if (typeof value === 'string') {
        return parseCommandSchema(value, '');
    }
    return value;
}

function parseCommandWithSchema(command: Command, schema: CommandSchema): Command {
    const parsedParams: unknown[] = [...command.params];
    for (let i = 0; i < command.params.length; i++) {
        const paramSchema = schema.params[i]?.schema;
        if (paramSchema && typeof command.params[i] === 'string') {
            try {
                parsedParams[i] = paramSchema.parse(command.params[i] as string);
            } catch {
                // keep original value
            }
        }
    }

    const parsedOptions: Record<string, unknown> = { ...command.options };
    for (const [key, value] of Object.entries(command.options)) {
        const optSchema = schema.options.find(o => o.name === key || o.short === key);
        if (optSchema?.schema && typeof value === 'string') {
            try {
                parsedOptions[key] = optSchema.schema.parse(value);
            } catch {
                // keep original value
            }
        }
    }

    return { ...command, params: parsedParams, options: parsedOptions };
}

function pushContextToGame(game: GameContextLike, ctx: RuleContext<unknown>) {
    game.contexts.value = [...game.contexts.value, { value: ctx } as any];
    game.addRuleContext(ctx);
}

function discardChildren(game: GameContextLike, parent: RuleContext<unknown>) {
    for (const child of parent.children) {
        game.removeRuleContext(child);

        const ctxIdx = game.contexts.value.findIndex((c: any) => c.value === child);
        if (ctxIdx !== -1) {
            const arr = [...game.contexts.value];
            arr.splice(ctxIdx, 1);
            game.contexts.value = arr;
        }
    }
    parent.children = [];
    parent.state = 'yielded';
}

function validateYieldedSchema(command: Command, schema: CommandSchema): boolean {
    const requiredParams = schema.params.filter(p => p.required);
    const variadicParam = schema.params.find(p => p.variadic);

    if (command.params.length < requiredParams.length) {
        return false;
    }

    if (!variadicParam && command.params.length > schema.params.length) {
        return false;
    }

    const requiredOptions = schema.options.filter(o => o.required);
    for (const opt of requiredOptions) {
        const hasOption = opt.name in command.options || (opt.short && opt.short in command.options);
        if (!hasOption) {
            return false;
        }
    }

    return true;
}

function invokeChildRule(
    game: GameContextLike,
    ruleName: string,
    command: Command,
    parent: RuleContext<unknown>
): RuleContext<unknown> {
    const ruleDef = game.rules.get(ruleName)!;
    const ctx: RuleContext<unknown> = {
        type: ruleDef.schema.name,
        schema: undefined,
        generator: ruleDef.create.call(game, command),
        parent,
        children: [],
        state: 'running',
        resolution: undefined,
    };

    parent.children.push(ctx);
    pushContextToGame(game, ctx);

    return stepGenerator(game, ctx);
}

function resumeInvokingParent(
    game: GameContextLike,
    childCtx: RuleContext<unknown>
): RuleContext<unknown> | undefined {
    const parent = childCtx.parent;
    if (!parent || parent.state !== 'invoking') return undefined;

    parent.children = parent.children.filter(c => c !== childCtx);

    const result = parent.generator.next(childCtx);
    if (result.done) {
        (parent as RuleContext<unknown>).resolution = result.value;
        (parent as RuleContext<unknown>).state = 'done';
        const resumed = resumeInvokingParent(game, parent);
        return resumed ?? parent;
    } else if (isInvokeYield(result.value)) {
        (parent as RuleContext<unknown>).state = 'invoking';
        const childCtx2 = invokeChildRule(game, result.value.rule, result.value.command, parent);
        return childCtx2;
    } else {
        (parent as RuleContext<unknown>).schema = parseYieldedSchema(result.value);
        (parent as RuleContext<unknown>).state = 'yielded';
    }

    return parent;
}

function stepGenerator<T>(
    game: GameContextLike,
    ctx: RuleContext<T>
): RuleContext<T> {
    const result = ctx.generator.next();

    if (result.done) {
        ctx.resolution = result.value;
        ctx.state = 'done';
        const resumed = resumeInvokingParent(game, ctx as RuleContext<unknown>);
        if (resumed) return resumed as RuleContext<T>;
    } else if (isInvokeYield(result.value)) {
        const childRuleDef = game.rules.get(result.value.rule);
        if (childRuleDef) {
            ctx.state = 'invoking';
            const childCtx = invokeChildRule(game, result.value.rule, result.value.command, ctx as RuleContext<unknown>);
            return childCtx as RuleContext<T>;
        } else {
            ctx.schema = parseYieldedSchema('');
            ctx.state = 'yielded';
        }
    } else {
        ctx.schema = parseYieldedSchema(result.value);
        ctx.state = 'yielded';
    }

    return ctx;
}

function invokeRule<T>(
    game: GameContextLike,
    command: Command,
    ruleDef: RuleDef<T>,
    parent?: RuleContext<unknown>
): RuleContext<T> {
    const ctx: RuleContext<T> = {
        type: ruleDef.schema.name,
        schema: undefined,
        generator: ruleDef.create.call(game, command),
        parent,
        children: [],
        state: 'running',
        resolution: undefined,
    };

    if (parent) {
        discardChildren(game, parent);
        parent.children.push(ctx as RuleContext<unknown>);
        parent.state = 'waiting';
    }

    pushContextToGame(game, ctx as RuleContext<unknown>);

    return stepGenerator(game, ctx);
}

export function dispatchCommand(game: GameContextLike, input: string): RuleContext<unknown> | undefined {
    const command = parseCommand(input);

    if (game.rules.has(command.name)) {
        const ruleDef = game.rules.get(command.name)!;

        const parent = findYieldedParent(game);

        return invokeRule(game, command, ruleDef, parent);
    }

    for (let i = game.ruleContexts.length - 1; i >= 0; i--) {
        const ctx = game.ruleContexts[i];
        if (ctx.state === 'yielded' && ctx.schema) {
            if (validateYieldedSchema(command, ctx.schema)) {
                const result = ctx.generator.next(command);
                if (result.done) {
                    ctx.resolution = result.value;
                    ctx.state = 'done';
                    const resumed = resumeInvokingParent(game, ctx);
                    return resumed ?? ctx;
                } else if (isInvokeYield(result.value)) {
                    ctx.state = 'invoking';
                    const childCtx = invokeChildRule(game, result.value.rule, result.value.command, ctx);
                    return childCtx;
                } else {
                    ctx.schema = parseYieldedSchema(result.value);
                    ctx.state = 'yielded';
                }
                return ctx;
            }
        }
    }

    return undefined;
}

function findYieldedParent(game: GameContextLike): RuleContext<unknown> | undefined {
    for (let i = game.ruleContexts.length - 1; i >= 0; i--) {
        const ctx = game.ruleContexts[i];
        if (ctx.state === 'yielded') {
            return ctx;
        }
    }
    return undefined;
}

export type GameContextLike = {
    rules: RuleRegistry;
    ruleContexts: RuleContext<unknown>[];
    contexts: { value: any[] };
    addRuleContext: (ctx: RuleContext<unknown>) => void;
    removeRuleContext: (ctx: RuleContext<unknown>) => void;
    parts: {
        collection: { value: Record<string, any> };
        add: (...entities: any[]) => void;
        remove: (...ids: string[]) => void;
        get: (id: string) => any;
    };
    regions: {
        collection: { value: Record<string, any> };
        add: (...entities: any[]) => void;
        remove: (...ids: string[]) => void;
        get: (id: string) => any;
    };
    pushContext: (context: any) => any;
    popContext: () => void;
    latestContext: <T>(type: string) => any | undefined;
};