import type {
  RepositoryIdentity,
  SourceControlProviderKind,
  ThreadLinkedPullRequest,
  ThreadPullRequestKey,
  ThreadPullRequestLink,
} from "@t3tools/contracts";

import { pullRequestHostOf } from "@t3tools/contracts";
import { parseChangeRequestUrl } from "./changeRequestUrl.ts";
import { canonicalRepositoryKey, sourceControlRepositorySelector } from "./sourceControl.ts";

/** Normalize stored link identity, including Azure's SSH and browser host aliases. */
export function normalizeThreadPullRequestKey(key: ThreadPullRequestKey): ThreadPullRequestKey {
  const canonical = canonicalRepositoryKey(
    `${key.host.trim().toLowerCase()}/${key.repository.trim().toLowerCase()}`,
  );
  const separator = canonical.indexOf("/");
  return {
    host: canonical.slice(0, separator),
    repository: canonical.slice(separator + 1),
    number: key.number,
  };
}

/** Legacy Azure selectors omit the organization and project; recover those from the PR URL. */
export function legacyThreadPullRequestKey(
  linked: Pick<ThreadLinkedPullRequest, "repository" | "number" | "url">,
  fallbackHost?: string,
): ThreadPullRequestKey {
  const parsed = parseChangeRequestUrl(linked.url);
  if (parsed !== null && parsed.number === linked.number) {
    const canonical = canonicalRepositoryKey(`${parsed.host}/${parsed.repository}`);
    if (canonical.startsWith("dev.azure.com/")) {
      return normalizeThreadPullRequestKey(parsed);
    }
  }
  let host = fallbackHost;
  if (host === undefined) {
    try {
      host = new URL(linked.url).hostname;
    } catch {
      host = "unknown";
    }
  }
  return {
    host: host.trim().toLowerCase() || "unknown",
    repository: linked.repository.trim().toLowerCase(),
    number: linked.number,
  };
}

/** Identity comparison for links: host-level, case-insensitive on host and repository. */
export function threadPullRequestKeysEqual(
  left: ThreadPullRequestKey,
  right: ThreadPullRequestKey,
): boolean {
  return threadPullRequestKeyOf(left) === threadPullRequestKeyOf(right);
}

export function threadPullRequestKeyOf(key: ThreadPullRequestKey): string {
  const normalized = normalizeThreadPullRequestKey(key);
  return `${normalized.host}/${normalized.repository}#${normalized.number}`;
}

/** Links a user should see. Tombstoned stack members stay in the array only so the
 * sync reactor does not re-add them. */
export function visibleThreadPullRequests(
  links: ReadonlyArray<ThreadPullRequestLink>,
): ReadonlyArray<ThreadPullRequestLink> {
  return links.filter((link) => link.source !== "stack-dismissed");
}

function isOpen(link: ThreadPullRequestLink): boolean {
  // Unsynced links are treated as open: they were just linked, and hiding them
  // behind a terminal PR until the first sync would make the link look lost.
  return link.snapshot === null || link.snapshot.state === "open";
}

function latestUpdatedAt(link: ThreadPullRequestLink): number {
  const value = link.snapshot?.updatedAt ?? link.linkedAt;
  const ms = Date.parse(value);
  return Number.isNaN(ms) ? 0 : ms;
}

/** The single pull request a one-slot surface (sidebar badge, tab icon, copy link) shows. */
export type ThreadCurrentPullRequest =
  | { readonly kind: "single"; readonly link: ThreadPullRequestLink }
  | {
      readonly kind: "stack";
      readonly open: ReadonlyArray<ThreadPullRequestLink>;
      /** Highest layer of the open set; the one "View PR" and copy-link target. */
      readonly top: ThreadPullRequestLink;
    };

/**
 * Prefer open work and the highest open layer within a chain. A completed chain still
 * points at its top; unrelated terminal links use the most recently updated request.
 */
