import type { ChatTransport, UIMessage, UIMessageChunk } from "ai";
import { getUuid } from "../api/client";
import { generateMessageUuid } from "./utils";
import type { SessionEvent, EventPayload } from "../types";

// ============================================================
// SSE Event Bus — shared between SSE listener and transport
// ============================================================

type SSEEventHandler = (event: SessionEvent) => void;

class SSEEventBus {
  private listeners: Set<SSEEventHandler> = new Set();
  private eventSource: EventSource | null = null;
  private _lastSeqNum = 0;

  get lastSeqNum() {
    return this._lastSeqNum;
  }

  /** Register a listener for SSE events */
  onEvent(handler: SSEEventHandler): () => void {
    this.listeners.add(handler);
    return () => this.listeners.delete(handler);
  }

  /** Connect to the SSE stream for a session */
  connect(sessionId: string): void {
    this.disconnect();
    const uuid = getUuid();
    const url = `/web/sessions/${sessionId}/events?uuid=${encodeURIComponent(uuid)}`;
    const es = new EventSource(url);
    this.eventSource = es;

    es.addEventListener("message", (e: MessageEvent) => {
      try {
        const data = JSON.parse(e.data) as SessionEvent;
        if (data.seqNum !== undefined && data.seqNum <= this._lastSeqNum) return;
        if (data.seqNum !== undefined) this._lastSeqNum = data.seqNum;
        for (const handler of this.listeners) {
          handler(data);
        }
      } catch {
        // ignore parse errors
      }
    });
  }

  /** Disconnect the SSE stream */
  disconnect(): void {
    if (this.eventSource) {
      this.eventSource.close();
      this.eventSource = null;
    }
    this._lastSeqNum = 0;
  }
}

// Singleton event bus
export const sseBus = new SSEEventBus();

// ============================================================
// RCS ChatTransport — bridges RCS SSE to AI SDK UIMessageChunk
// ============================================================

interface RCSTransportOptions {
  sessionId: string;
  onPermissionRequest?: (event: SessionEvent) => void;
  onSessionStatus?: (status: string) => void;
  onError?: (error: string) => void;
}

export class RCSTransport implements ChatTransport<UIMessage> {
  private sessionId: string;
  private onPermissionRequest?: (event: SessionEvent) => void;
  private onSessionStatus?: (status: string) => void;
  private onError?: (error: string) => void;
  private unsub: (() => void) | null = null;

  constructor(options: RCSTransportOptions) {
    this.sessionId = options.sessionId;
    this.onPermissionRequest = options.onPermissionRequest;
    this.onSessionStatus = options.onSessionStatus;
    this.onError = options.onError;
  }

