export function getFileExtension(path: string): string {
  const lastDot = path.lastIndexOf(".");
  const lastSlash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
  if (lastDot <= lastSlash + 1) return "";
  return path.slice(lastDot + 1);
}

const WINDOWS_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]/;
const EXPLICIT_URL_SCHEME = /^[A-Za-z][A-Za-z\d+.-]*:/;
const MARKDOWN_ESCAPABLE = new Set(`!"#$%&'()*+,-./:;<=>?@[\\]^_\`{|}~ \t`.split(""));

export type LinkTarget =
  | { kind: "internal"; path: string; anchor?: string }
  | { kind: "same-doc-anchor"; anchor: string }
  | { kind: "external-url"; url: string }
  | { kind: "external-path"; path: string };

function splitLinkHref(href: string): string {
  const hashIndex = href.indexOf("#");
  const queryIndex = href.indexOf("?");
  const splitIndex =
    hashIndex === -1 ? queryIndex : queryIndex === -1 ? hashIndex : Math.min(hashIndex, queryIndex);
  return splitIndex === -1 ? href : href.slice(0, splitIndex);
}

function extractAnchor(href: string): string | undefined {
  const hashIndex = href.indexOf("#");
  if (hashIndex === -1) return undefined;
  const anchor = href.slice(hashIndex + 1);
  return anchor ? decodeLinkPath(anchor) : undefined;
}

export function decodeLinkPath(path: string): string {
  try {
    return decodeURIComponent(path);
  } catch {
    return path;
  }
}

function unescapeMarkdownDestination(path: string): string {
  let result = "";
  for (let index = 0; index < path.length; index++) {
    const char = path[index]!;
    const next = path[index + 1];
    if (char === "\\" && next && MARKDOWN_ESCAPABLE.has(next)) {
      result += next;
      index++;
      continue;
    }
    result += char;
  }
  return result;
}

export function normalizeMarkdownDestination(destination: string): string {
  let normalized = destination.trim();
  if (normalized.startsWith("<") && normalized.endsWith(">")) {
    normalized = normalized.slice(1, -1).trim();
  }
  return unescapeMarkdownDestination(normalized);
}

export function normalizeLocalMarkdownDestination(destination: string): string {
  return decodeLinkPath(normalizeMarkdownDestination(destination));
}

export function formatMarkdownDestination(destination: string): string {
  if (!/[\s<>]/.test(destination)) return destination;
  const escaped = destination.replace(/</g, "%3C").replace(/>/g, "%3E");
  return `<${escaped}>`;
}

export function normalizePath(path: string): string {
  const normalized = path.replace(/\\/g, "/");
  const isWindowsAbsolute = WINDOWS_ABSOLUTE_PATH.test(normalized);
  const hasLeadingSlash = normalized.startsWith("/");
  const parts = normalized.split("/");
  const stack: string[] = [];

  for (const part of parts) {
    if (!part || part === ".") continue;
    if (part === "..") {
      const last = stack[stack.length - 1];
      if (last && last !== "..") {
        if (isWindowsAbsolute || hasLeadingSlash || !WINDOWS_ABSOLUTE_PATH.test(last)) {
          stack.pop();
          continue;
        }
      }
      if (!isWindowsAbsolute && !hasLeadingSlash) stack.push(part);
      continue;
    }
    stack.push(part);
  }

  if (isWindowsAbsolute) {
    const [drive, ...rest] = stack;
    return rest.length === 0 ? `${drive}/` : `${drive}/${rest.join("/")}`;
  }

  if (hasLeadingSlash) {
    return stack.length === 0 ? "/" : `/${stack.join("/")}`;
  }

  return stack.join("/");
}

function resolvePath(baseDir: string, target: string): string {
  if (WINDOWS_ABSOLUTE_PATH.test(target) || target.startsWith("/")) {
    return normalizePath(target);
  }
  return normalizePath(`${baseDir.replace(/\/$/, "")}/${target}`);
}

function isPathInsideRoot(path: string, root: string): boolean {
  const normalizedPath = normalizePath(path);
  const normalizedRoot = normalizePath(root).replace(/\/$/, "");
  return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
}

