#!/usr/bin/env python3
"""Update products.json entries from discovered issue data files."""

from __future__ import annotations

import argparse
import json
import re
from pathlib import Path
from typing import Any


ISSUE_TYPES = {"addressed", "known"}
VERSION_FILENAME_RE = re.compile(r"^(?P<version>[^.]+(?:\.[^.]+)*)\.md$")
HOTFIX_RE = re.compile(r"^(?P<base>\d+(?:\.\d+)*)(?:-h(?P<hotfix>\d+))?$")


def parse_args() -> argparse.Namespace:
    """Parse command line arguments for input and output paths."""

    parser = argparse.ArgumentParser(
        description="Update products.json from issue files."
    )
    parser.add_argument(
        "--issues-dir",
        default="web/data/issues",
        help="Directory containing product issue files.",
    )
    parser.add_argument(
        "--products-json",
        default="web/data/products.json",
        help="Path to products.json.",
    )
    return parser.parse_args()


def collect_issue_files(issues_dir: Path) -> list[tuple[str, str, str, str]]:
    """Collect all issue files with '<version>.md' naming."""

    records: list[tuple[str, str, str, str]] = []

    for file_path in sorted(p for p in issues_dir.rglob("*") if p.is_file()):
        relative = file_path.relative_to(issues_dir)
        if len(relative.parts) != 3:
            continue

        product, issue_type, filename = relative.parts
        if issue_type not in ISSUE_TYPES:
            continue

        version = parse_issue_filename(filename)
        if version is None:
            continue

        records.append((product, issue_type, version, filename))

    return records


def parse_issue_filename(filename: str) -> str | None:
    """Parse '<version>.md' issue filenames and return version."""

    match = VERSION_FILENAME_RE.match(filename)
    if not match:
        return None

    return match.group("version")


def clear_leaf_issue_arrays(node: Any) -> None:
    """Reset addressed/known arrays on every issue leaf in products.json."""

    if isinstance(node, dict):
        if "addressed" in node or "known" in node:
            node["addressed"] = []
            node["known"] = []
            return

        for value in node.values():
            clear_leaf_issue_arrays(value)


def is_issue_leaf(node: Any) -> bool:
    """Return whether a node is a leaf containing issue arrays."""

    return isinstance(node, dict) and ("addressed" in node or "known" in node)


def pick_target_leaf_path(products: dict[str, Any], product: str, version: str) -> list[str] | None:
    """Choose the best matching product tree path for a version."""

    parts = version.split(".")
    if not parts:
        return None

    major = parts[0]
    minor = f"{parts[0]}.{parts[1]}" if len(parts) > 1 else parts[0]

    candidates = [
        [product, major, minor],
        [product, major],
        [product],
    ]

    for path in candidates:
        node = get_path(products, path)
        if is_issue_leaf(node):
            return path

    return None


def get_path(data: Any, path: list[str]) -> Any:
    """Traverse nested dict keys and return the value at path, if present."""

    current = data
    for key in path:
        if not isinstance(current, dict) or key not in current:
            return None
        current = current[key]
    return current


def parse_release_prefix(prefix: str) -> tuple[tuple[int, ...], int]:
    """Extract numeric base version parts and optional hotfix number."""

    match = HOTFIX_RE.match(prefix)
    if not match:
        return tuple(), -1

    base_parts = tuple(int(part) for part in match.group("base").split("."))
    hotfix_group = match.group("hotfix")
    hotfix = int(hotfix_group) if hotfix_group is not None else -1
    return base_parts, hotfix


def filename_sort_key(filename: str) -> tuple[tuple[int, ...], int, int, str]:
    """Build a sort key that orders base versions before hotfixes."""

    prefix = filename.rsplit(".", 1)[0]
    base_parts, hotfix = parse_release_prefix(prefix)
    is_hotfix = 1 if hotfix >= 0 else 0
    return base_parts, is_hotfix, hotfix, filename


def add_file_to_leaf(
    products: dict[str, Any],
    path: list[str],
    issue_type: str,
    filename: str,
) -> None:
    """Insert an issue filename into the target leaf with stable sorting."""

    leaf = get_path(products, path)
    if not isinstance(leaf, dict):
        return

    files = leaf.get(issue_type)
    if not isinstance(files, list):
        files = []

    files.append(filename)
    leaf[issue_type] = sorted(set(files), key=filename_sort_key)


def update_products(issues_dir: Path, products_path: Path) -> None:
    """Rebuild product issue file lists from crawled issue files."""

    if not issues_dir.is_dir():
        raise FileNotFoundError(f"Issues directory not found: {issues_dir}")
    if not products_path.is_file():
        raise FileNotFoundError(f"products.json not found: {products_path}")

    with products_path.open("r", encoding="utf-8") as f:
        products = json.load(f)

    if not isinstance(products, dict):
        raise ValueError("products.json must contain a top-level object")

    records = collect_issue_files(issues_dir)
    if not records:
        raise ValueError(
            "No '<version>.md' issue files found; refusing to rewrite products.json"
        )

    clear_leaf_issue_arrays(products)

    for product, issue_type, version, filename in sorted(
        records,
        key=lambda r: (r[0], r[1], r[2]),
    ):
        path = pick_target_leaf_path(products, product, version)
        if path is None:
            continue
        add_file_to_leaf(products, path, issue_type, filename)

    with products_path.open("w", encoding="utf-8") as f:
        json.dump(products, f, indent=2)
        f.write("\n")


def main() -> int:
    """Entrypoint for command-line usage."""

    args = parse_args()
    script_dir = Path(__file__).resolve().parent
    repo_root = script_dir.parent
    issues_dir = (repo_root / args.issues_dir).resolve()
    products_path = (repo_root / args.products_json).resolve()

    update_products(issues_dir=issues_dir, products_path=products_path)
    print(f"Updated {products_path} from {issues_dir}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())