export async function validateStory(
  rootInput: string,
  documentInput: string,
): Promise<ResolvedStoryDocument> {
  const root = resolve(rootInput);
  const { documentAbsolute, documentPath } = repositoryStoryPath(
    root,
    documentInput,
  );
  const document = parseStoryDocument(
    await readFile(documentAbsolute, "utf8"),
    documentPath,
  );
  const source = await repositoryState(root);
  const snapshot = await captureSourceSnapshot(
    root,
    document.anchors.map((anchor) => anchor.path),
  );
  const resolved = await resolveStoryDocument(
    root,
    document,
    documentPath,
    { revision: source.revision, dirty: source.dirty },
    async (path) => snapshot.get(path),
  );
  await assertSourceSnapshot(root, snapshot);
  const finalSource = await repositoryState(root);
  if (
    finalSource.revision !== source.revision ||
    finalSource.dirty !== source.dirty ||
    finalSource.fingerprint !== source.fingerprint
  ) {
    throw new Error(
      `${documentPath}: repository changed while validating; retry`,
    );
  }
  return resolved;
}

export async function captureSourceSnapshot(
  rootInput: string,
  paths: Iterable<string>,
): Promise<SourceSnapshot> {
  const root = await realpath(rootInput);
  const unique = [...new Set(paths)].sort();
  return new Map(await Promise.all(unique.map(async (path) => [
    path,
    await readStableSource(root, path),
  ] as const)));
}

export async function captureSourceSnapshot(
  rootInput: string,
  paths: Iterable<string>,
): Promise<SourceSnapshot> {
  const root = await realpath(rootInput);
  const unique = [...new Set(paths)].sort();
  return new Map(await Promise.all(unique.map(async (path) => [
    path,
    await readStableSource(root, path),
  ] as const)));
}

async function readStableSource(
  root: string,
  repositoryPath: string,
): Promise<string | undefined> {
  const requested = resolve(root, repositoryPath);
  const rel = relative(root, requested);
  if (
    isAbsolute(repositoryPath) ||
    rel === ".." ||
    rel.startsWith(`..${sep}`) ||
    isAbsolute(rel)
  ) {
    throw new Error(`Source path escapes the repository: ${repositoryPath}`);
  }
  let actual: string;
  try {
    actual = await realpath(requested);
  } catch (error) {
    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
      return undefined;
    }
    throw error;
  }
  if (actual !== requested) {
    throw new Error(`Source path must not resolve through a symlink: ${repositoryPath}`);
  }
  const initial = await stat(requested);
  if (!initial.isFile()) {
    throw new Error(`Source path must be a regular file: ${repositoryPath}`);
  }
  const handle = await open(
    requested,
    constants.O_RDONLY | constants.O_NOFOLLOW,
  );
  try {
    const opened = await handle.stat();
    if (
      !opened.isFile() ||
      opened.dev !== initial.dev ||
      opened.ino !== initial.ino
    ) {
      throw new Error(`Source changed before it was read: ${repositoryPath}`);
    }
    const contents = await handle.readFile("utf8");
    const openedAfter = await handle.stat();
    const currentActual = await realpath(requested);
    const current = await stat(requested);
    if (
      currentActual !== requested ||
      !current.isFile() ||
      current.dev !== opened.dev ||
      current.ino !== opened.ino ||
      openedAfter.size !== opened.size ||
      openedAfter.mtimeMs !== opened.mtimeMs ||
      openedAfter.ctimeMs !== opened.ctimeMs
    ) {
      throw new Error(`Source changed while it was read: ${repositoryPath}`);
    }
    return contents;
  } finally {
    await handle.close();
  }
}

export async function validateStory(
  rootInput: string,
  documentInput: string,
): Promise<ResolvedStoryDocument> {
  const root = resolve(rootInput);
  const { documentAbsolute, documentPath } = repositoryStoryPath(
    root,
    documentInput,
  );
  const document = parseStoryDocument(
    await readFile(documentAbsolute, "utf8"),
    documentPath,
  );
  const source = await repositoryState(root);
  const snapshot = await captureSourceSnapshot(
    root,
    document.anchors.map((anchor) => anchor.path),
  );
  const resolved = await resolveStoryDocument(
    root,
    document,
    documentPath,
    { revision: source.revision, dirty: source.dirty },
    async (path) => snapshot.get(path),
  );
  await assertSourceSnapshot(root, snapshot);
  const finalSource = await repositoryState(root);
  if (
    finalSource.revision !== source.revision ||
    finalSource.dirty !== source.dirty ||
    finalSource.fingerprint !== source.fingerprint
  ) {
    throw new Error(
      `${documentPath}: repository changed while validating; retry`,
    );
  }
  return resolved;
}