export type FileExistsFn = (path: string) => boolean | Promise<boolean>;

export async function resolveLinkTarget(
  href: string,
  currentFilePath: string,
  workspaceRoot?: string | null,
  fileExists?: FileExistsFn,
): Promise<LinkTarget | null> {
  const trimmed = normalizeMarkdownDestination(href);
  if (!trimmed) return null;
  if (trimmed.startsWith("#")) {
    const anchor = extractAnchor(trimmed);
    return anchor ? { kind: "same-doc-anchor", anchor } : null;
  }
  if (EXPLICIT_URL_SCHEME.test(trimmed) && !WINDOWS_ABSOLUTE_PATH.test(trimmed)) {
    return { kind: "external-url", url: trimmed };
  }

  const target = splitLinkHref(trimmed);
  if (!target) return null;

  const anchor = extractAnchor(trimmed);
  const decodedTarget = decodeLinkPath(target);
  const resolvedPath = resolvePath(getParentDir(currentFilePath), decodedTarget);

  const extension = getFileExtension(resolvedPath).toLowerCase();
  const isMarkdown = extension === "md" || extension === "markdown";

  if (isMarkdown && (!workspaceRoot || isPathInsideRoot(resolvedPath, workspaceRoot))) {
    return { kind: "internal", path: resolvedPath, ...(anchor ? { anchor } : {}) };
  }

  // Probe for markdown files when the resolved path has no recognized extension.
  // For doc-corpus conventions (Hugo, Docusaurus, MDN, …), extensionless
  // absolute paths like `/docs/foo/bar/` are site-root-relative, so we probe
  // both their workspace-root mapping and their filesystem mapping.
  if (extension === "" && fileExists) {
    const bases: string[] = [resolvedPath.replace(/\/+$/, "")];
    const isPosixAbsolute =
      decodedTarget.startsWith("/") && !WINDOWS_ABSOLUTE_PATH.test(decodedTarget);
    if (isPosixAbsolute && workspaceRoot) {
      const rootRelative = normalizePath(
        `${workspaceRoot.replace(/\/$/, "")}${decodedTarget}`,
      ).replace(/\/+$/, "");
      if (!bases.includes(rootRelative)) bases.push(rootRelative);
    }

    for (const base of bases) {
      const candidates = [
        `${base}.md`,
        `${base}.markdown`,
        `${base}/index.md`,
        `${base}/index.markdown`,
        `${base}/README.md`,
      ];
      for (const candidate of candidates) {
        if (workspaceRoot && !isPathInsideRoot(candidate, workspaceRoot)) continue;
        if (await fileExists(candidate)) {
          return { kind: "internal", path: candidate, ...(anchor ? { anchor } : {}) };
        }
      }
    }
  }

  return { kind: "external-path", path: resolvedPath };
}

export function getFileStem(path: string): string {
  const name = getFileName(path);
  const lastDot = name.lastIndexOf(".");
  if (lastDot <= 0) return name;
  return name.slice(0, lastDot);
}

export function getFileName(path: string): string {
  const lastSlash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
  return path.slice(lastSlash + 1);
}

export function getRelativePath(fullPath: string, root: string): string {
  const normalized = fullPath.replace(/\\/g, "/");
  const normalizedRoot = root.replace(/\\/g, "/").replace(/\/$/, "");
  if (normalized.startsWith(normalizedRoot + "/")) {
    return normalized.slice(normalizedRoot.length + 1);
  }
  return normalized;
}

export function getParentDir(path: string): string {
  const normalized = path.replace(/\\/g, "/");
  const lastSlash = normalized.lastIndexOf("/");
  if (lastSlash <= 0) return "/";
  return normalized.slice(0, lastSlash);
}

export function resolveImagePath(imageSrc: string, markdownDir: string): string {
  const normalizedSrc = normalizeMarkdownDestination(imageSrc);
  if (normalizedSrc.startsWith("http://") || normalizedSrc.startsWith("https://")) {
    return normalizedSrc;
  }
  const localSrc = decodeLinkPath(normalizedSrc);
  if (localSrc.startsWith("/")) return localSrc;
  return `${markdownDir.replace(/\/$/, "")}/${localSrc}`;
}