export function resolveThreadCurrentPullRequest(
  links: ReadonlyArray<ThreadPullRequestLink>,
): ThreadCurrentPullRequest | null {
  const visible = visibleThreadPullRequests(links);
  if (visible.length === 0) return null;
  const open = visible.filter(isOpen);
  if (open.length === 1) return { kind: "single", link: open[0]! };
  const chains = resolveThreadPullRequestChains(visible);
  if (open.length > 1) {
    const openChains = chains
      .map((chain) => chain.layers.toReversed().filter(isOpen))
      .filter((layers) => layers.length > 0)
      .sort(
        (left, right) =>
          Math.max(...right.map((link) => Date.parse(link.linkedAt))) -
          Math.max(...left.map((link) => Date.parse(link.linkedAt))),
      );
    const ordered = openChains.flat();
    return { kind: "stack", open: ordered, top: ordered[0]! };
  }
  if (chains.length === 1) {
    return { kind: "single", link: chains[0]!.layers.at(-1)! };
  }
  const terminal = [...visible].sort(
    (left, right) => latestUpdatedAt(right) - latestUpdatedAt(left),
  );
  return { kind: "single", link: terminal[0]! };
}

/** The one link a legacy `linkedPullRequest` consumer should see, or null. */
export function resolveThreadCurrentPullRequestLink(
  links: ReadonlyArray<ThreadPullRequestLink>,
): ThreadPullRequestLink | null {
  const current = resolveThreadCurrentPullRequest(links);
  if (current === null) return null;
  return current.kind === "single" ? current.link : current.top;
}

/** Legacy clients can only route links belonging to the thread's own repository. */
export function legacyLinkedPullRequestOf(
  links: ReadonlyArray<ThreadPullRequestLink>,
  projectId: ThreadLinkedPullRequest["projectId"],
  identity: RepositoryIdentity | null | undefined,
): ThreadLinkedPullRequest | null {
  if (!identity) return null;
  const host = pullRequestHostOf(identity, identity.provider as SourceControlProviderKind);
  const repository = sourceControlRepositorySelector(identity);
  if (repository === null) return null;
  const azureKey =
    identity.provider === "azure-devops"
      ? canonicalRepositoryKey(identity.canonicalKey.toLowerCase())
      : null;
  const link = resolveThreadCurrentPullRequestLink(
    links.filter((link) => {
      if (azureKey !== null) {
        const key = legacyThreadPullRequestKey(link, link.host);
        return canonicalRepositoryKey(`${key.host}/${key.repository}`) === azureKey;
      }
      return (
        link.host.toLowerCase() === host.toLowerCase() &&
        link.repository.toLowerCase() === repository.toLowerCase()
      );
    }),
  );
  if (link === null) return null;
  return {
    projectId,
    repository: azureKey === null ? link.repository : repository,
    number: link.number,
    url: link.url,
  };
}

export interface ThreadPullRequestChain {
  readonly kind: "native" | "derived";
  /** Bottom to top. */
  readonly layers: ReadonlyArray<ThreadPullRequestLink>;
}

/**
 * Groups a thread's links into stacks. Native stacks come from the host and win; the rest
 * are chained by matching one link's base branch to another's head branch within the same
 * repository. A link that chains to nothing is a one-layer chain.
 */
