import { useMemo } from "react";import * as Order from "effect/Order";import * as Arr from "effect/Array"; import {  EnvironmentConnectionState,  EnvironmentScopedProjectShell,  EnvironmentScopedThreadShell,  scopeProjectShell,  scopeThreadShell,} from "@t3tools/client-runtime"; import { ConnectedEnvironmentSummary } from "./remote-runtime-types";import type { SavedRemoteConnection } from "../lib/connection";import { useCachedShellSnapshotMetadata, useShellSnapshotStates } from "./use-shell-snapshot";import {  useRemoteConnectionStatus,  useRemoteEnvironmentState,} from "./use-remote-environment-registry"; const projectsSortOrder = Order.mapInput(  Order.Struct({    title: Order.String,    environmentId: Order.String,  }),  (project: EnvironmentScopedProjectShell) => ({    title: project.title,    environmentId: project.environmentId,  }),); const threadsSortOrder = Order.mapInput(  Order.Struct({    activityAt: Order.flip(Order.String),    environmentId: Order.String,  }),  (thread: EnvironmentScopedThreadShell) => ({    activityAt: thread.updatedAt ?? thread.createdAt,    environmentId: thread.environmentId,  }),); function deriveOverallConnectionState(  environments: ReadonlyArray<ConnectedEnvironmentSummary>,): EnvironmentConnectionState {  if (environments.length === 0) {    return "idle";  }  if (environments.some((environment) => environment.connectionState === "ready")) {    return "ready";  }  if (environments.some((environment) => environment.connectionState === "reconnecting")) {    return "reconnecting";  }  if (environments.some((environment) => environment.connectionState === "connecting")) {    return "connecting";  }  return "disconnected";} function listRemoteCatalogEnvironmentIds(  savedConnectionsById: Readonly<Record<string, SavedRemoteConnection>>,): ReadonlyArray<SavedRemoteConnection["environmentId"]> {  const environmentIds: SavedRemoteConnection["environmentId"][] = [];  for (const connection of Object.values(savedConnectionsById)) {    environmentIds.push(connection.environmentId);  }  return environmentIds;} export interface RemoteCatalogState {  readonly isLoadingSavedConnections: boolean;  readonly hasSavedConnections: boolean;  readonly hasLoadedShellSnapshot: boolean;  readonly hasPendingShellSnapshot: boolean;  readonly hasReadyEnvironment: boolean;  readonly hasConnectingEnvironment: boolean;  readonly connectionState: EnvironmentConnectionState;  readonly connectionError: string | null;  readonly shellSnapshotError: string | null;  readonly isUsingCachedData: boolean;  readonly latestCachedSnapshotReceivedAt: string | null;} export function useRemoteCatalog() {  const { connectedEnvironments, connectionError, connectionState } = useRemoteConnectionStatus();  const { environmentStateById, isLoadingSavedConnection, savedConnectionsById } =    useRemoteEnvironmentState();  const catalogEnvironmentIds = useMemo(    () => listRemoteCatalogEnvironmentIds(savedConnectionsById),    [savedConnectionsById],  );  const shellSnapshotStates = useShellSnapshotStates(catalogEnvironmentIds);  const cachedShellSnapshotMetadata = useCachedShellSnapshotMetadata();   const projects = useMemo(() => {    const scopedProjects: EnvironmentScopedProjectShell[] = [];    for (const connection of Object.values(savedConnectionsById)) {      const projects = shellSnapshotStates[connection.environmentId]?.data?.projects ?? [];      for (const project of projects) {        scopedProjects.push(scopeProjectShell(connection.environmentId, project));      }    }    return Arr.sort(scopedProjects, projectsSortOrder);  }, [savedConnectionsById, shellSnapshotStates]);   const threads = useMemo(() => {    const scopedThreads: EnvironmentScopedThreadShell[] = [];    for (const connection of Object.values(savedConnectionsById)) {      const threads = shellSnapshotStates[connection.environmentId]?.data?.threads ?? [];      for (const thread of threads) {        scopedThreads.push(scopeThreadShell(connection.environmentId, thread));      }    }    return Arr.sort(scopedThreads, threadsSortOrder);  }, [savedConnectionsById, shellSnapshotStates]);   const serverConfigByEnvironmentId = useMemo(    () =>      Object.fromEntries(        Object.entries(environmentStateById).map(([environmentId, runtime]) => [          environmentId,          runtime.serverConfig ?? null,        ]),      ),    [environmentStateById],  );   const overallConnectionState = useMemo(    () => deriveOverallConnectionState(connectedEnvironments),    [connectedEnvironments],  );   const hasRemoteActivity = useMemo(    () =>      threads.some(        (thread) => thread.session?.status === "running" || thread.session?.status === "starting",      ),    [threads],  );   const state = useMemo<RemoteCatalogState>(() => {    const shellSnapshots = Object.values(shellSnapshotStates);    const cachedSnapshotReceivedAts: string[] = [];    for (const environmentId of catalogEnvironmentIds) {      const metadata = cachedShellSnapshotMetadata[environmentId];      if (metadata) {        cachedSnapshotReceivedAts.push(metadata.snapshotReceivedAt);      }    }    let shellSnapshotError: string | null = null;    for (const snapshot of shellSnapshots) {      if (snapshot.error !== null) {        shellSnapshotError = snapshot.error;        break;      }    }    return {      isLoadingSavedConnections: isLoadingSavedConnection,      hasSavedConnections: catalogEnvironmentIds.length > 0,      hasLoadedShellSnapshot: shellSnapshots.some((snapshot) => snapshot.data !== null),      hasPendingShellSnapshot: shellSnapshots.some((snapshot) => snapshot.isPending),      hasReadyEnvironment: connectedEnvironments.some(        (environment) => environment.connectionState === "ready",      ),      hasConnectingEnvironment: connectedEnvironments.some(        (environment) =>          environment.connectionState === "connecting" ||          environment.connectionState === "reconnecting",      ),      connectionState: connectionState ?? overallConnectionState,      connectionError,      shellSnapshotError,      isUsingCachedData: cachedSnapshotReceivedAts.length > 0,      latestCachedSnapshotReceivedAt:        Arr.sort(cachedSnapshotReceivedAts, Order.flip(Order.String))[0] ?? null,    };  }, [    cachedShellSnapshotMetadata,    catalogEnvironmentIds,    connectedEnvironments,    connectionError,    connectionState,    isLoadingSavedConnection,    overallConnectionState,    shellSnapshotStates,  ]);   return {    projects,    threads,    serverConfigByEnvironmentId,    connectionState: state.connectionState,    connectionError: state.connectionError,    state,    hasRemoteActivity,  };}