import type { InMemoryEventBus } from "./eventBus";
import { createEvent } from "./events";
import type { YouTubeAdapterHandle } from "../platform/youtube";

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

type GetAdapter = (streamId: string) => YouTubeAdapterHandle | null;

async function emitResult(
    eventBus: InMemoryEventBus,
    streamId: string,
    event: string,
    data: Record<string, unknown>
): Promise<void> {
    await eventBus.emit(
        createEvent("ws_out", {
            streamId,
            target: "admin",
            event,
            data
        })
    );
}

export function attachYouTubeAdminController(
    eventBus: InMemoryEventBus,
    getAdapter: GetAdapter,
    log: ControllerLog
): () => void {
    return eventBus.on(
        "admin_command",
        async (event) => {
            if (event.payload.command.trim().toLowerCase() !== "youtube") {
                return;
            }
            const streamId = event.payload.streamId;
            const adapter = getAdapter(streamId);
            if (!adapter) {
                log("youtube_adapter_not_active_for_stream", { streamId });
                await emitResult(eventBus, streamId, "youtube_ops_error", {
                    message: "YouTube adapter is not active for this stream."
                });
                return;
            }

            const operation = event.payload.args[0]?.toLowerCase() ?? "status";
            if (operation === "status" || operation === "refresh" || operation === "refresh-status") {
                await emitResult(eventBus, streamId, "youtube_ops_status", adapter.status());
                return;
            }

            if (operation === "arm" || operation === "arm-discovery") {
                adapter.armDiscovery();
                await emitResult(eventBus, streamId, "youtube_ops_result", {
                    ok: true,
                    operation: "arm",
                    status: adapter.status()
                });
                log("youtube_discovery_armed", { streamId });
                return;
            }

            if (operation === "pause" || operation === "pause-discovery") {
                adapter.pauseDiscovery();
                await emitResult(eventBus, streamId, "youtube_ops_result", {
                    ok: true,
                    operation: "pause",
                    status: adapter.status()
                });
                log("youtube_discovery_paused", { streamId });
                return;
            }

            if (operation === "set-video") {
                const videoInput = event.payload.args[1]?.trim() ?? "";
                if (!videoInput) {
                    await emitResult(eventBus, streamId, "youtube_ops_error", {
                        message: "Usage: youtube set-video <videoId-or-url>"
                    });
                    return;
                }

                const result = await adapter.setVideo(videoInput);
                if (!result.found) {
                    await emitResult(eventBus, streamId, "youtube_ops_error", {
                        message: "Could not resolve activeLiveChatId from provided video."
                    });
                    return;
                }
                await emitResult(eventBus, streamId, "youtube_ops_result", {
                    ok: true,
                    operation,
                    liveChatId: result.liveChatId,
                    status: adapter.status()
                });
                return;
            }

            await emitResult(eventBus, streamId, "youtube_ops_error", {
                message:
                    "Usage: youtube status | youtube arm | youtube pause | youtube set-video <id-or-url>"
            });
        },
        {
            componentId: "youtube-admin-controller",
            componentKind: "core"
        }
    );
}