#!/usr/bin/env python3
"""Generate software citations from repository installation manifests."""

from __future__ import annotations

import argparse
import json
import re
import shlex
import tomllib
from pathlib import Path
from urllib.parse import quote


ROOT = Path(__file__).resolve().parents[1]
OUTPUT = ROOT / "docs" / "software_citations.bib"
SKIP_DIRS = {
    ".git",
    ".lake",
    ".tmp",
    ".venv",
    "__pycache__",
    "_build",
    "build",
    "dist",
    "node_modules",
    "target",
    "venv",
}
REQUIREMENT_NAME = re.compile(r"^\s*([A-Za-z0-9][A-Za-z0-9._-]*)(?:\[[^]]+\])?")
PACKAGE_TOKEN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9+_.:-]*$")


def manifest_paths(pattern: str) -> list[Path]:
    paths = [
        path
        for path in ROOT.rglob(pattern)
        if path.is_file() and not any(part in SKIP_DIRS for part in path.parts)
    ]
    return sorted(paths, key=lambda path: path.relative_to(ROOT).as_posix())


def relative(path: Path) -> str:
    return path.relative_to(ROOT).as_posix()


def shell_words(value: str) -> list[str]:
    value = value.rstrip().removesuffix("\\")
    try:
        return shlex.split(value)
    except ValueError:
        return value.replace("\\", " ").split()


def canonical_name(ecosystem: str, name: str) -> str:
    if ecosystem == "python":
        return re.sub(r"[-_.]+", "-", name).lower()
    return name.lower()


def citation_slug(ecosystem: str, name: str) -> str:
    value = name.lower()
    if ecosystem == "node" and value.startswith("@"):
        value = "at-" + value[1:].replace("/", "--")
    return re.sub(r"[^a-z0-9]+", "-", value).strip("-")


class Catalog:
    def __init__(self) -> None:
        self.records: dict[tuple[str, str], dict[str, set[str] | str]] = {}
        self.keys: dict[str, tuple[str, str]] = {}

    def add(
        self,
        ecosystem: str,
        name: str,
        source: str,
        constraint: str = "unversioned",
        url: str = "",
        source_kind: str = "manifest declaration",
    ) -> None:
        if not name.strip():
            return
        if not isinstance(constraint, str):
            constraint = json.dumps(constraint, sort_keys=True)
        if not isinstance(url, str):
            url = json.dumps(url, sort_keys=True)
        canonical = canonical_name(ecosystem, name.strip())
        identity = (ecosystem, canonical)
        record = self.records.setdefault(
            identity,
            {
                "display": name.strip(),
                "sources": set(),
                "constraints": set(),
                "urls": set(),
                "kinds": set(),
            },
        )
        record["sources"].add(source)  # type: ignore[union-attr]
        record["constraints"].add(constraint or "unversioned")  # type: ignore[union-attr]
        record["kinds"].add(source_kind)  # type: ignore[union-attr]
        if url:
            record["urls"].add(url)  # type: ignore[union-attr]

    def key(self, ecosystem: str, name: str) -> str:
        slug = citation_slug(ecosystem, name)
        key = f"software-{ecosystem}-{slug}"
        identity = (ecosystem, canonical_name(ecosystem, name))
        previous = self.keys.get(key)
        if previous is not None and previous != identity:
            suffix = re.sub(r"[^a-z0-9]", "", identity[1])[-8:]
            key = f"{key}-{suffix}"
        self.keys[key] = identity
        return key

    def render(self, sorted_order: bool = False) -> str:
        blocks = [
            "% Generated by tools/generate_software_citations.py.",
            "% Constraints are manifest declarations, not resolved lockfile versions.",
        ]
        records = sorted(self.records.items()) if sorted_order else self.records.items()
        for (ecosystem, canonical), record in records:
            key = self.key(ecosystem, canonical)
            display = str(record["display"])
            sources = sorted(record["sources"])  # type: ignore[arg-type]
            constraints = sorted(record["constraints"])  # type: ignore[arg-type]
            kinds = sorted(record["kinds"])  # type: ignore[arg-type]
            urls = sorted(record["urls"])  # type: ignore[arg-type]
            note_parts = [
                f"{', '.join(kinds)} in {', '.join(sources)}",
                f"declared constraints: {', '.join(constraints)}",
            ]
            has_local_metadata = any(
                "local project metadata" in kind or "local crate metadata" in kind or "local package metadata" in kind
                for kind in kinds
            )
            url = urls[0] if urls else ("" if has_local_metadata else registry_url(ecosystem, canonical))
            blocks.extend(
                [
                    "",
                    f"@misc{{{key},",
                    f"    title = {{{bib_escape(display)}}},",
                    f"    howpublished = {{{bib_escape(ecosystem_title(ecosystem))}}},",
                    f"    note = {{{bib_escape('; '.join(note_parts))}}},",
                ]
            )
            if url:
                blocks.append(f"    url = {{{bib_escape(url)}}},")
            blocks.extend(["}"])
        return "\n".join(blocks) + "\n"


