// snapshot views: a commit's tree, one of its blobs, or its files of one
// language. only the tree is rendered at the tip: the static blob page is
// richer than what the client can make
import type { Commit, TreeEntry } from "./git/types.ts";
import { objectAt } from "./git/walk.ts";
import { detectLanguage, languageGroup } from "./languages.ts";
import { canonical, encodePath, isPageView, type Site, type View } from "./route.ts";
import { commitTime, humanSize, isImage, looksBinary, looksGenerated, plural, utf8 } from "./util.ts";

const TREE = 0o040000;
const SYMLINK = 0o120000;
const GITLINK = 0o160000;
const kindOf = (entry: TreeEntry) => entry.mode & 0o170000;

export async function kindAtTip(site: Site, path: string[]): Promise<"tree" | "blob" | null> {
  if (!site.page.tip) return null;
  if (path.length === 0) return "tree";
  const commit = await site.repo.commit(site.page.tip);
  const object = await objectAt(site.repo, commit.tree, path);
  if (!object) return null;
  const kind = object.mode & 0o170000;
  return kind === TREE ? "tree" : kind === GITLINK ? null : "blob";
}

export async function href(site: Site, view: View): Promise<string> {
  const needsTip = view.kind === "tree" || view.kind === "blob" || view.kind === "history";
  return canonical(site.page, view, needsTip ? await kindAtTip(site, view.path) : null);
}

async function entriesAt(site: Site, commit: Commit, path: string[]): Promise<TreeEntry[]> {
  const object = await objectAt(site.repo, commit.tree, path);
  if (!object || (object.mode & 0o170000) !== TREE) throw new Error(`${path.join("/")} is not a tree`);
  return site.repo.tree(object.oid);
}

/** `a/b/c` when `a` holds only `b`, which holds only `c`: a chain of lone
 * directories reads better as one link than as three clicks */
async function collapseLoneDirs(site: Site, entry: TreeEntry): Promise<string[]> {
  const names = [entry.name];
  let oid = entry.oid;
  for (;;) {
    const [only, ...rest] = await site.repo.tree(oid);
    if (rest.length > 0 || !only || kindOf(only) !== TREE) return names;
    names.push(only.name);
    oid = only.oid;
  }
}

/** the same shape as the static topbar. the ref switcher is baked into the
 * static page and only applies at the tip, so it is borrowed from there;
 * elsewhere the commit panel above says which commit this is */
export async function topbar(site: Site, view: View, stats: string[], actions: Node[] = []): Promise<HTMLElement> {
  const { name } = site;
  const { kind, oid, path } = view;
  const crumbs = (<nav class="crumbs" />) as HTMLElement;
  const isRoot = kind !== "language" && kind !== "commit" && path.length === 0;
  if (isRoot) crumbs.append(<span class="cur">{name}</span>);
  else crumbs.append(<a href={await href(site, { kind: "tree", oid, path: [] })}>{name}</a>);
  if (kind === "language") crumbs.append(<span class="label">language:</span>, " ", <span class="cur">{path[0]}</span>);
  else if (kind === "commit") crumbs.append(<span class="label">commit:</span>, " ", <span class="cur">{oid.slice(0, 7)}</span>);
  else {
    for (let i = 0; i < path.length; i++) {
      crumbs.append(" / ");
      if (i < path.length - 1) {
        crumbs.append(<a href={await href(site, { kind: "tree", oid, path: path.slice(0, i + 1) })}>{path[i]}</a>);
      } else {
        crumbs.append(<span class="cur">{path[i]}</span>);
        if (kind === "tree") crumbs.append(" /");
      }
    }
  }

  if (kind === "tree" || kind === "blob") {
    actions.unshift(<a href={await href(site, { kind: "history", oid, path })}>history</a>);
  }
  const switcher = isPageView(site.page, view)
    ? document.querySelector("main > .topbar > .switcher")?.cloneNode(true) as HTMLElement | undefined
    : undefined;
  return (
    <header class="topbar">
      {switcher}
      {crumbs}
      <span class="view-stats">{stats.map(stat => <span>{stat}</span>)}</span>
      <span class="actions">{actions}</span>
    </header>
  ) as HTMLElement;
}

function commitPanel(commit: Commit): HTMLElement {
  return (
    <p class="snapshot-commit">
      <span class="commit-author">{commit.author.name}</span>
      <a class="commit-message" href={`#commit/${commit.oid}`}>{commit.message.split("\n")[0]}</a>
      <a class="snapshot-sha sha" href={`#commit/${commit.oid}`}>{commit.oid.slice(0, 7)}</a>
      {commitTime(commit.author)}
    </p>
  ) as HTMLElement;
}

