import type { QuickActionRegistry } from "../extensions/quickActions";
import type { InMemoryEventBus } from "./eventBus";
import { createEvent } from "./events";

type ControllerLog = (message: string, fields?: Record<string, unknown>) => void;

async function emitActionsManifest(
    eventBus: InMemoryEventBus,
    streamId: string,
    quickActions: QuickActionRegistry
): Promise<void> {
    await eventBus.emit(
        createEvent("ws_out", {
            streamId,
            target: "admin",
            event: "quick_actions_manifest",
            data: {
                actions: quickActions.list()
            }
        })
    );
}

export function attachQuickActionController(
    eventBus: InMemoryEventBus,
    quickActions: QuickActionRegistry,
    log: ControllerLog
): () => void {
    return eventBus.on(
        "admin_command",
        async (event) => {
            if (event.payload.command !== "action") {
                return;
            }

            const operation = event.payload.args[0]?.toLowerCase() ?? "list";
            if (operation === "list") {
                await emitActionsManifest(eventBus, event.payload.streamId, quickActions);
                return;
            }

            if (operation === "run") {
                const actionId = event.payload.args[1]?.trim().toLowerCase() ?? "";
                const actionArgs = event.payload.args.slice(2);
                if (!actionId) {
                    await eventBus.emit(
                        createEvent("ws_out", {
                            streamId: event.payload.streamId,
                            target: "admin",
                            event: "quick_actions_error",
                            data: {
                                message: "Usage: action run <id> [args...]"
                            }
                        })
                    );
                    return;
                }

                if (!quickActions.has(actionId)) {
                    await eventBus.emit(
                        createEvent("ws_out", {
                            streamId: event.payload.streamId,
                            target: "admin",
                            event: "quick_actions_error",
                            data: {
                                message: `Unknown action: ${actionId}`
                            }
                        })
                    );
                    return;
                }

                try {
                    await quickActions.run(actionId, {
                        streamId: event.payload.streamId,
                        tokenId: event.payload.tokenId,
                        sessionId: event.payload.sessionId,
                        args: actionArgs
                    });
                    log("quick_action_invoked", {
                        actionId,
                        streamId: event.payload.streamId,
                        sessionId: event.payload.sessionId
                    });
                    await eventBus.emit(
                        createEvent("ws_out", {
                            streamId: event.payload.streamId,
                            target: "admin",
                            event: "quick_actions_result",
                            data: {
                                ok: true,
                                actionId
                            }
                        })
                    );
                } catch (error) {
                    await eventBus.emit(
                        createEvent("ws_out", {
                            streamId: event.payload.streamId,
                            target: "admin",
                            event: "quick_actions_error",
                            data: {
                                message:
                                    error instanceof Error
                                        ? error.message
                                        : `Action failed: ${actionId}`
                            }
                        })
                    );
                }
                return;
            }

            await eventBus.emit(
                createEvent("ws_out", {
                    streamId: event.payload.streamId,
                    target: "admin",
                    event: "quick_actions_error",
                    data: {
                        message: "Usage: action list | action run <id> [args...]"
                    }
                })
            );
        },
        {
            componentId: "quick-action-controller",
            componentKind: "core"
        }
    );
}