export function resolveThreadPullRequestChains(
  links: ReadonlyArray<ThreadPullRequestLink>,
): ReadonlyArray<ThreadPullRequestChain> {
  const visible = visibleThreadPullRequests(links);
  const chains: Array<ThreadPullRequestChain> = [];
  const placed = new Set<string>();

  const nativeStacks = new Map<string, Array<ThreadPullRequestLink>>();
  for (const link of visible) {
    if (link.stack === null) continue;
    const stackKey = `${link.host.toLowerCase()}/${link.repository.toLowerCase()}#stack:${link.stack.id}`;
    const members = nativeStacks.get(stackKey) ?? [];
    members.push(link);
    nativeStacks.set(stackKey, members);
  }
  for (const members of nativeStacks.values()) {
    const order = new Map(members[0]!.stack!.layers.map((layer, index) => [layer.number, index]));
    members.sort((left, right) => (order.get(left.number) ?? 0) - (order.get(right.number) ?? 0));
    for (const member of members) placed.add(threadPullRequestKeyOf(member));
    chains.push({ kind: "native", layers: members });
  }

  const remaining = visible.filter((link) => !placed.has(threadPullRequestKeyOf(link)));
  const branchKey = (link: ThreadPullRequestLink, branch: string) =>
    `${link.host.toLowerCase()}/${link.repository.toLowerCase()}:${branch}`;
  // Reused head names cannot identify a parent unambiguously.
  const byHead = new Map<string, ThreadPullRequestLink | null>();
  for (const link of remaining) {
    if (link.snapshot === null) continue;
    const key = branchKey(link, link.snapshot.headBranch);
    byHead.set(key, byHead.has(key) ? null : link);
  }
  const hasChild = new Set<string>();
  for (const link of remaining) {
    if (link.snapshot === null) continue;
    const parent = byHead.get(branchKey(link, link.snapshot.baseBranch));
    if (parent != null && parent !== link) hasChild.add(threadPullRequestKeyOf(parent));
  }
  // Walk from each top (a link nothing builds on) down its base chain.
  for (const top of remaining) {
    if (hasChild.has(threadPullRequestKeyOf(top))) continue;
    const layers: Array<ThreadPullRequestLink> = [];
    let cursor: ThreadPullRequestLink | undefined = top;
    while (cursor !== undefined && !placed.has(threadPullRequestKeyOf(cursor))) {
      placed.add(threadPullRequestKeyOf(cursor));
      layers.unshift(cursor);
      cursor =
        cursor.snapshot === null
          ? undefined
          : (byHead.get(branchKey(cursor, cursor.snapshot.baseBranch)) ?? undefined);
    }
    if (layers.length > 0) chains.push({ kind: "derived", layers });
  }
  // Cycles have no top. Keep those links visible without inventing a stack order.
  for (const link of remaining) {
    if (!placed.has(threadPullRequestKeyOf(link))) {
      chains.push({ kind: "derived", layers: [link] });
    }
  }
  return chains;
}

export type ThreadPullRequestBadge = {
  readonly state: "open" | "closed" | "merged" | "draft";
} & (
  | {
      readonly kind: "stack";
      readonly layers: number;
    }
  | { readonly kind: "pull-request"; readonly others: number }
);

/** Aggregate visible links' state for both stacks and unrelated linked counts. */
export function resolveThreadPullRequestBadge(
  pullRequests: ReadonlyArray<ThreadPullRequestLink> | undefined,
): ThreadPullRequestBadge | null {
  const visible = visibleThreadPullRequests(pullRequests ?? []);
  if (visible.length === 0) return null;
  const states = visible.map((link) => link.snapshot?.state ?? "open");
  const state = visible.every((link) => link.snapshot?.state === "open" && link.snapshot.isDraft)
    ? "draft"
    : states.includes("open")
      ? "open"
      : states.every((entry) => entry === "merged")
        ? "merged"
        : "closed";
  const chains = resolveThreadPullRequestChains(visible);
  if (visible.length > 1 && chains.length === 1) {
    return { kind: "stack", layers: visible.length, state };
  }
  return { kind: "pull-request", others: visible.length - 1, state };
}

/** Search terms for visible PR links, including the legacy single-link projection. */
export function threadPullRequestSearchTerms(thread: {
  readonly pullRequests?: ReadonlyArray<ThreadPullRequestLink> | undefined;
  readonly linkedPullRequest?: ThreadLinkedPullRequest | null | undefined;
}): string[] {
  if (thread.pullRequests !== undefined && thread.pullRequests.length > 0) {
    return visibleThreadPullRequests(thread.pullRequests).flatMap((link) => [
      `#${link.number}`,
      `${link.repository}#${link.number}`,
      link.url,
      link.snapshot?.title ?? "",
    ]);
  }
  const legacy = thread.linkedPullRequest;
  return legacy ? [`#${legacy.number}`, `${legacy.repository}#${legacy.number}`, legacy.url] : [];
}