export async function treeView(site: Site, view: View): Promise<Node[]> {
  const { oid, path } = view;
  await site.repo.prefetch([oid], { smart: "tree" });
  const commit = await site.repo.commit(oid);
  const entries = await entriesAt(site, commit, path);
  // directories first, then byte order, as git and the static pages
  entries.sort((a, b) => Number(kindOf(a) !== TREE) - Number(kindOf(b) !== TREE) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
  const folders = entries.filter(entry => kindOf(entry) === TREE).length;
  const files = entries.length - folders;
  const stats = [folders ? plural(folders, "folder") : "", files ? plural(files, "file") : ""].filter(Boolean);
  const rows = await Promise.all(entries.map(async entry => {
    const kind = kindOf(entry);
    if (kind === GITLINK) return { name: `${entry.name} @ ${entry.oid.slice(0, 7)}` };
    const names = kind === TREE ? await collapseLoneDirs(site, entry) : [entry.name];
    const name = names.join("/") + (kind === TREE ? "/" : kind === SYMLINK ? "@" : "");
    return { name, href: await href(site, { kind: kind === TREE ? "tree" : "blob", oid, path: [...path, ...names] }) };
  }));
  return [
    commitPanel(commit),
    await topbar(site, view, stats),
    <h2 class="file-heading">files</h2>,
    listing(rows),
  ];
}

function listing(rows: Array<{ name: string; href?: string }>): HTMLTableElement {
  const table = (<table class="list" />) as HTMLTableElement;
  for (const { name, href } of rows) {
    table.append(<tr><td>{href ? <a href={href}>{name}</a> : name}</td></tr>);
  }
  return table;
}

/** every file at the commit classified as `language`, flat: a filtered tree
 * would need the filter carried through every directory link */
export async function languageView(site: Site, view: View): Promise<Node[]> {
  const { oid, path: [language] } = view;
  await site.repo.prefetch([oid], { smart: "tree" });
  const commit = await site.repo.commit(oid);
  const paths: string[][] = [];
  // the smart tree bundle caps at 128 objects, so load further
  // levels' subtrees in batches rather than one at a time
  let level = [{ oid: commit.tree, prefix: [] as string[] }];
  while (level.length > 0) {
    await site.repo.prefetch(level.map(tree => tree.oid), { depth: 0 });
    const next: typeof level = [];
    for (const { oid: tree, prefix } of level) {
      for (const entry of await site.repo.tree(tree)) {
        const path = [...prefix, entry.name];
        const kind = kindOf(entry);
        if (kind === TREE) {
          // trailing slash so the directory is tested as a parent, not a file
          if (!looksGenerated(`${path.join("/")}/`)) next.push({ oid: entry.oid, prefix: path });
        } else if (kind !== SYMLINK && kind !== GITLINK && !looksGenerated(path.join("/"))) {
          const grammar = detectLanguage(entry.name);
          if (grammar && languageGroup(grammar) === language) paths.push(path);
        }
      }
    }
    level = next;
  }
  paths.sort((a, b) => (a.join("/") < b.join("/") ? -1 : 1));
  const rows = await Promise.all(paths.map(async path => ({
    name: path.join("/"),
    href: await href(site, { kind: "blob", oid, path }),
  })));
  return [
    commitPanel(commit),
    await topbar(site, view, [plural(paths.length, "file")]),
    <h2 class="file-heading">files</h2>,
    listing(rows),
  ];
}

export async function blobView(site: Site, view: View): Promise<Node[]> {
  const { oid, path } = view;
  if (path.length === 0) throw new Error("blob path is empty");
  const commit = await site.repo.commit(oid);
  const object = await objectAt(site.repo, commit.tree, path);
  if (!object || (object.mode & 0o170000) === TREE || (object.mode & 0o170000) === GITLINK) {
    throw new Error(`${path.join("/")} is not a blob`);
  }
  const data = await site.repo.blob(object.oid);
  const rawURL = `${site.page.base}/raw/${object.oid}/${encodePath(path)}`;
  const raw = <a class="raw" href={rawURL}>raw</a>;
  const symlink = (object.mode & 0o170000) === SYMLINK;
  const image = !symlink && isImage(path.at(-1)!);
  const renderable = !symlink && !image && !looksBinary(data) && data.length <= 1 << 20;
  const text = renderable ? utf8.decode(data) : "";
  const lines = text.split("\n");
  if (lines.at(-1) === "") lines.pop();
  const stats = symlink
    ? [`symlink → ${utf8.decode(data)}`]
    : renderable
    ? [humanSize(data.length), plural(lines.length, "line")]
    : [image ? "image" : looksBinary(data) ? "binary file" : "large file", humanSize(data.length)];
  const head = [commitPanel(commit), await topbar(site, view, stats, [raw])];
  if (image) return [...head, <div class="image-preview"><img src={rawURL} alt={path.join("/")} /></div>];
  if (!renderable) return symlink ? head : [...head,
    <div class="file-download">
      <p>This file cannot be previewed.</p>
      <a href={rawURL} download={path.at(-1)!}>download raw file</a>
    </div>,
  ];

  const source = (
    <pre class="code src">{lines.map((line, i) =>
      <span class="code-line">
        <span class="ln">{String(i + 1)}</span>
        <span class="code-text">{line}</span>
        {i < lines.length - 1 ? <span class="code-break">{"\n"}</span> : ""}
      </span>
    )}</pre>
  ) as HTMLPreElement;
  void import("./highlight.ts")
    .then(module => module.highlightedLines(path.join("/"), text))
    .then(highlighted => {
      if (highlighted === null) return;
      const targets = source.querySelectorAll(".code-text");
      for (const [i, line] of highlighted.entries()) targets[i]?.replaceChildren(...line);
    })
    .catch(err => console.warn("arborium:", err));
  return [...head, source];
}