def bib_escape(value: str) -> str:
    return value.replace("\\", r"\textbackslash{}").replace("{", r"\{").replace("}", r"\}")


def ecosystem_title(ecosystem: str) -> str:
    return {
        "lean": "Lean package or toolchain",
        "node": "Node.js package",
        "python": "Python distribution",
        "rust": "Rust crate or tool",
        "vscode": "Visual Studio Code extension",
        "apt": "Ubuntu 24.04 package",
    }.get(ecosystem, ecosystem)


def registry_url(ecosystem: str, name: str) -> str:
    if ecosystem == "python":
        return f"https://pypi.org/project/{quote(name, safe='-._')}/"
    if ecosystem == "rust":
        return f"https://crates.io/crates/{quote(name, safe='-._')}"
    if ecosystem == "node":
        return f"https://www.npmjs.com/package/{quote(name, safe='@/-._')}"
    if ecosystem == "ubuntu-apt":
        return f"https://packages.ubuntu.com/noble/{quote(name, safe='-+.')}"
    if ecosystem == "vscode":
        return f"https://marketplace.visualstudio.com/items?itemName={quote(name, safe='.-')}"
    if ecosystem == "runtime":
        return {
            "node.js": "https://nodejs.org/",
            "npm": "https://www.npmjs.com/",
            "elan": "https://github.com/leanprover/elan",
        }.get(name.lower(), "")
    if ecosystem == "browser":
        return {
            "chromium": "https://www.chromium.org/",
            "firefox": "https://www.mozilla.org/firefox/",
        }.get(name.lower(), "")
    return ""


def add_requirement(catalog: Catalog, line: str, source: str) -> None:
    line = re.sub(r"\s+#.*$", "", line).strip()
    if line.startswith("#"):
        return
    if not line or line.startswith(("-", "--")):
        return
    egg = re.search(r"#egg=([A-Za-z0-9._-]+)", line)
    match = REQUIREMENT_NAME.match(line)
    name = egg.group(1) if egg else (match.group(1) if match else "")
    if not name:
        return
    tail = line[match.end() :].strip() if match else ""
    if tail.startswith("@"):
        url = tail[1:].split(";", 1)[0].strip()
        constraint = "direct URL"
    else:
        url_match = re.search(r"https?://\S+", tail)
        url = url_match.group(0).rstrip(";,") if url_match else ""
        constraint = tail.split(";", 1)[0].strip() or "unversioned"
    catalog.add("python", name, source, constraint, url)


