import type {
  EnvironmentPresentation,
  PreparedConnection,
} from "@t3tools/client-runtime/connection";
import { connectionCatalogDisplayUrl } from "@t3tools/client-runtime/connection";
import type { EnvironmentId, ServerConfig } from "@t3tools/contracts";
import * as Option from "effect/Option";
import { Atom } from "effect/unstable/reactivity";

import type { SavedRemoteConnection } from "../lib/connection";
import type { EnvironmentRuntimeState } from "./remote-runtime-types";

export function createRemoteEnvironmentProjectionAtoms(input: {
  readonly presentationAtom: (
    environmentId: EnvironmentId,
  ) => Atom.Atom<EnvironmentPresentation | null>;
  readonly preparedConnectionAtom: (
    environmentId: EnvironmentId,
  ) => Atom.Atom<Option.Option<PreparedConnection>>;
  readonly serverConfigAtom: (environmentId: EnvironmentId) => Atom.Atom<ServerConfig | null>;
}) {
  const savedConnectionAtom = Atom.family((environmentId: EnvironmentId) => {
    let previousEntry: EnvironmentPresentation["entry"] | null = null;
    let previousPrepared: PreparedConnection | null = null;
    let previous: SavedRemoteConnection | null = null;

    return Atom.make((get) => {
      const presentation = get(input.presentationAtom(environmentId));
      if (presentation === null) {
        previousEntry = null;
        previousPrepared = null;
        previous = null;
        return null;
      }

      const prepared = Option.getOrNull(get(input.preparedConnectionAtom(environmentId)));
      if (
        previous !== null &&
        presentation.entry === previousEntry &&
        prepared === previousPrepared
      ) {
        return previous;
      }

      const displayUrl = connectionCatalogDisplayUrl(presentation.entry) ?? "";
      const httpBaseUrl = prepared?.httpBaseUrl ?? displayUrl;
      const socketUrl = prepared?.socketUrl ?? "";
      const wsBaseUrl =
        socketUrl === ""
          ? displayUrl.startsWith("https://")
            ? displayUrl.replace(/^https:/, "wss:")
            : displayUrl.replace(/^http:/, "ws:")
          : new URL(socketUrl).origin;
      const authorization = prepared?.httpAuthorization ?? null;
      const relayManaged = presentation.entry.target._tag === "RelayConnectionTarget";

      previousEntry = presentation.entry;
      previousPrepared = prepared;
      previous = {
        environmentId,
        environmentLabel: presentation.entry.target.label,
        pairingUrl: displayUrl,
        displayUrl,
        httpBaseUrl,
        wsBaseUrl,
        bearerToken: authorization?._tag === "Bearer" ? authorization.token : null,
        ...(relayManaged
          ? {
              authenticationMethod: "dpop" as const,
              relayManaged: true as const,
              ...(authorization?._tag === "Dpop"
                ? { dpopAccessToken: authorization.accessToken }
                : {}),
            }
          : { authenticationMethod: "bearer" as const }),
      };
      return previous;
    }).pipe(Atom.withLabel(`mobile:saved-connection:${environmentId}`));
  });

  const runtimeStateAtom = Atom.family((environmentId: EnvironmentId) => {
    let previousConnection: EnvironmentPresentation["connection"] | null = null;
    let previousServerConfig: ServerConfig | null = null;
    let previous: EnvironmentRuntimeState | null = null;

    return Atom.make((get) => {
      const presentation = get(input.presentationAtom(environmentId));
      if (presentation === null) {
        previousConnection = null;
        previousServerConfig = null;
        previous = null;
        return null;
      }

      const connection = presentation.connection;
      const serverConfig = get(input.serverConfigAtom(environmentId));
      if (
        previous !== null &&
        connection.phase === previousConnection?.phase &&
        connection.error === previousConnection?.error &&
        connection.traceId === previousConnection?.traceId &&
        serverConfig === previousServerConfig
      ) {
        return previous;
      }

      previousConnection = connection;
      previousServerConfig = serverConfig;
      previous = {
        connectionState: connection.phase,
        connectionError: connection.error,
        connectionErrorTraceId: connection.traceId,
        serverConfig,
      };
      return previous;
    }).pipe(Atom.withLabel(`mobile:environment-runtime-state:${environmentId}`));
  });

  return { savedConnectionAtom, runtimeStateAtom };
}