export async function resolveStoryDocument(
  root: string,
  document: StoryDocument,
  documentPath: string,
  source: { revision: string; dirty: boolean },
  loadSource?: (path: string) => Promise<string | undefined>,
): Promise<ResolvedStoryDocument> {
  const repositoryRoot =
    loadSource === undefined ? await realpath(root) : resolve(root);
  const anchors: ResolvedSourceAnchor[] = [];
  for (const anchor of document.anchors) {
    assertRepositoryPath(root, documentPath, anchor);
    const contents = loadSource === undefined
      ? await readRepositorySource(repositoryRoot, documentPath, anchor)
      : await loadSource(anchor.path);
    if (contents === undefined) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-file",
        `source file "${anchor.path}" does not exist`,
      );
    }
    anchors.push(await resolveAnchor(documentPath, anchor, contents));
  }
  return { document, documentPath, repositoryRoot, source, anchors };
}

export async function validateStory(
  rootInput: string,
  documentInput: string,
): Promise<ResolvedStoryDocument> {
  const root = resolve(rootInput);
  const { documentAbsolute, documentPath } = repositoryStoryPath(
    root,
    documentInput,
  );
  const document = parseStoryDocument(
    await readFile(documentAbsolute, "utf8"),
    documentPath,
  );
  const source = await repositoryState(root);
  const snapshot = await captureSourceSnapshot(
    root,
    document.anchors.map((anchor) => anchor.path),
  );
  const resolved = await resolveStoryDocument(
    root,
    document,
    documentPath,
    { revision: source.revision, dirty: source.dirty },
    async (path) => snapshot.get(path),
  );
  await assertSourceSnapshot(root, snapshot);
  const finalSource = await repositoryState(root);
  if (
    finalSource.revision !== source.revision ||
    finalSource.dirty !== source.dirty ||
    finalSource.fingerprint !== source.fingerprint
  ) {
    throw new Error(
      `${documentPath}: repository changed while validating; retry`,
    );
  }
  return resolved;
}

export async function resolveStoryDocument(
  root: string,
  document: StoryDocument,
  documentPath: string,
  source: { revision: string; dirty: boolean },
  loadSource?: (path: string) => Promise<string | undefined>,
): Promise<ResolvedStoryDocument> {
  const repositoryRoot =
    loadSource === undefined ? await realpath(root) : resolve(root);
  const anchors: ResolvedSourceAnchor[] = [];
  for (const anchor of document.anchors) {
    assertRepositoryPath(root, documentPath, anchor);
    const contents = loadSource === undefined
      ? await readRepositorySource(repositoryRoot, documentPath, anchor)
      : await loadSource(anchor.path);
    if (contents === undefined) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-file",
        `source file "${anchor.path}" does not exist`,
      );
    }
    anchors.push(await resolveAnchor(documentPath, anchor, contents));
  }
  return { document, documentPath, repositoryRoot, source, anchors };
}

export async function resolveStoryDocument(
  root: string,
  document: StoryDocument,
  documentPath: string,
  source: { revision: string; dirty: boolean },
  loadSource?: (path: string) => Promise<string | undefined>,
): Promise<ResolvedStoryDocument> {
  const repositoryRoot =
    loadSource === undefined ? await realpath(root) : resolve(root);
  const anchors: ResolvedSourceAnchor[] = [];
  for (const anchor of document.anchors) {
    assertRepositoryPath(root, documentPath, anchor);
    const contents = loadSource === undefined
      ? await readRepositorySource(repositoryRoot, documentPath, anchor)
      : await loadSource(anchor.path);
    if (contents === undefined) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-file",
        `source file "${anchor.path}" does not exist`,
      );
    }
    anchors.push(await resolveAnchor(documentPath, anchor, contents));
  }
  return { document, documentPath, repositoryRoot, source, anchors };
}

