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

import { APIFunctionInfo } from "../api-types.mjs";
import { CommandDataBase, CommandService, EnqueuedCommand } from "./command-types.mjs";
import { getAllFunctionInfos } from "../api-index.mjs";

/**
 * @class CommandService_V1 - Implementation of the command service.
 * Implements the {@link CommandService} interface.
 */
export class CommandService_V1 implements CommandService {
    protected lc: string = `[${CommandService_V1.name}]`;
    private commandQueue: EnqueuedCommand<CommandDataBase<string, string[]>>[] = [];
    private isProcessing = false;

    // private anonFns: Map<string, APIFunctionInfo<any>> = new Map();

    constructor() { }

    // registerAnonFn({ apiFnInfo }: { apiFnInfo: APIFunctionInfo<any> }): void {
    //     const lc = `${this.lc}[${this.registerAnonFn.name}]`;
    //     if (this.anonFns.has(apiFnInfo.nameOrId)) {
    //         console.warn(`${lc} anonFn already registered? (W: c6721a63affe97f5514d54bbe780f625)`)
    //     }
    //     this.anonFns.set(apiFnInfo.nameOrId, apiFnInfo);
    // }

    enqueueCommand<TCommand extends CommandDataBase<string, string[]>>(enqueuedCommand: EnqueuedCommand<TCommand>): void {
        this.commandQueue.push(enqueuedCommand);
        if (!this.isProcessing) {
            this.startProcessing();
        }
    }

    private startProcessing(): void {
        this.isProcessing = true;
        this.processQueue().finally(() => {
            this.isProcessing = false;
            if (this.commandQueue.length > 0) {
                this.startProcessing(); // If more commands were added, process them
            }
        });
    }

    async processQueue(): Promise<void> {
        const lc = `${this.lc}[${this.processQueue.name}]`;
        while (this.commandQueue.length > 0) {
            const enqueuedCommand = this.commandQueue.shift();
            if (enqueuedCommand) {
                try {
                    const result =
                        await this.executeCommand(enqueuedCommand.command, enqueuedCommand.anonApiFn);
                    enqueuedCommand.resolve(result);
                } catch (error: any) {
                    console.error(`Error executing command ${enqueuedCommand.command.cmd} ${enqueuedCommand.command.cmdModifiers?.join(',') ?? ''}:`, error);
                    enqueuedCommand.reject(error);
                }
            }
        }
    }

    private async executeCommand(cmdData: CommandDataBase<string, string[]>, anonApiFn?: APIFunctionInfo<any>): Promise<any | void> {
        const lc = `[${CommandService_V1.name}.${this.executeCommand.name}]`;
        try {
            const functionInfo =
                anonApiFn ??
                Array.from(getAllFunctionInfos().entries())
                    .map(x => x[1] as APIFunctionInfo<any>)
                    .find((info) => {
                        return info.cmd === cmdData.cmd &&
                            info.cmdModifiers.every(modifier => !!cmdData.cmdModifiers?.includes(modifier));
                    });

            if (functionInfo) {
                console.log(`${lc} command executing. cmdData: ${pretty(cmdData)}`)
                // Type checking and argument passing will need refinement based on schema
                if (cmdData.notesToSelf) {
                    console.log(`${lc} Notes to self: ${cmdData.notesToSelf}.  (I: ebcc5471b2b309ba186281c134f77e25)`);
                }
                const args = this.getCommandArgs(cmdData, functionInfo);
                const result = await functionInfo.functionImpl(args);
                return result;
            } else {
                throw new Error(`${lc} Unknown command: ${cmdData.cmd} with modifiers ${cmdData.cmdModifiers?.join(', ')} (E: cc9cb829f118de05b762020213ef2825)`);
            }
        } catch (error) {
            debugger; // error in command svc exec
            const errorMsg = `${lc} ${extractErrorMsg(error)}`;
            console.error(errorMsg);
            return { errorMsg };
        }
    }

    /**
     * todo: change the structure so these explicit calls aren't necessary.
     * @param cmdData about the cmd to invoke
     * @param functionInfo full function info corresponding to cmd
     * @returns args that the cmd expects depending on incoming {@link cmdData}
     */
    private getCommandArgs(cmdData: CommandDataBase<string, string[]>, functionInfo: APIFunctionInfo): any {
        return cmdData as any;
        // // This will need to be refined based on the actual function signature and schema
        // if (functionInfo.nameOrId === 'renderableCreate') {
        //     // return { initialStates: (cmdData as RenderableCreateCommandData).initialStates, };
        //     return cmdData as RenderableCreateCommandData;
        // } else if (functionInfo.nameOrId === 'renderableUpdate') {
        //     // return { handle: (cmdData as RenderableUpdateCommandData).handle,
        //     // updatedState: (cmdData as RenderableUpdateCommandData).updatedState
        //     // };
        //     return cmdData as RenderableUpdateCommandData;
        // } else if (functionInfo.nameOrId === 'renderableDestroy') {
        //     return cmdData as RenderableDestroyCommandData;
        // } else if (functionInfo.nameOrId === 'tellUser') {
        //     return { text: (cmdData as TellUserCommandData).text };
        // } else {
        //     throw new Error(`(UNEXPECTED) unknown command? functionInfo.nameOrId: ${functionInfo.nameOrId}, cmdData: ${pretty(cmdData)} (E: 376725f2024d48c5056a9f8989616125)`);
        // }
    }

}

/**
 * @private
 */
let globalCommandService: CommandService | undefined;

/**
 * Gets the singleton instance of the CommandService.
 * @returns {CommandService} The CommandService instance.
 */
export function getCommandService(): CommandService {
    if (!globalCommandService) {
        globalCommandService = new CommandService_V1();
    }
    return globalCommandService;
}