import { EnvironmentId, type OrchestrationShellSnapshot } from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import { AsyncResult, Atom, type AtomRegistry } from "effect/unstable/reactivity";

export type ArchivedSnapshotEntry = {
  readonly environmentId: EnvironmentId;
  readonly snapshot: OrchestrationShellSnapshot;
};

export interface ArchivedThreadsClient {
  readonly getArchivedShellSnapshot: () => Promise<OrchestrationShellSnapshot>;
}

export interface ArchivedThreadsSnapshotState {
  readonly snapshots: ReadonlyArray<ArchivedSnapshotEntry>;
  readonly error: string | null;
  readonly isLoading: boolean;
}

const ARCHIVED_THREADS_ENVIRONMENT_KEY_SEPARATOR = "\u001f";
const DEFAULT_ARCHIVED_THREADS_STALE_TIME_MS = 5_000;
const DEFAULT_ARCHIVED_THREADS_IDLE_TTL_MS = 5 * 60_000;

export function makeArchivedThreadsEnvironmentKey(
  environmentIds: ReadonlyArray<EnvironmentId>,
): string {
  return environmentIds.toSorted().join(ARCHIVED_THREADS_ENVIRONMENT_KEY_SEPARATOR);
}

export function parseArchivedThreadsEnvironmentKey(key: string): ReadonlyArray<EnvironmentId> {
  if (key.length === 0) {
    return [];
  }
  return key
    .split(ARCHIVED_THREADS_ENVIRONMENT_KEY_SEPARATOR)
    .map((environmentId) => EnvironmentId.make(environmentId));
}

export function readArchivedThreadsSnapshotState(
  result: AsyncResult.AsyncResult<ReadonlyArray<ArchivedSnapshotEntry>, unknown>,
): ArchivedThreadsSnapshotState {
  const snapshots = Option.getOrElse(AsyncResult.value(result), () => []);
  let error: string | null = null;
  if (result._tag === "Failure") {
    const cause = Cause.squash(result.cause);
    error = cause instanceof Error ? cause.message : "Failed to load archived threads.";
  }

  return {
    snapshots,
    error,
    isLoading: result.waiting,
  };
}

export function createArchivedThreadsManager(config: {
  readonly getRegistry: () => AtomRegistry.AtomRegistry;
  readonly getClient: (environmentId: EnvironmentId) => ArchivedThreadsClient | null;
  readonly staleTimeMs?: number;
  readonly idleTtlMs?: number;
}) {
  const knownEnvironmentKeys = new Set<string>();
  const staleTime = config.staleTimeMs ?? DEFAULT_ARCHIVED_THREADS_STALE_TIME_MS;
  const idleTtl = config.idleTtlMs ?? DEFAULT_ARCHIVED_THREADS_IDLE_TTL_MS;

  const snapshotsAtom = Atom.family((environmentKey: string) => {
    knownEnvironmentKeys.add(environmentKey);
    return Atom.make(
      Effect.promise(async (): Promise<ReadonlyArray<ArchivedSnapshotEntry>> => {
        const snapshots = await Promise.all(
          parseArchivedThreadsEnvironmentKey(environmentKey).map(async (environmentId) => {
            const client = config.getClient(environmentId);
            if (!client) {
              return null;
            }
            return {
              environmentId,
              snapshot: await client.getArchivedShellSnapshot(),
            };
          }),
        );
        return snapshots.filter((snapshot) => snapshot !== null);
      }),
    ).pipe(
      Atom.swr({
        staleTime,
        revalidateOnMount: true,
      }),
      Atom.setIdleTTL(idleTtl),
      Atom.withLabel(`archived-thread-snapshots:${environmentKey}`),
    );
  });

  function getAtom(environmentKey: string) {
    return snapshotsAtom(environmentKey);
  }

  function refresh(environmentIds: ReadonlyArray<EnvironmentId>): void {
    config.getRegistry().refresh(getAtom(makeArchivedThreadsEnvironmentKey(environmentIds)));
  }

  function refreshForEnvironment(environmentId: EnvironmentId): void {
    for (const environmentKey of knownEnvironmentKeys) {
      if (parseArchivedThreadsEnvironmentKey(environmentKey).includes(environmentId)) {
        config.getRegistry().refresh(getAtom(environmentKey));
      }
    }
  }

  return {
    getAtom,
    refresh,
    refreshForEnvironment,
  };
}