def add_python(catalog: Catalog) -> tuple[int, int]:
    projects = manifest_paths("pyproject.toml")
    requirements = manifest_paths("requirements*.txt")
    project_dirs: dict[Path, str] = {}
    for path in projects:
        data = tomllib.loads(path.read_text(encoding="utf-8"))
        project = data.get("project", {})
        poetry = data.get("tool", {}).get("poetry", {})
        name = project.get("name") or poetry.get("name")
        if name:
            version = project.get("version") or poetry.get("version") or "unversioned"
            project_dirs[path.parent.resolve()] = name
            homepage = project.get("urls", {}).get("Homepage", "")
            catalog.add("python", name, relative(path), version, homepage, "local project metadata")
        for requirement in data.get("build-system", {}).get("requires", []):
            add_requirement(catalog, requirement, relative(path))
        dependency_groups = [
            project.get("dependencies", []),
            *project.get("optional-dependencies", {}).values(),
            *data.get("dependency-groups", {}).values(),
        ]
        dependency_groups.extend(
            [
                [
                    f"{dependency} {constraint if isinstance(constraint, str) else ''}"
                    for dependency, constraint in poetry.get("dependencies", {}).items()
                    if dependency.lower() != "python"
                ]
            ]
        )
        dependency_groups.extend(
            group.get("dependencies", [])
            for group in poetry.get("group", {}).values()
            if isinstance(group, dict)
        )
        for group in dependency_groups:
            for requirement in group:
                if isinstance(requirement, str):
                    add_requirement(catalog, requirement, relative(path))
    for path in requirements:
        for raw_line in path.read_text(encoding="utf-8", errors="replace").splitlines():
            line = raw_line.strip()
            if line.startswith(("-e ", "--editable ")):
                local_path = line.split(maxsplit=1)[1].split("#", 1)[0]
                target = (path.parent / local_path).resolve()
                if target.is_file():
                    target = target.parent
                name = project_dirs.get(target)
                if name:
                    catalog.add("python", name, relative(path), "editable install", source_kind="editable install")
                continue
            add_requirement(catalog, raw_line, relative(path))
    return len(projects), len(requirements)


def dependency_tables(data: dict) -> list[dict]:
    tables = [
        data.get("dependencies", {}),
        data.get("dev-dependencies", {}),
        data.get("build-dependencies", {}),
        data.get("workspace", {}).get("dependencies", {}),
    ]
    for target in data.get("target", {}).values():
        if isinstance(target, dict):
            tables.extend(
                [
                    target.get("dependencies", {}),
                    target.get("dev-dependencies", {}),
                    target.get("build-dependencies", {}),
                ]
            )
    return tables


def add_rust(catalog: Catalog) -> int:
    manifests = manifest_paths("Cargo.toml")
    for path in manifests:
        data = tomllib.loads(path.read_text(encoding="utf-8"))
        package = data.get("package", {})
        if package.get("name"):
            repo_url = package.get("repository", "")
            version = package.get("version", "unversioned")
            rust_version = package.get("rust-version")
            if rust_version:
                version = f"package {version}; rust-version {rust_version}"
            catalog.add("rust", package["name"], relative(path), version, repo_url, "local crate metadata")
        for table in dependency_tables(data):
            for name, value in table.items():
                if name in {"workspace", "package"}:
                    continue
                if isinstance(value, dict):
                    constraint = value.get("version") or ("workspace-inherited" if value.get("workspace") else "unversioned")
                    url = value.get("git", "")
                    if value.get("path"):
                        local_target = (path.parent / value["path"]).as_posix()
                        constraint = f"{constraint}; local path {local_target}"
                else:
                    constraint = str(value)
                    url = ""
                catalog.add("rust", name, relative(path), str(constraint), url)
    return len(manifests)


def add_node(catalog: Catalog) -> int:
    manifests = manifest_paths("package.json")
    for path in manifests:
        data = json.loads(path.read_text(encoding="utf-8"))
        name = data.get("name")
        if name:
            catalog.add("node", name, relative(path), data.get("version", "unversioned"), source_kind="local package metadata")
        for group in ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies", "overrides"):
            for package, declaration in data.get(group, {}).items():
                if isinstance(declaration, dict):
                    declaration = declaration.get("version", "unversioned")
                catalog.add("node", package, relative(path), str(declaration), source_kind=f"{group} declaration")
    return len(manifests)


