import { clone, extractErrorMsg, pickRandom_Letters } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";

import { GLOBAL_LOG_A_LOT } from "../../constants.mjs";
import { APIFunctionInfo } from "../api-types.mjs";
import { getCommandService } from "./command-service-v1.mjs";
import { CommandDataBase } from "./command-types.mjs";

const logalot = GLOBAL_LOG_A_LOT;

/**
 * customizing function to create the schema specific to some concrete schema
 * description/instructions.
 */
export function tweakGeminiSchema({
    baseSchema,
    addlDescription,
}: {
    /**
     * starting schema which we will customize.
     */
    baseSchema: any,
    /**
     * additional description, to be used for concrete schema descriptions.
     * If there is no description to begin with, this will simply set the
     * description.
     *
     * For example, with destroy renderable, describe that this will recursively
     * destroy children. With update renderable, this will apply the changes
     * recursively to all children (like setting color).
     */
    addlDescription?: string,
}): { type: 'boolean', description: string } {
    if (!baseSchema) { throw new Error(`(UNEXPECTED) baseSchema falsy? (E: 338a083d88ab9ae5286edc7d0c20c825)`); }
    const resSchema = clone(baseSchema);
    resSchema.description = `${resSchema.description ?? ''}\n${addlDescription}`;
    return resSchema;
}

/**
 * wraps the given {@link fn} inside of a {@link APIFunctionInfo} that can be
 * executed on the api command service.
 *
 * ## intent
 *
 * I want to be able to execute certain functions serially similar to a barrier
 * or critical section. This was the "easiest" way for me to do it, since each
 * command is executed serially on the commanding service. And I didn't want to
 * have to create APIFunctionInfo objects for things that will not be exposed to
 * agents proper.
 *
 * ## NOT for agents' use
 *
 * because this is anon function, there is NO schema generated. So this can't be
 * used with agents directly.
 */
export function commandifyAnonFn<TFunc extends (...args: any[]) => Promise<any> = (...args: any[]) => Promise<void>>({
    fn,
    nameOrId,
    cmdCategory,
}: {
    fn: TFunc,
    nameOrId?: string,
    cmdCategory?: string,
}): APIFunctionInfo<TFunc> {
    const lc = `[${commandifyAnonFn.name}]`;
    try {
        if (logalot) { console.log(`${lc} starting... (I: e302e6a0f13584968379c9149406f225)`); }

        const cmdName =
            (nameOrId ?? fn.name) + `_${pickRandom_Letters({ count: 8 })}`;
        cmdCategory ??= 'anon';
        const cmdModifiers = [cmdName];

        const fnViaCmd: any = async (opts: any) => {
            cmdCategory ??= 'anon';
            const commandService = getCommandService();
            const command: CommandDataBase<typeof cmdCategory, typeof cmdModifiers> = {
                cmd: cmdCategory,
                cmdModifiers,
                ...opts,
            };
            return new Promise<any>((resolve, reject) => {
                commandService.enqueueCommand({ command, resolve, reject, anonApiFn });
            });
        }

        const anonApiFn: APIFunctionInfo<TFunc> = {
            nameOrId: cmdName,
            cmd: cmdCategory,
            cmdModifiers: [cmdName],
            fnViaCmd,
            functionImpl: fn,
            schema: undefined,
            isAnon: true,
        }

        return anonApiFn;

    } catch (error) {
        console.error(`${lc} ${extractErrorMsg(error)}`);
        throw error;
    } finally {
        if (logalot) { console.log(`${lc} complete.`); }
    }
}