import { useAtomValue } from "@effect/atom-react";
import { useCallback, useEffect, useMemo } from "react";

import { EnvironmentScopedThreadShell } from "@t3tools/client-runtime";
import { CommandId, MessageId, type EnvironmentId, type ThreadId } from "@t3tools/contracts";
import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
import { Atom } from "effect/unstable/reactivity";

import { makeQueuedMessageMetadata } from "../lib/commandMetadata";
import {
  convertPastedImagesToAttachments,
  pasteComposerClipboard,
  pickComposerImages,
} from "../lib/composerImages";
import type { DraftComposerImageAttachment } from "../lib/composerImages";
import { scopedThreadKey } from "../lib/scopedEntities";
import { buildThreadFeed, type QueuedThreadMessage } from "../lib/threadActivity";
import { appAtomRegistry } from "../state/atom-registry";
import { getEnvironmentClient } from "./environment-session-registry";
import type { ConnectedEnvironmentSummary } from "../state/remote-runtime-types";
import {
  setPendingConnectionError,
  useRemoteConnectionStatus,
} from "../state/use-remote-environment-registry";
import { useRemoteCatalog } from "../state/use-remote-catalog";
import { useSelectedThreadDetail } from "../state/use-thread-detail";
import { useThreadSelection } from "../state/use-thread-selection";

const draftMessageByThreadKeyAtom = Atom.make<Record<string, string>>({}).pipe(
  Atom.keepAlive,
  Atom.withLabel("mobile:thread-composer:draft-message"),
);

const draftAttachmentsByThreadKeyAtom = Atom.make<
  Record<string, ReadonlyArray<DraftComposerImageAttachment>>
>({}).pipe(Atom.keepAlive, Atom.withLabel("mobile:thread-composer:draft-attachments"));

const dispatchingQueuedMessageIdAtom = Atom.make<MessageId | null>(null).pipe(
  Atom.keepAlive,
  Atom.withLabel("mobile:thread-composer:dispatching-message-id"),
);

const queuedMessagesByThreadKeyAtom = Atom.make<Record<string, ReadonlyArray<QueuedThreadMessage>>>(
  {},
).pipe(Atom.keepAlive, Atom.withLabel("mobile:thread-composer:queued-messages"));

function setDraftMessage(threadKey: string, value: string): void {
  const current = appAtomRegistry.get(draftMessageByThreadKeyAtom);
  appAtomRegistry.set(draftMessageByThreadKeyAtom, {
    ...current,
    [threadKey]: value,
  });
}

function appendDraftAttachments(
  threadKey: string,
  attachments: ReadonlyArray<DraftComposerImageAttachment>,
): void {
  const current = appAtomRegistry.get(draftAttachmentsByThreadKeyAtom);
  appAtomRegistry.set(draftAttachmentsByThreadKeyAtom, {
    ...current,
    [threadKey]: [...(current[threadKey] ?? []), ...attachments],
  });
}

function appendDraftMessage(threadKey: string, value: string): void {
  const current = appAtomRegistry.get(draftMessageByThreadKeyAtom);
  appAtomRegistry.set(draftMessageByThreadKeyAtom, {
    ...current,
    [threadKey]: `${current[threadKey] ?? ""}${value}`,
  });
}

export function appendReviewCommentToDraft(input: {
  readonly environmentId: EnvironmentId;
  readonly threadId: ThreadId;
  readonly text: string;
  readonly attachments?: ReadonlyArray<DraftComposerImageAttachment>;
}): void {
  const threadKey = scopedThreadKey(input.environmentId, input.threadId);
  const current = appAtomRegistry.get(draftMessageByThreadKeyAtom);
  const existing = current[threadKey] ?? "";
  const separator = existing.trim().length > 0 && !existing.endsWith("\n") ? "\n\n" : "";
  appAtomRegistry.set(draftMessageByThreadKeyAtom, {
    ...current,
    [threadKey]: `${existing}${separator}${input.text}`,
  });
  if (input.attachments && input.attachments.length > 0) {
    appendDraftAttachments(threadKey, input.attachments);
  }
}