def add_apt(catalog: Catalog) -> int:
    path = ROOT / "Dockerfile.e2e"
    installing = False
    packages: set[str] = set()
    for raw_line in path.read_text(encoding="utf-8").splitlines():
        line = raw_line.split("#", 1)[0]
        if not line.strip():
            continue
        if not installing and "apt-get install" in line:
            installing = True
            line = line.split("apt-get install", 1)[1]
        if not installing:
            continue
        stops = "&&" in line
        line = line.split("&&", 1)[0].replace("\\", " ")
        for token in line.split():
            token = token.strip()
            if PACKAGE_TOKEN.fullmatch(token) and not token.startswith("-") and token not in {"y", "install"}:
                packages.add(token)
        if stops or "--no-install-recommends" in line or not raw_line.rstrip().endswith("\\"):
            installing = False
    for package in sorted(packages):
        catalog.add("ubuntu-apt", package, "Dockerfile.e2e", "Ubuntu 24.04 repository", source_kind="apt package install")
    catalog.add("python", "PyMuPDF", "Dockerfile.e2e", "==1.28.2", source_kind="pip install in /opt/pdf-tools")
    catalog.add("runtime", "Node.js", "Dockerfile.e2e", "22.x via NodeSource", source_kind="runtime install")
    catalog.add("runtime", "npm", "Dockerfile.e2e", "bundled with Node.js 22.x", source_kind="runtime install")
    catalog.add("runtime", "Elan", "Dockerfile.e2e", "installed with elan-init.sh", source_kind="Lean toolchain manager")
    catalog.add("lean", "Lean toolchain", "Dockerfile.e2e", "leanprover/lean4:v4.34.0-rc2", "https://lean-lang.org/", "container toolchain install")
    catalog.add("browser", "Chromium", "Dockerfile.e2e", "Playwright-managed; version follows installed Playwright", source_kind="browser install")
    catalog.add("browser", "Firefox", "Dockerfile.e2e", "Playwright-managed; version follows installed Playwright", source_kind="browser install")
    return len(packages)


def add_lean(catalog: Catalog) -> int:
    manifests = manifest_paths("lakefile.toml")
    for path in manifests:
        data = tomllib.loads(path.read_text(encoding="utf-8"))
        if data.get("name"):
            catalog.add("lean", data["name"], relative(path), data.get("version", "unversioned"), source_kind="Lake package")
        for requirement in data.get("require", []):
            name = requirement.get("name", "")
            git_source = requirement.get("git", "")
            local_path = requirement.get("path", "")
            constraint = requirement.get("rev") or requirement.get("version") or "unversioned"
            if local_path:
                constraint = f"{constraint}; local path {local_path}"
            catalog.add("lean", name, relative(path), str(constraint), git_source, "Lake dependency")
    for path in manifest_paths("lean-toolchain"):
        value = path.read_text(encoding="utf-8").strip()
        catalog.add("lean", "Lean toolchain", relative(path), value, "https://lean-lang.org/", "toolchain declaration")
    return len(manifests)


def add_devcontainer(catalog: Catalog) -> int:
    path = ROOT / ".devcontainer" / "devcontainer.json"
    text = path.read_text(encoding="utf-8")
    match = re.search(r'"extensions"\s*:\s*\[(.*?)\]', text, re.S)
    if not match:
        return 0
    extensions = re.findall(r'"([A-Za-z0-9_.-]+\.[A-Za-z0-9_.-]+)"', match.group(1))
    for extension in extensions:
        catalog.add("vscode", extension, relative(path), "unversioned", source_kind="devcontainer extension")
    return len(set(extensions))