async function resolveAnchor(
  documentPath: string,
  anchor: SourceAnchor,
  contents: string,
): Promise<ResolvedSourceAnchor> {
  if (anchor.sha256 !== undefined && createHash("sha256").update(contents).digest("hex") !== anchor.sha256) {
    throw anchorError(documentPath, anchor.id, "stale-source", `source "${anchor.path}" changed; inspect the change and deliberately update its digest, preserving anchor identity`);
  }
  const sourceFile = ts.createSourceFile(
    anchor.path,
    contents,
    ts.ScriptTarget.Latest,
    true,
  );
  let start = 0;
  let end = contents.length;
  if (anchor.symbol !== undefined) {
    const language = anchor.language ?? (anchor.path.endsWith(".rs") ? "rust" : "typescript");
    if (language === "text") throw anchorError(documentPath, anchor.id, "unsupported-symbol", "text anchors support exact patterns, not compiler symbols");
    const rust = language === "rust" ? await resolveRustSymbol(anchor.path, contents, anchor.symbol) : undefined;
    const symbol = rust === undefined ? findSymbolRange(sourceFile, anchor.symbol) : {
      start: sourceFile.getPositionOfLineAndCharacter(rust.startLine - 1, rust.startColumn - 1),
      end: sourceFile.getPositionOfLineAndCharacter(rust.endLine - 1, rust.endColumn - 1),
    };
    if (symbol === undefined) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-symbol",
        `symbol "${anchor.symbol}" was not found in "${anchor.path}"`,
      );
    }
    start = symbol.start;
    end = symbol.end;
  }
  if (anchor.pattern !== undefined) {
    const scope = contents.slice(start, end);
    const offset = scope.indexOf(anchor.pattern);
    if (offset < 0) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-pattern",
        anchor.symbol === undefined
          ? `pattern "${anchor.pattern}" was not found in "${anchor.path}"`
          : `pattern "${anchor.pattern}" was not found within symbol "${anchor.symbol}" in "${anchor.path}"`,
      );
    }
    if (
      anchor.symbol === undefined &&
      scope.indexOf(anchor.pattern, offset + 1) >= 0
    ) {
      throw anchorError(
        documentPath,
        anchor.id,
        "ambiguous-pattern",
        `pattern "${anchor.pattern}" occurs more than once in "${anchor.path}"`,
      );
    }
    start += offset;
    end = start + anchor.pattern.length;
  }
  const startLine = sourceFile.getLineAndCharacterOfPosition(start).line + 1;
  const endLine = sourceFile.getLineAndCharacterOfPosition(
    Math.max(start, end - 1),
  ).line + 1;
  return {
    ...anchor,
    location: { startLine, endLine },
    excerpt: contents.slice(start, end),
  };
}

function findSymbolRange(
  sourceFile: ts.SourceFile,
  symbol: string,
): { start: number; end: number } | undefined {
  let result: ts.Node | undefined;
  const visit = (node: ts.Node): void => {
    if (result !== undefined) return;
    if (declarationName(node) === symbol) {
      result = node;
      return;
    }
    ts.forEachChild(node, visit);
  };
  visit(sourceFile);
  return result === undefined
    ? undefined
    : {
      start: result.getStart(sourceFile),
      end: result.getEnd(),
    };
}

export async function resolveRustSymbol(path: string, contents: string, symbol: string): Promise<SourceLocation> {
  const contribution = await rustContribution({ root: "", files: [{ path, contents, sha256: hash(contents) }] });
  const candidates = contribution.entities.filter((entity) => entity.name === symbol || entity.qualifiedName === symbol);
  if (candidates.length !== 1) throw new Error(`Rust symbol "${symbol}" in "${path}" is ${candidates.length ? "ambiguous; use a lexical qualifiedName" : "missing"}`);
  if (contribution.unresolved.some((item) => item.kind === "syntax-error")) throw new Error(`Rust source "${path}" has parser recovery; use an exact pattern after repairing it`);
  return candidates[0]!.location;
}