export function useThreadDraftForThread(input: {
  readonly environmentId?: EnvironmentId;
  readonly threadId?: ThreadId;
}) {
  const draftMessageByThreadKey = useAtomValue(draftMessageByThreadKeyAtom);
  const draftAttachmentsByThreadKey = useAtomValue(draftAttachmentsByThreadKeyAtom);
  const threadKey =
    input.environmentId && input.threadId
      ? scopedThreadKey(input.environmentId, input.threadId)
      : null;

  return {
    draftMessage: threadKey ? (draftMessageByThreadKey[threadKey] ?? "") : "",
    draftAttachments: threadKey ? (draftAttachmentsByThreadKey[threadKey] ?? []) : [],
  };
}

function clearDraft(threadKey: string): void {
  const draftMessages = appAtomRegistry.get(draftMessageByThreadKeyAtom);
  const draftAttachments = appAtomRegistry.get(draftAttachmentsByThreadKeyAtom);
  appAtomRegistry.set(draftMessageByThreadKeyAtom, {
    ...draftMessages,
    [threadKey]: "",
  });
  appAtomRegistry.set(draftAttachmentsByThreadKeyAtom, {
    ...draftAttachments,
    [threadKey]: [],
  });
}

function removeDraftImage(threadKey: string, imageId: string): void {
  const current = appAtomRegistry.get(draftAttachmentsByThreadKeyAtom);
  appAtomRegistry.set(draftAttachmentsByThreadKeyAtom, {
    ...current,
    [threadKey]: (current[threadKey] ?? []).filter((image) => image.id !== imageId),
  });
}

function beginDispatchingQueuedMessage(queuedMessageId: MessageId): void {
  appAtomRegistry.set(dispatchingQueuedMessageIdAtom, queuedMessageId);
}

function finishDispatchingQueuedMessage(queuedMessageId: MessageId): void {
  const current = appAtomRegistry.get(dispatchingQueuedMessageIdAtom);
  appAtomRegistry.set(dispatchingQueuedMessageIdAtom, current === queuedMessageId ? null : current);
}

function enqueueQueuedMessage(message: QueuedThreadMessage): void {
  const current = appAtomRegistry.get(queuedMessagesByThreadKeyAtom);
  const threadKey = scopedThreadKey(message.environmentId, message.threadId);
  appAtomRegistry.set(queuedMessagesByThreadKeyAtom, {
    ...current,
    [threadKey]: [...(current[threadKey] ?? []), message],
  });
}

function removeQueuedMessage(
  environmentId: EnvironmentId,
  threadId: ThreadId,
  queuedMessageId: MessageId,
): void {
  const current = appAtomRegistry.get(queuedMessagesByThreadKeyAtom);
  const threadKey = scopedThreadKey(environmentId, threadId);
  const existing = current[threadKey];
  if (!existing) {
    return;
  }

  const nextQueue = existing.filter((entry) => entry.messageId !== queuedMessageId);
  const next = { ...current };
  if (nextQueue.length === 0) {
    delete next[threadKey];
  } else {
    next[threadKey] = nextQueue;
  }

  appAtomRegistry.set(queuedMessagesByThreadKeyAtom, next);
}

function useQueueDrain(input: {
  readonly dispatchingQueuedMessageId: MessageId | null;
  readonly queuedMessagesByThreadKey: Record<string, ReadonlyArray<QueuedThreadMessage>>;
  readonly threads: ReadonlyArray<EnvironmentScopedThreadShell>;
  readonly environments: ReadonlyArray<ConnectedEnvironmentSummary>;
  readonly sendQueuedMessage: (message: QueuedThreadMessage) => Promise<void>;
}) {
  const {
    dispatchingQueuedMessageId,
    environments,
    queuedMessagesByThreadKey,
    sendQueuedMessage,
    threads,
  } = input;

  useEffect(() => {
    if (dispatchingQueuedMessageId !== null) {
      return;
    }

    for (const [threadKey, queuedMessages] of Object.entries(queuedMessagesByThreadKey)) {
      const nextQueuedMessage = queuedMessages[0];
      if (!nextQueuedMessage) {
        continue;
      }

      const thread = threads.find(
        (candidate) => scopedThreadKey(candidate.environmentId, candidate.id) === threadKey,
      );
      if (!thread) {
        continue;
      }

      const environment = environments.find(
        (candidate) => candidate.environmentId === nextQueuedMessage.environmentId,
      );
      if (!environment || environment.connectionState !== "ready") {
        continue;
      }

      const threadStatus = thread.session?.status;
      if (threadStatus === "running" || threadStatus === "starting") {
        continue;
      }

      void sendQueuedMessage(nextQueuedMessage);
      return;
    }
  }, [
    dispatchingQueuedMessageId,
    environments,
    queuedMessagesByThreadKey,
    sendQueuedMessage,
    threads,
  ]);
}

