import { useAtomValue } from "@effect/atom-react";
import type { EnvironmentId } from "@t3tools/contracts";
import { automaticServerUpdateDecision } from "@t3tools/client-runtime/state/server";
import * as Option from "effect/Option";
import { useEffect, useRef } from "react";

import { APP_VERSION } from "~/branding";
import { useEnvironments } from "~/state/environments";
import { environmentShell } from "~/state/shell";
import { serverEnvironment } from "~/state/server";
import { useAtomCommand } from "~/state/use-atom-command";

function EnvironmentAutomaticServerUpdate({
  connected,
  environmentId,
}: {
  readonly connected: boolean;
  readonly environmentId: EnvironmentId;
}) {
  const serverConfig = useAtomValue(serverEnvironment.configValueAtom(environmentId));
  const shell = useAtomValue(environmentShell.stateValueAtom(environmentId));
  const updateState = useAtomValue(serverEnvironment.updateStateAtom(environmentId));
  const updateServer = useAtomCommand(serverEnvironment.updateServer, { reportFailure: false });
  const setAutomaticUpdatePending = useAtomCommand(serverEnvironment.setAutomaticUpdatePending, {
    reportFailure: false,
  });
  const attemptedTargetRef = useRef<string | null>(null);
  const decision = automaticServerUpdateDecision({
    enabled: connected && (serverConfig?.settings.automaticallyUpdateWhenIdle ?? false),
    selfUpdate: serverConfig?.environment.capabilities.serverSelfUpdate ?? null,
    clientVersion: APP_VERSION,
    serverVersion: serverConfig?.environment.serverVersion ?? "",
    shellStatus: shell.status,
    threads: Option.isSome(shell.snapshot) ? shell.snapshot.value.threads : [],
  });
  const decisionStatus = decision.status;
  const decisionReason = decision.status === "pending" ? decision.reason : null;
  const fromVersion = decision.status === "ineligible" ? null : decision.fromVersion;
  const targetVersion = decision.status === "ineligible" ? null : decision.targetVersion;

  useEffect(() => {
    if (decisionStatus !== "ready" || fromVersion === null || targetVersion === null) {
      attemptedTargetRef.current = null;
    }

    if (decisionStatus === "pending" && fromVersion !== null && targetVersion !== null) {
      const pendingMatches =
        updateState.status === "pending" &&
        updateState.reason === decisionReason &&
        updateState.fromVersion === fromVersion &&
        updateState.targetVersion === targetVersion;
      if (!pendingMatches) {
        void setAutomaticUpdatePending({
          environmentId,
          pending: {
            status: "pending",
            reason: decisionReason ?? "synchronizing",
            fromVersion,
            targetVersion,
          },
        });
      }
      return;
    }

    if (decisionStatus === "ineligible") {
      if (updateState.status === "pending") {
        void setAutomaticUpdatePending({ environmentId, pending: null });
      }
      return;
    }

    if (decisionStatus !== "ready" || fromVersion === null || targetVersion === null) {
      return;
    }

    const targetKey = `${fromVersion}->${targetVersion}`;
    if (updateState.status === "running") {
      attemptedTargetRef.current = targetKey;
      return;
    }
    if (
      updateState.status === "failed" &&
      updateState.fromVersion === fromVersion &&
      updateState.targetVersion === targetVersion
    ) {
      attemptedTargetRef.current = targetKey;
      return;
    }
    if (attemptedTargetRef.current === targetKey) {
      return;
    }

    attemptedTargetRef.current = targetKey;
    void updateServer({
      environmentId,
      input: { targetVersion, automatic: true },
    });
  }, [
    decisionReason,
    decisionStatus,
    environmentId,
    fromVersion,
    setAutomaticUpdatePending,
    targetVersion,
    updateServer,
    updateState,
  ]);

  return null;
}

export function AutomaticServerUpdateCoordinator() {
  const { environments } = useEnvironments();

  return environments.map((environment) => (
    <EnvironmentAutomaticServerUpdate
      key={environment.environmentId}
      connected={environment.connection.phase === "connected"}
      environmentId={environment.environmentId}
    />
  ));
}