  async sendMessages({
    messages,
    abortSignal,
  }: Parameters<ChatTransport<UIMessage>["sendMessages"]>[0]): Promise<ReadableStream<UIMessageChunk>> {
    const lastMessage = messages[messages.length - 1];
    if (!lastMessage || lastMessage.role !== "user") {
      // Return empty stream if no user message
      return new ReadableStream({ start: (c) => c.close() });
    }

    // Extract text from the user message parts
    const text = lastMessage.parts
      .filter((p: UIMessage["parts"][number]): p is Extract<typeof p, { type: "text" }> => p.type === "text")
      .map((p: { text: string }) => p.text)
      .join("");

    if (!text.trim()) {
      return new ReadableStream({ start: (c) => c.close() });
    }

    // POST user message to the RCS backend
    const uuid = getUuid();
    const response = await fetch(
      `/web/sessions/${this.sessionId}/events?uuid=${encodeURIComponent(uuid)}`,
      {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          type: "user",
          uuid: generateMessageUuid(),
          content: text,
          message: { content: text },
        }),
        signal: abortSignal,
      },
    );

    if (!response.ok) {
      const data = await response.json().catch(() => ({ error: { message: response.statusText } }));
      throw new Error(data.error?.message || "Failed to send message");
    }

    // Create a ReadableStream from the SSE event bus
    // Collects events until the assistant turn is complete
    return new ReadableStream<UIMessageChunk>({
      start: (controller) => {
        let textId = `text-${Date.now()}`;
        let started = false;

        const ensureStarted = () => {
          if (!started) {
            started = true;
            controller.enqueue({ type: "start", messageId: `msg-${Date.now()}` });
          }
        };

        const handler = (event: SessionEvent) => {
          const type = event.type;
          const payload = event.payload || ({} as EventPayload);

          // Skip bridge init noise
          const serialized = JSON.stringify(event);
          if (/Remote Control connecting/i.test(serialized)) return;

          switch (type) {
            // ---- Assistant text ----
            case "assistant": {
              const content =
                typeof payload.content === "string"
                  ? payload.content
                  : "";
              if (content && content.trim()) {
                ensureStarted();
                controller.enqueue({ type: "text-start", id: textId });
                controller.enqueue({ type: "text-delta", id: textId, delta: content });
                controller.enqueue({ type: "text-end", id: textId });
              }

              // Check for embedded tool_use blocks
              const msg = payload.message as Record<string, unknown> | undefined;
              if (msg && typeof msg === "object" && Array.isArray(msg.content)) {
                const toolBlocks = (msg.content as Array<Record<string, unknown>>).filter(
                  (b) => b.type === "tool_use",
                );
                for (const block of toolBlocks) {
                  ensureStarted();
                  const toolCallId = (block.id as string) || `call-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
                  controller.enqueue({
                    type: "tool-input-available",
                    toolCallId,
                    toolName: (block.name as string) || "tool",
                    input: block.input || {},
                  });
                }
              }

              // Finish after assistant message
              ensureStarted();
              controller.enqueue({ type: "finish", finishReason: "stop" });
              controller.close();
              cleanup();
              break;
            }

            // ---- Tool use events ----
            case "tool_use": {
              ensureStarted();
              const toolCallId =
                (payload as Record<string, unknown>).tool_call_id as string ||
                `call-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
              controller.enqueue({
                type: "tool-input-available",
                toolCallId,
                toolName: (payload as Record<string, unknown>).tool_name as string || "tool",
                input: (payload as Record<string, unknown>).tool_input || {},
              });
              break;
            }

            // ---- Tool result events ----
            case "tool_result": {
              ensureStarted();
              const resultCallId =
                (payload as Record<string, unknown>).tool_call_id as string ||
                `call-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
              const output =
                typeof (payload as Record<string, unknown>).output === "string"
                  ? (payload as Record<string, unknown>).output
                  : (payload as Record<string, unknown>).content || "";
              controller.enqueue({
                type: "tool-output-available",
                toolCallId: resultCallId,
                output: output as string,
              });
              break;
            }

            // ---- Permission / control requests ----
            case "control_request":
            case "permission_request": {
              const req = payload.request as Record<string, unknown> | undefined;
              if (req && req.subtype === "can_use_tool") {
                // Forward to the UI layer for handling
                this.onPermissionRequest?.(event);
              }
              // Don't close the stream — wait for the response
              break;
            }

            // ---- Status events ----
            case "status": {
              const msg =
                (typeof payload.message === "string" ? payload.message : "") ||
                payload.content ||
                "";
              if (/connecting|waiting|initializing|Remote Control/i.test(msg)) return;
              break;
            }

            // ---- Session status ----
            case "session_status": {
              if (typeof payload.status === "string") {
                this.onSessionStatus?.(payload.status);
                if (
                  payload.status === "archived" ||
                  payload.status === "inactive"
                ) {
                  ensureStarted();
                  controller.enqueue({ type: "finish", finishReason: "stop" });
                  controller.close();
                  cleanup();
                }
              }
              break;
            }

            // ---- Errors ----
            case "error": {
              ensureStarted();
              controller.enqueue({
                type: "error",
                errorText: String(payload.message || payload.content || "Unknown error"),
              });
              controller.enqueue({ type: "finish", finishReason: "error" });
              controller.close();
              cleanup();
              break;
            }

            // ---- Interrupt ----
            case "interrupt": {
              ensureStarted();
              controller.enqueue({ type: "abort", reason: "Session interrupted" });
              controller.close();
              cleanup();
              break;
            }

            // ---- Skip noise ----
            case "partial_assistant":
            case "result":
            case "result_success":
            case "control_response":
            case "permission_response":
            case "system":
            case "task_state":
            case "automation_state":
              return;

            default:
              return;
          }
        };

        const cleanup = () => {
          if (this.unsub) {
            this.unsub();
            this.unsub = null;
          }
        };

        this.unsub = sseBus.onEvent(handler);

        // Handle abort
        if (abortSignal) {
          const onAbort = () => {
            controller.enqueue({ type: "abort", reason: "Aborted" });
            controller.close();
            cleanup();
            abortSignal.removeEventListener("abort", onAbort);
          };
          abortSignal.addEventListener("abort", onAbort);
        }
      },
    });
  }

  /** Not supported — RCS doesn't have stream resumption */
  reconnectToStream(): Promise<ReadableStream<UIMessageChunk> | null> {
    return Promise.resolve(null);
  }

  /** Clean up listeners */
  destroy(): void {
    if (this.unsub) {
      this.unsub();
      this.unsub = null;
    }
  }
}