export function useThreadComposerState() {
  const { connectedEnvironments } = useRemoteConnectionStatus();
  const { threads } = useRemoteCatalog();
  const { selectedThread: selectedThreadShell } = useThreadSelection();
  const selectedThread = useSelectedThreadDetail();
  const draftMessageByThreadKey = useAtomValue(draftMessageByThreadKeyAtom);
  const draftAttachmentsByThreadKey = useAtomValue(draftAttachmentsByThreadKeyAtom);
  const dispatchingQueuedMessageId = useAtomValue(dispatchingQueuedMessageIdAtom);
  const queuedMessagesByThreadKey = useAtomValue(queuedMessagesByThreadKeyAtom);

  const selectedThreadKey = selectedThreadShell
    ? scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id)
    : null;
  const selectedThreadQueuedMessages = useMemo(
    () => (selectedThreadKey ? (queuedMessagesByThreadKey[selectedThreadKey] ?? []) : []),
    [queuedMessagesByThreadKey, selectedThreadKey],
  );

  const selectedThreadFeed = useMemo(
    () =>
      selectedThread
        ? buildThreadFeed(selectedThread, selectedThreadQueuedMessages, dispatchingQueuedMessageId)
        : [],
    [dispatchingQueuedMessageId, selectedThread, selectedThreadQueuedMessages],
  );

  const draftMessage = selectedThreadKey ? (draftMessageByThreadKey[selectedThreadKey] ?? "") : "";
  const draftAttachments = selectedThreadKey
    ? (draftAttachmentsByThreadKey[selectedThreadKey] ?? [])
    : [];
  const selectedThreadQueueCount = selectedThreadQueuedMessages.length;

  const selectedThreadSessionActivity = useMemo(() => {
    if (!selectedThread?.session) {
      return null;
    }

    return {
      orchestrationStatus: selectedThread.session.status,
      activeTurnId: selectedThread.session.activeTurnId ?? undefined,
    };
  }, [selectedThread]);

  const queuedSendStartedAt = selectedThreadQueuedMessages[0]?.createdAt ?? null;
  const activeWorkStartedAt = useMemo(() => {
    if (!selectedThread) {
      return null;
    }

    return deriveActiveWorkStartedAt(
      selectedThread.latestTurn,
      selectedThreadSessionActivity,
      queuedSendStartedAt,
    );
  }, [queuedSendStartedAt, selectedThread, selectedThreadSessionActivity]);

  const activeThreadBusy =
    !!selectedThread &&
    (selectedThread.session?.status === "running" || selectedThread.session?.status === "starting");

  const sendQueuedMessage = useCallback(
    async (queuedMessage: QueuedThreadMessage) => {
      const client = getEnvironmentClient(queuedMessage.environmentId);
      const thread = threads.find(
        (candidate) =>
          candidate.environmentId === queuedMessage.environmentId &&
          candidate.id === queuedMessage.threadId,
      );
      if (!client || !thread) {
        return;
      }

      beginDispatchingQueuedMessage(queuedMessage.messageId);
      try {
        await client.orchestration.dispatchCommand({
          type: "thread.turn.start",
          commandId: queuedMessage.commandId,
          threadId: queuedMessage.threadId,
          message: {
            messageId: queuedMessage.messageId,
            role: "user",
            text: queuedMessage.text,
            attachments: queuedMessage.attachments,
          },
          runtimeMode: thread.runtimeMode,
          interactionMode: thread.interactionMode,
          createdAt: queuedMessage.createdAt,
        });

        removeQueuedMessage(
          queuedMessage.environmentId,
          queuedMessage.threadId,
          queuedMessage.messageId,
        );
      } catch (error) {
        removeQueuedMessage(
          queuedMessage.environmentId,
          queuedMessage.threadId,
          queuedMessage.messageId,
        );
        setPendingConnectionError(
          error instanceof Error ? error.message : "Failed to send message.",
        );
      } finally {
        finishDispatchingQueuedMessage(queuedMessage.messageId);
      }
    },
    [threads],
  );

  useQueueDrain({
    dispatchingQueuedMessageId,
    queuedMessagesByThreadKey,
    threads,
    environments: connectedEnvironments,
    sendQueuedMessage,
  });

  const onSendMessage = useCallback(() => {
    if (!selectedThreadShell) {
      return;
    }

    const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
    const text = (draftMessageByThreadKey[threadKey] ?? "").trim();
    const attachments = draftAttachmentsByThreadKey[threadKey] ?? [];
    if (text.length === 0 && attachments.length === 0) {
      return;
    }

    const metadata = makeQueuedMessageMetadata();
    enqueueQueuedMessage({
      environmentId: selectedThreadShell.environmentId,
      threadId: selectedThreadShell.id,
      messageId: MessageId.make(metadata.messageId),
      commandId: CommandId.make(metadata.commandId),
      text,
      attachments,
      createdAt: metadata.createdAt,
    });
    clearDraft(threadKey);
  }, [draftAttachmentsByThreadKey, draftMessageByThreadKey, selectedThreadShell]);

  const onChangeDraftMessage = useCallback(
    (value: string) => {
      if (!selectedThreadShell) {
        return;
      }

      const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
      setDraftMessage(threadKey, value);
    },
    [selectedThreadShell],
  );

  const onPickDraftImages = useCallback(async () => {
    if (!selectedThreadShell) {
      return;
    }

    const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
    const result = await pickComposerImages({
      existingCount: draftAttachmentsByThreadKey[threadKey]?.length ?? 0,
    });
    if (result.images.length > 0) {
      appendDraftAttachments(threadKey, result.images);
    }
    if (result.error) {
      setPendingConnectionError(result.error);
    }
  }, [draftAttachmentsByThreadKey, selectedThreadShell]);

  const onPasteIntoDraft = useCallback(async () => {
    if (!selectedThreadShell) {
      return;
    }

    const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
    const result = await pasteComposerClipboard({
      existingCount: draftAttachmentsByThreadKey[threadKey]?.length ?? 0,
    });
    if (result.images.length > 0) {
      appendDraftAttachments(threadKey, result.images);
    }
    if (result.text) {
      appendDraftMessage(threadKey, result.text);
    }
    if (result.error) {
      setPendingConnectionError(result.error);
    }
  }, [draftAttachmentsByThreadKey, selectedThreadShell]);

  const onNativePasteImages = useCallback(
    async (uris: ReadonlyArray<string>) => {
      if (!selectedThreadShell || uris.length === 0) {
        return;
      }

      const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
      try {
        const images = await convertPastedImagesToAttachments({
          uris,
          existingCount: draftAttachmentsByThreadKey[threadKey]?.length ?? 0,
        });
        if (images.length > 0) {
          appendDraftAttachments(threadKey, images);
        }
      } catch (error) {
        console.error("[native paste] error converting images", error);
      }
    },
    [draftAttachmentsByThreadKey, selectedThreadShell],
  );

  const onRemoveDraftImage = useCallback(
    (imageId: string) => {
      if (!selectedThreadShell) {
        return;
      }

      const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
      removeDraftImage(threadKey, imageId);
    },
    [selectedThreadShell],
  );

  return {
    selectedThreadFeed,
    selectedThreadQueueCount,
    activeWorkStartedAt,
    draftMessage,
    draftAttachments,
    activeThreadBusy,
    onChangeDraftMessage,
    onPickDraftImages,
    onPasteIntoDraft,
    onNativePasteImages,
    onRemoveDraftImage,
    onSendMessage,
  };
}