import * as Arr from "effect/Array";
import * as Order from "effect/Order";
import { useAtomValue } from "@effect/atom-react";
import { Atom } from "effect/unstable/reactivity";
import {
  EMPTY_SHELL_SNAPSHOT_ATOM,
  EMPTY_SHELL_SNAPSHOT_STATE,
  createShellSnapshotManager,
  getShellSnapshotTargetKey,
  shellSnapshotStateAtom,
  type ShellSnapshotState,
} from "@t3tools/client-runtime";
import type { EnvironmentId } from "@t3tools/contracts";
import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";

import { appAtomRegistry } from "./atom-registry";
import type { CachedShellSnapshot } from "../lib/storage";

const cachedShellSnapshotMetadataAtom = Atom.make<
  Readonly<Record<EnvironmentId, { readonly snapshotReceivedAt: string }>>
>({}).pipe(Atom.keepAlive, Atom.withLabel("mobile:cached-shell-snapshot-metadata"));

export const shellSnapshotManager = createShellSnapshotManager({
  getRegistry: () => appAtomRegistry,
});

export function hydrateCachedShellSnapshot(cached: CachedShellSnapshot): void {
  shellSnapshotManager.syncSnapshot({ environmentId: cached.environmentId }, cached.snapshot);
  appAtomRegistry.set(cachedShellSnapshotMetadataAtom, {
    ...appAtomRegistry.get(cachedShellSnapshotMetadataAtom),
    [cached.environmentId]: {
      snapshotReceivedAt: cached.snapshotReceivedAt,
    },
  });
}

export function markShellSnapshotLive(environmentId: EnvironmentId): void {
  const current = appAtomRegistry.get(cachedShellSnapshotMetadataAtom);
  if (current[environmentId] === undefined) {
    return;
  }

  const next = { ...current };
  delete next[environmentId];
  appAtomRegistry.set(cachedShellSnapshotMetadataAtom, next);
}

export function clearCachedShellSnapshotMetadata(environmentId: EnvironmentId): void {
  markShellSnapshotLive(environmentId);
}

export function useCachedShellSnapshotMetadata(): Readonly<
  Record<EnvironmentId, { readonly snapshotReceivedAt: string }>
> {
  return useAtomValue(cachedShellSnapshotMetadataAtom);
}

export function useShellSnapshot(environmentId: EnvironmentId | null): ShellSnapshotState {
  const targetKey = getShellSnapshotTargetKey({ environmentId });
  const state = useAtomValue(
    targetKey !== null ? shellSnapshotStateAtom(targetKey) : EMPTY_SHELL_SNAPSHOT_ATOM,
  );
  return targetKey === null ? EMPTY_SHELL_SNAPSHOT_STATE : state;
}

export function useShellSnapshotStates(
  environmentIds: ReadonlyArray<EnvironmentId>,
): Readonly<Record<EnvironmentId, ShellSnapshotState>> {
  const stableEnvironmentIds = useMemo(
    () => Arr.sort(new Set(environmentIds), Order.String),
    [environmentIds],
  );
  const snapshotCacheRef = useRef<Readonly<Record<EnvironmentId, ShellSnapshotState>>>({});

  const subscribe = useCallback(
    (onStoreChange: () => void) => {
      const unsubs = stableEnvironmentIds.map((environmentId) =>
        appAtomRegistry.subscribe(shellSnapshotStateAtom(environmentId), onStoreChange),
      );
      return () => {
        for (const unsub of unsubs) {
          unsub();
        }
      };
    },
    [stableEnvironmentIds],
  );

  const getSnapshot = useCallback(() => {
    const previous = snapshotCacheRef.current;
    let hasChanged = Object.keys(previous).length !== stableEnvironmentIds.length;
    const next: Record<EnvironmentId, ShellSnapshotState> = {};

    for (const environmentId of stableEnvironmentIds) {
      const snapshot = shellSnapshotManager.getSnapshot({ environmentId });
      next[environmentId] = snapshot;
      if (!hasChanged && previous[environmentId] !== snapshot) {
        hasChanged = true;
      }
    }

    if (!hasChanged) {
      return previous;
    }

    snapshotCacheRef.current = next;
    return next;
  }, [stableEnvironmentIds]);

  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
}