import {
type EnvironmentId,
type ProjectId,
type ScopedThreadRef,
type ThreadLinkedPullRequest,
type VcsStatusResult,
} from "@t3tools/contracts";
import { scopedThreadKey } from "@t3tools/client-runtime/environment";
import {
isAtomCommandInterrupted,
squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
import { useEffect, useRef } from "react";
import { selectActiveRightPanelSurface, useRightPanelStore } from "../../rightPanelStore";
import { threadEnvironment } from "../../state/threads";
import { useOrchestrationCommand } from "../../state/use-orchestration-command";
import { useLinkedThreadPullRequest } from "../ThreadStatusIndicators";
import { stackedThreadToast, toastManager } from "../ui/toast";
/** Relink replaced closed/merged requests to the newer open request on the same branch, moving its panel. */
export function useThreadLinkedPullRequest(input: {
readonly serverThreadRef: ScopedThreadRef | null;
readonly environmentId: EnvironmentId | null;
readonly persisted: ThreadLinkedPullRequest | null;
readonly projectId: ProjectId | null;
readonly projectRepository: string | null;
readonly threadBranch: string | null;
readonly gitStatus: VcsStatusResult | null;
}) {
const { serverThreadRef, persisted, projectId, projectRepository, threadBranch, gitStatus } =
input;
const updateThreadMetadata = useOrchestrationCommand(threadEnvironment.updateMetadata, {
reportFailure: false,
});
const persistedStatus = useLinkedThreadPullRequest(input.environmentId, persisted);
const detected = gitStatus?.pr;
const replacement: ThreadLinkedPullRequest | null =
persisted === null ||
(persistedStatus?.pr.state !== "merged" && persistedStatus?.pr.state !== "closed") ||
gitStatus?.refName !== threadBranch ||
detected?.state !== "open" ||
detected.headRef !== threadBranch ||
projectId === null ||
projectRepository === null ||
(persisted.projectId === projectId &&
persisted.repository.toLowerCase() === projectRepository.toLowerCase() &&
persisted.number === detected.number)
? null
: { projectId, repository: projectRepository, number: detected.number, url: detected.url };
const relinkKeysRef = useRef(new Map<string, string>());
const relinkWriteRef = useRef(Promise.resolve());
// oxlint-disable-next-line t3code/no-unreasoned-state-sync -- persists the detected PR to the server thread once per change and retargets the open right panel store
useEffect(() => {
if (serverThreadRef === null) return;
const threadKey = scopedThreadKey(serverThreadRef);
if (replacement === null) {
relinkKeysRef.current.delete(threadKey);
return;
}
const relinkKey = `${replacement.projectId}:${replacement.repository}#${replacement.number}`;
if (relinkKeysRef.current.get(threadKey) === relinkKey) return;
relinkKeysRef.current.set(threadKey, relinkKey);
const openSurface = selectActiveRightPanelSurface(
useRightPanelStore.getState().byThreadKey,
serverThreadRef,
);
if (
openSurface?.kind === "pull-request" &&
persisted !== null &&
openSurface.projectId === persisted.projectId &&
openSurface.repository.toLowerCase() === persisted.repository.toLowerCase() &&
openSurface.number === persisted.number
) {
useRightPanelStore.getState().openPullRequest(serverThreadRef, replacement);
}
relinkWriteRef.current = relinkWriteRef.current.then(async () => {
if (relinkKeysRef.current.get(threadKey) !== relinkKey) return;
const result = await updateThreadMetadata({
environmentId: serverThreadRef.environmentId,
input: { threadId: serverThreadRef.threadId, linkedPullRequest: replacement },
});
if (relinkKeysRef.current.get(threadKey) !== relinkKey) return;
if (result._tag !== "Failure") return;
relinkKeysRef.current.delete(threadKey);
if (isAtomCommandInterrupted(result)) return;
const error = squashAtomCommandFailure(result);
toastManager.add(
stackedThreadToast({
type: "error",
title: "Unable to update the thread pull request",
description: error instanceof Error ? error.message : "An error occurred.",
}),
);
});
}, [persisted, replacement, serverThreadRef, updateThreadMetadata]);
const linked = replacement ?? persisted;
return {
linked,
linkedKey: linked ? JSON.stringify([linked.projectId, linked.repository, linked.number]) : null,
hasDetail: persisted !== null,
};
}