import type { FileSystemProvider } from '../filesystem/types';
import type { OpenDocRequest } from '../workspaces/workspace';
import type { DocumentHandle } from './types';

export type DocumentOpenCallbacks = {
  onLoading: () => void;
  onOpen: (handle: DocumentHandle, request: OpenDocRequest) => void;
  onError: (message: string, request: OpenDocRequest) => void;
  /** Remove and return the previous handle; released in `finally` after open settles. */
  takePreviousHandle: () => DocumentHandle | null;
  /** After open, return true if this handle is no longer the active one. */
  isStaleHandle?: (handle: DocumentHandle) => boolean;
};

/**
 * Starts opening a document; returns a cancel function for effect cleanup.
 */
export function startDocumentOpen(
  request: OpenDocRequest,
  resolveProvider: (providerId: string) => FileSystemProvider | undefined,
  callbacks: DocumentOpenCallbacks,
): () => void {
  const fs = resolveProvider(request.providerId);
  if (!fs) return () => undefined;

  callbacks.onLoading();
  const prevHandle = callbacks.takePreviousHandle();

  let cancelled = false;
  fs.documents
    .openDocument(request.entryId)
    .then((handle) => {
      if (cancelled) {
        handle.release();
        return;
      }
      callbacks.onOpen(handle, request);
      handle.loadPromise.catch((err: unknown) => {
        if (cancelled || callbacks.isStaleHandle?.(handle)) return;
        const message = err instanceof Error ? err.message : 'Unknown error';
        handle.release();
        callbacks.onError(message, request);
      });
    })
    .catch((err: unknown) => {
      if (cancelled) return;
      const message = err instanceof Error ? err.message : 'Unknown error';
      callbacks.onError(message, request);
    })
    .finally(() => {
      prevHandle?.release();
    });

  return () => {
    cancelled = true;
  };
}