import { useAtomValue } from "@effect/atom-react";
import type { EnvironmentId } from "@t3tools/contracts";
import { Atom } from "effect/unstable/reactivity";
import { useEffect, useRef } from "react";

import { prepareTurnAttachments } from "../lib/attachmentUpload";
import { isFileBackedComposerAttachment } from "../lib/composerImages";
import {
  composerAttachmentUploadKey,
  composerDraftEnvironmentId,
  canUploadComposerAttachment,
  createComposerAttachmentUploadQueue,
  type ComposerAttachmentUploadState,
} from "../lib/composerAttachmentUploadQueue";
import { appAtomRegistry } from "./atom-registry";
import { useServerConfigs } from "./entities";
import { flattenQueuedThreadMessages, threadOutboxManager } from "./thread-outbox";
import { useThreadOutboxMessages } from "./use-thread-outbox";
import {
  composerDraftsAtom,
  ensureComposerDraftsLoaded,
  flushComposerDrafts,
  retainComposerAttachmentFileForPreview,
  setComposerDraftAttachmentUpload,
} from "./use-composer-drafts";
import { useRemoteConnectionStatus } from "./use-remote-environment-registry";

export {
  composerAttachmentUploadBlockReason,
  composerAttachmentsStillUploading,
} from "../lib/composerAttachmentUploadQueue";

export const composerAttachmentUploadsAtom = Atom.make<
  Readonly<Record<string, ComposerAttachmentUploadState>>
>({}).pipe(Atom.keepAlive);
const uploadStateAtom = Atom.family((key: string) =>
  Atom.map(composerAttachmentUploadsAtom, (states) => states[key]),
);
let uploadQueue: ReturnType<typeof createComposerAttachmentUploadQueue> | null = null;

export function useComposerAttachmentUploadState(
  environmentId: EnvironmentId | undefined,
  attachmentId: string,
) {
  return useAtomValue(
    uploadStateAtom(environmentId ? composerAttachmentUploadKey(environmentId, attachmentId) : ""),
  );
}

export function retryComposerAttachmentUpload(environmentId: EnvironmentId, attachmentId: string) {
  uploadQueue?.retry(environmentId, attachmentId);
}

/** Runs outside mounted composers so a transfer can finish after navigation. */
export function useComposerAttachmentUploadWorker() {
  const drafts = useAtomValue(composerDraftsAtom);
  const queuedMessages = useThreadOutboxMessages();
  const serverConfigs = useServerConfigs();
  const { connectedEnvironments } = useRemoteConnectionStatus();
  const queueRef = useRef<ReturnType<typeof createComposerAttachmentUploadQueue> | null>(null);

  useEffect(() => {
    ensureComposerDraftsLoaded();
    const queue = createComposerAttachmentUploadQueue({
      onChange: (states) => appAtomRegistry.set(composerAttachmentUploadsAtom, states),
      upload: async ({ environmentId, attachment }, signal, onProgress) => {
        const release = isFileBackedComposerAttachment(attachment)
          ? retainComposerAttachmentFileForPreview(attachment)
          : undefined;
        try {
          const result = await prepareTurnAttachments({
            environmentId,
            attachments: [attachment],
            supportsImageUploads: true,
            signal,
            onUploadProgress: (_, progress) => onProgress(progress),
            persistUploadedReferences: async ([uploaded]) => {
              if (signal.aborted || !uploaded) return "abandon";
              const queued = flattenQueuedThreadMessages(
                appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom),
              );
              let retained = false;
              for (const [key, draft] of Object.entries(appAtomRegistry.get(composerDraftsAtom))) {
                if (
                  composerDraftEnvironmentId(key, queued, draft) === environmentId &&
                  draft.attachments.some((candidate) => candidate.id === attachment.id)
                ) {
                  retained = setComposerDraftAttachmentUpload(key, uploaded) || retained;
                }
              }
              if (!retained) return "abandon";
              await flushComposerDrafts();
              return "persisted";
            },
          });
          return result.status === "ready";
        } finally {
          release?.();
        }
      },
    });
    queueRef.current = queue;
    uploadQueue = queue;
    return () => {
      queue.dispose();
      if (uploadQueue === queue) uploadQueue = null;
      queueRef.current = null;
    };
  }, []);

  useEffect(() => {
    const queued = flattenQueuedThreadMessages(queuedMessages);
    const connected = new Set(
      connectedEnvironments
        .filter((environment) => environment.connectionState === "connected")
        .map((environment) => environment.environmentId),
    );
    const requests = Object.entries(drafts).flatMap(([key, draft]) => {
      const environmentId = composerDraftEnvironmentId(key, queued, draft);
      if (environmentId === null || !connected.has(environmentId)) return [];
      return draft.attachments
        .filter((attachment) =>
          canUploadComposerAttachment(attachment, serverConfigs.get(environmentId)),
        )
        .map((attachment) => ({ environmentId, attachment }));
    });
    queueRef.current?.sync(requests);
  }, [connectedEnvironments, drafts, queuedMessages, serverConfigs]);
}