async function resolveAnchor(
  documentPath: string,
  anchor: SourceAnchor,
  contents: string,
): Promise<ResolvedSourceAnchor> {
  if (anchor.sha256 !== undefined && createHash("sha256").update(contents).digest("hex") !== anchor.sha256) {
    throw anchorError(documentPath, anchor.id, "stale-source", `source "${anchor.path}" changed; inspect the change and deliberately update its digest, preserving anchor identity`);
  }
  const sourceFile = ts.createSourceFile(
    anchor.path,
    contents,
    ts.ScriptTarget.Latest,
    true,
  );
  let start = 0;
  let end = contents.length;
  if (anchor.symbol !== undefined) {
    const language = anchor.language ?? (anchor.path.endsWith(".rs") ? "rust" : "typescript");
    if (language === "text") throw anchorError(documentPath, anchor.id, "unsupported-symbol", "text anchors support exact patterns, not compiler symbols");
    const rust = language === "rust" ? await resolveRustSymbol(anchor.path, contents, anchor.symbol) : undefined;
    const symbol = rust === undefined ? findSymbolRange(sourceFile, anchor.symbol) : {
      start: sourceFile.getPositionOfLineAndCharacter(rust.startLine - 1, rust.startColumn - 1),
      end: sourceFile.getPositionOfLineAndCharacter(rust.endLine - 1, rust.endColumn - 1),
    };
    if (symbol === undefined) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-symbol",
        `symbol "${anchor.symbol}" was not found in "${anchor.path}"`,
      );
    }
    start = symbol.start;
    end = symbol.end;
  }
  if (anchor.pattern !== undefined) {
    const scope = contents.slice(start, end);
    const offset = scope.indexOf(anchor.pattern);
    if (offset < 0) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-pattern",
        anchor.symbol === undefined
          ? `pattern "${anchor.pattern}" was not found in "${anchor.path}"`
          : `pattern "${anchor.pattern}" was not found within symbol "${anchor.symbol}" in "${anchor.path}"`,
      );
    }
    if (
      anchor.symbol === undefined &&
      scope.indexOf(anchor.pattern, offset + 1) >= 0
    ) {
      throw anchorError(
        documentPath,
        anchor.id,
        "ambiguous-pattern",
        `pattern "${anchor.pattern}" occurs more than once in "${anchor.path}"`,
      );
    }
    start += offset;
    end = start + anchor.pattern.length;
  }
  const startLine = sourceFile.getLineAndCharacterOfPosition(start).line + 1;
  const endLine = sourceFile.getLineAndCharacterOfPosition(
    Math.max(start, end - 1),
  ).line + 1;
  return {
    ...anchor,
    location: { startLine, endLine },
    excerpt: contents.slice(start, end),
  };
}

function findSymbolRange(
  sourceFile: ts.SourceFile,
  symbol: string,
): { start: number; end: number } | undefined {
  let result: ts.Node | undefined;
  const visit = (node: ts.Node): void => {
    if (result !== undefined) return;
    if (declarationName(node) === symbol) {
      result = node;
      return;
    }
    ts.forEachChild(node, visit);
  };
  visit(sourceFile);
  return result === undefined
    ? undefined
    : {
      start: result.getStart(sourceFile),
      end: result.getEnd(),
    };
}

export async function resolveRustSymbol(path: string, contents: string, symbol: string): Promise<SourceLocation> {
  const contribution = await rustContribution({ root: "", files: [{ path, contents, sha256: hash(contents) }] });
  const candidates = contribution.entities.filter((entity) => entity.name === symbol || entity.qualifiedName === symbol);
  if (candidates.length !== 1) throw new Error(`Rust symbol "${symbol}" in "${path}" is ${candidates.length ? "ambiguous; use a lexical qualifiedName" : "missing"}`);
  if (contribution.unresolved.some((item) => item.kind === "syntax-error")) throw new Error(`Rust source "${path}" has parser recovery; use an exact pattern after repairing it`);
  return candidates[0]!.location;
}

export async function resolveStoryDocument(
  root: string,
  document: StoryDocument,
  documentPath: string,
  source: { revision: string; dirty: boolean },
  loadSource?: (path: string) => Promise<string | undefined>,
): Promise<ResolvedStoryDocument> {
  const repositoryRoot =
    loadSource === undefined ? await realpath(root) : resolve(root);
  const anchors: ResolvedSourceAnchor[] = [];
  for (const anchor of document.anchors) {
    assertRepositoryPath(root, documentPath, anchor);
    const contents = loadSource === undefined
      ? await readRepositorySource(repositoryRoot, documentPath, anchor)
      : await loadSource(anchor.path);
    if (contents === undefined) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-file",
        `source file "${anchor.path}" does not exist`,
      );
    }
    anchors.push(await resolveAnchor(documentPath, anchor, contents));
  }
  return { document, documentPath, repositoryRoot, source, anchors };
}