def add_makefile_installs(catalog: Catalog) -> int:
    paths = manifest_paths("Makefile")
    installs = 0
    for path in paths:
        apt_continuation = False
        for raw_line in path.read_text(encoding="utf-8", errors="replace").splitlines():
            line = raw_line.strip()
            if not line or line.startswith("#"):
                continue
            apt_match = re.search(r"\bapt(?:-get)?\s+(?:-[^\s]+\s+)*install\b([^;&|]*)", line)
            if apt_match:
                apt_values = shell_words(apt_match.group(1))
                apt_continuation = line.endswith("\\")
            elif apt_continuation:
                apt_values = shell_words(line)
                apt_continuation = line.endswith("\\")
            else:
                apt_values = []
            for package in apt_values:
                package = package.rstrip("\\,")
                if PACKAGE_TOKEN.fullmatch(package) and "$" not in package:
                    catalog.add("ubuntu-apt", package, relative(path), "Ubuntu repository", source_kind="Makefile apt install")
            if apt_match:
                installs += 1
            cargo_match = re.search(r"\bcargo\s+install\b([^;&|]*)", line)
            if cargo_match:
                packages = [token for token in shell_words(cargo_match.group(1)) if not token.startswith("-")]
                for package in packages:
                    catalog.add("rust", package, relative(path), "cargo install", source_kind="Makefile tool install")
                installs += 1
            pip_match = re.search(r"\b(?:uv\s+)?pip\s+install\b([^;&|]*)", line)
            if pip_match:
                tokens = shell_words(pip_match.group(1))
                skip_next = False
                local_project = None
                for index, token in enumerate(tokens):
                    if skip_next:
                        if tokens[index - 1] == "--directory":
                            local_project = token
                        elif tokens[index - 1] in {"-e", "--editable"} and token not in {".", "./"}:
                            local_project = token
                        skip_next = False
                        continue
                    if token in {"--python", "--directory", "--group", "-r", "--requirement", "-e", "--editable"}:
                        skip_next = True
                    elif token.startswith("-") or token in {".", "./", "\\"}:
                        if token in {".", "./"}:
                            local_project = local_project or "."
                        continue
                    else:
                        add_requirement(catalog, token.rstrip("\\,"), relative(path))
                if local_project:
                    project_path = (path.parent / local_project).resolve()
                    project_file = project_path / "pyproject.toml"
                    if project_file.is_file():
                        project_data = tomllib.loads(project_file.read_text(encoding="utf-8"))
                        project_name = project_data.get("project", {}).get("name") or project_data.get("tool", {}).get("poetry", {}).get("name")
                        if project_name:
                            catalog.add("python", project_name, relative(path), "Makefile install", source_kind="Makefile local project install")
                    installs += 1
            for match in re.finditer(r"\brustup\s+toolchain\s+install\s+([^\s;&|]+)", line):
                catalog.add("rust", "rustup toolchain", relative(path), match.group(1), "https://rustup.rs/", "Makefile toolchain install")
                installs += 1
            for match in re.finditer(r"\brustup\s+component\s+add\s+([^\s;&|]+)", line):
                catalog.add("rust", match.group(1), relative(path), "rustup component", "https://doc.rust-lang.org/", "Makefile toolchain component")
                installs += 1
            if re.search(r"\b(?:npm\s+install|npx\s+playwright\s+install)\b", line):
                catalog.add("runtime", "npm", relative(path), "npm install", source_kind="Makefile tool install")
                installs += 1
    return installs


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--sorted",
        "--sort",
        dest="sorted_order",
        action="store_true",
        help="sort bibliography entries by ecosystem and package name instead of manifest traversal order",
    )
    args = parser.parse_args()

    catalog = Catalog()
    pyproject_count, requirements_count = add_python(catalog)
    cargo_count = add_rust(catalog)
    node_count = add_node(catalog)
    apt_count = add_apt(catalog)
    lake_count = add_lean(catalog)
    extension_count = add_devcontainer(catalog)
    makefile_installs = add_makefile_installs(catalog)
    OUTPUT.write_text(catalog.render(sorted_order=args.sorted_order), encoding="utf-8")
    print(
        f"Wrote {len(catalog.records)} software citations to {relative(OUTPUT)} "
        f"from {pyproject_count} pyproject.toml, {requirements_count} requirements files, "
        f"{cargo_count} Cargo.toml, {node_count} package.json, {lake_count} lakefile.toml, "
        f"{apt_count} apt packages, {extension_count} VS Code extensions, "
        f"and {makefile_installs} Makefile install declarations."
    )


if __name__ == "__main__":
    main()