import { useMemo } from "react";
import { sourceControlRepositorySelector } from "@t3tools/shared/sourceControl";
import type {
  EnvironmentId,
  ScopedThreadRef,
  ThreadLinkedPullRequest,
  ThreadPullRequestLink,
} from "@t3tools/contracts";
import {
  isAtomCommandInterrupted,
  squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
import {
  planThreadPullRequestMutation,
  threadPullRequestLinkMode,
} from "@t3tools/client-runtime/thread-pull-request-compatibility";
import {
  threadPullRequestKeysEqual,
  visibleThreadPullRequests,
} from "@t3tools/shared/threadPullRequests";
import {
  findProjectForChangeRequest,
  findProjectOnChangeRequestHost,
  matchesLinkedPullRequestUrl,
  parseChangeRequestUrl,
} from "~/lib/openPullRequestLink";
import { useProjects, useServerConfigs } from "~/state/entities";
import { threadEnvironment } from "~/state/threads";
import { useAtomCommand } from "~/state/use-atom-command";

/** Routes link actions through the command advertised by this environment. */
export function usePullRequestLinking(environmentId: EnvironmentId | null | undefined) {
  const configs = useServerConfigs();
  const projects = useProjects();
  const capabilities =
    environmentId == null ? undefined : configs.get(environmentId)?.environment.capabilities;
  const mode = threadPullRequestLinkMode(capabilities);
  const link = useAtomCommand(threadEnvironment.linkPullRequest, { reportFailure: false });
  const unlink = useAtomCommand(threadEnvironment.unlinkPullRequest, { reportFailure: false });
  const updateMetadata = useAtomCommand(threadEnvironment.updateMetadata, { reportFailure: false });
  return useMemo(() => {
    const environmentProjects = projects.filter(
      (project) => project.environmentId === environmentId,
    );
    const canLink = (url: string) => {
      const parsed = parseChangeRequestUrl(url);
      if (parsed === null || mode === "unsupported") return false;
      return (
        (mode === "multiple" ? findProjectOnChangeRequestHost : findProjectForChangeRequest)(
          environmentProjects,
          parsed,
        ) !== undefined
      );
    };
    const isLinked = (
      thread: {
        readonly pullRequests?: readonly ThreadPullRequestLink[];
        readonly linkedPullRequest?: ThreadLinkedPullRequest | null | undefined;
      } | null,
      url: string,
    ) => {
      if (thread === null || mode === "unsupported") return false;
      if (mode !== "multiple")
        return (
          thread.linkedPullRequest != null &&
          matchesLinkedPullRequestUrl(thread.linkedPullRequest, url)
        );
      const parsed = parseChangeRequestUrl(url);
      return (
        parsed !== null &&
        visibleThreadPullRequests(thread.pullRequests ?? []).some((entry) =>
          threadPullRequestKeysEqual(entry, parsed),
        )
      );
    };
    const changeLink = async (threadRef: ScopedThreadRef, url: string, linked: boolean) => {
      const parsed = parseChangeRequestUrl(url);
      if (parsed === null || threadRef.environmentId !== environmentId || (linked && !canLink(url)))
        throw new Error("The pull request is not available in this environment.");
      const legacyProject = findProjectForChangeRequest(environmentProjects, parsed);
      const mutation = planThreadPullRequestMutation({
        capabilities,
        threadId: threadRef.threadId,
        reference: { ...parsed, url },
        legacyProjectId: legacyProject?.id ?? null,
        legacyRepository:
          sourceControlRepositorySelector(legacyProject?.repositoryIdentity) ?? undefined,
        linked,
      });
      if (mutation === null)
        throw new Error("This environment does not support linking this pull request.");
      const result = await (mutation.type === "thread.meta.update"
        ? updateMetadata({ environmentId: threadRef.environmentId, input: mutation.input })
        : mutation.type === "thread.pull-request.link"
          ? link({ environmentId: threadRef.environmentId, input: mutation.input })
          : unlink({ environmentId: threadRef.environmentId, input: mutation.input }));
      if (result._tag === "Failure") {
        if (isAtomCommandInterrupted(result)) throw new Error("Link update interrupted.");
        throw squashAtomCommandFailure(result);
      }
    };
    return { mode, canLink, isLinked, changeLink };
  }, [capabilities, environmentId, link, mode, projects, unlink, updateMetadata]);
}