async function resolveAnchor(
  documentPath: string,
  anchor: SourceAnchor,
  contents: string,
): Promise<ResolvedSourceAnchor> {
  if (anchor.sha256 !== undefined && createHash("sha256").update(contents).digest("hex") !== anchor.sha256) {
    throw anchorError(documentPath, anchor.id, "stale-source", `source "${anchor.path}" changed; inspect the change and deliberately update its digest, preserving anchor identity`);
  }
  const sourceFile = ts.createSourceFile(
    anchor.path,
    contents,
    ts.ScriptTarget.Latest,
    true,
  );
  let start = 0;
  let end = contents.length;
  if (anchor.symbol !== undefined) {
    const language = anchor.language ?? (anchor.path.endsWith(".rs") ? "rust" : "typescript");
    if (language === "text") throw anchorError(documentPath, anchor.id, "unsupported-symbol", "text anchors support exact patterns, not compiler symbols");
    const rust = language === "rust" ? await resolveRustSymbol(anchor.path, contents, anchor.symbol) : undefined;
    const symbol = rust === undefined ? findSymbolRange(sourceFile, anchor.symbol) : {
      start: sourceFile.getPositionOfLineAndCharacter(rust.startLine - 1, rust.startColumn - 1),
      end: sourceFile.getPositionOfLineAndCharacter(rust.endLine - 1, rust.endColumn - 1),
    };
    if (symbol === undefined) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-symbol",
        `symbol "${anchor.symbol}" was not found in "${anchor.path}"`,
      );
    }
    start = symbol.start;
    end = symbol.end;
  }
  if (anchor.pattern !== undefined) {
    const scope = contents.slice(start, end);
    const offset = scope.indexOf(anchor.pattern);
    if (offset < 0) {
      throw anchorError(
        documentPath,
        anchor.id,
        "missing-pattern",
        anchor.symbol === undefined
          ? `pattern "${anchor.pattern}" was not found in "${anchor.path}"`
          : `pattern "${anchor.pattern}" was not found within symbol "${anchor.symbol}" in "${anchor.path}"`,
      );
    }
    if (
      anchor.symbol === undefined &&
      scope.indexOf(anchor.pattern, offset + 1) >= 0
    ) {
      throw anchorError(
        documentPath,
        anchor.id,
        "ambiguous-pattern",
        `pattern "${anchor.pattern}" occurs more than once in "${anchor.path}"`,
      );
    }
    start += offset;
    end = start + anchor.pattern.length;
  }
  const startLine = sourceFile.getLineAndCharacterOfPosition(start).line + 1;
  const endLine = sourceFile.getLineAndCharacterOfPosition(
    Math.max(start, end - 1),
  ).line + 1;
  return {
    ...anchor,
    location: { startLine, endLine },
    excerpt: contents.slice(start, end),
  };
}

export async function validateStory(
  rootInput: string,
  documentInput: string,
): Promise<ResolvedStoryDocument> {
  const root = resolve(rootInput);
  const { documentAbsolute, documentPath } = repositoryStoryPath(
    root,
    documentInput,
  );
  const document = parseStoryDocument(
    await readFile(documentAbsolute, "utf8"),
    documentPath,
  );
  const source = await repositoryState(root);
  const snapshot = await captureSourceSnapshot(
    root,
    document.anchors.map((anchor) => anchor.path),
  );
  const resolved = await resolveStoryDocument(
    root,
    document,
    documentPath,
    { revision: source.revision, dirty: source.dirty },
    async (path) => snapshot.get(path),
  );
  await assertSourceSnapshot(root, snapshot);
  const finalSource = await repositoryState(root);
  if (
    finalSource.revision !== source.revision ||
    finalSource.dirty !== source.dirty ||
    finalSource.fingerprint !== source.fingerprint
  ) {
    throw new Error(
      `${documentPath}: repository changed while validating; retry`,
    );
  }
  return resolved;
}

export async function assertSourceSnapshot(
  root: string,
  snapshot: SourceSnapshot,
): Promise<void> {
  const current = await captureSourceSnapshot(root, snapshot.keys());
  for (const [path, contents] of snapshot) {
    if (current.get(path) !== contents) {
      throw new Error(`Repository source changed while rendering: ${path}`);
    }
  }
}

export async function validateStory(
  rootInput: string,
  documentInput: string,
): Promise<ResolvedStoryDocument> {
  const root = resolve(rootInput);
  const { documentAbsolute, documentPath } = repositoryStoryPath(
    root,
    documentInput,
  );
  const document = parseStoryDocument(
    await readFile(documentAbsolute, "utf8"),
    documentPath,
  );
  const source = await repositoryState(root);
  const snapshot = await captureSourceSnapshot(
    root,
    document.anchors.map((anchor) => anchor.path),
  );
  const resolved = await resolveStoryDocument(
    root,
    document,
    documentPath,
    { revision: source.revision, dirty: source.dirty },
    async (path) => snapshot.get(path),
  );
  await assertSourceSnapshot(root, snapshot);
  const finalSource = await repositoryState(root);
  if (
    finalSource.revision !== source.revision ||
    finalSource.dirty !== source.dirty ||
    finalSource.fingerprint !== source.fingerprint
  ) {
    throw new Error(
      `${documentPath}: repository changed while validating; retry`,
    );
  }
  return resolved;
}

export async function assertSourceSnapshot(
  root: string,
  snapshot: SourceSnapshot,
): Promise<void> {
  const current = await captureSourceSnapshot(root, snapshot.keys());
  for (const [path, contents] of snapshot) {
    if (current.get(path) !== contents) {
      throw new Error(`Repository source changed while rendering: ${path}`);
    }
  }
}