#!/usr/bin/env python3

"""Render a compact Oak branch field map from local isolated clones.

The tool is intentionally read-only: it shells out to `oak status`, remote

branch listing, and local log only. It does not pull, switch, close, or merge.

Use fresh/disposable worker clones when the exact latest main log matters.

"""

from __future__ import annotations

import argparse

import json

import subprocess

from pathlib import Path

from typing import Any, Optional

def _run_json(repo: Path, command: list[str]) -> tuple[Optional[Any], Optional[str]]:

    try:

        proc = subprocess.run(

            command,

            cwd=repo,

            check=False,

            text=True,

            stdout=subprocess.PIPE,

            stderr=subprocess.PIPE,

        )

    except OSError as exc:

        return None, str(exc)

    if proc.returncode != 0:

        return None, (proc.stderr or proc.stdout or f"returncode={proc.returncode}")[-2000:]

    try:

        return json.loads(proc.stdout or "null"), None

    except json.JSONDecodeError as exc:

        return None, f"invalid_json:{exc}"

def _short_hash(value: Any) -> str:

    text = str(value or "")

    return text[:12] if text else ""

def _desc_line(value: Any) -> str:

    if not isinstance(value, str):

        return ""

    for line in value.splitlines():

        stripped = line.strip()

        if stripped:

            return stripped

    return ""

def inspect_repo(repo: Path) -> dict[str, Any]:

    repo = repo.resolve()

    status, status_error = _run_json(repo, ["oak", "status", "--json"])

    open_branches, branch_error = _run_json(

        repo, ["oak", "branch", "list", "--remote", "--status", "open", "--json"]

    )

    log, log_error = _run_json(repo, ["oak", "log", "-n", "8", "--json"])

    open_branch_rows = open_branches if isinstance(open_branches, list) else []

    log_rows = log if isinstance(log, list) else []

    non_main_open = [

        row for row in open_branch_rows

        if isinstance(row, dict) and row.get("name") != "main"

    ]

    main = next(

        (

            row for row in open_branch_rows

            if isinstance(row, dict) and row.get("name") == "main"

        ),

        None,

    )

    return {

        "path": str(repo),

        "label": repo.name,

        "status": status if isinstance(status, dict) else None,

        "status_error": status_error,

        "branch_error": branch_error,

        "log_error": log_error,

        "remote_main": main,

        "remote_open_branches": open_branch_rows,

        "remote_non_main_open_branches": non_main_open,

        "recent_log": log_rows,

    }

def inspect_repos(paths: list[Path]) -> list[dict[str, Any]]:

    return [inspect_repo(path) for path in paths]

def render_markdown(repos: list[dict[str, Any]]) -> str:

    lines = ["# Oak Field Map", ""]

    for repo in repos:

        status = repo.get("status") or {}

        remote_main = repo.get("remote_main") or {}

        non_main = repo.get("remote_non_main_open_branches") or []

        lines.append(f"## {repo['label']}")

        lines.append("")

        lines.append(f"- path: `{repo['path']}`")

        lines.append(f"- local branch: `{status.get('branch') or 'unknown'}`")

        lines.append(f"- local head: `{_short_hash(status.get('head')) or 'unknown'}`")

        lines.append(f"- local unmerged commits: `{status.get('unmerged_commit_count', 'unknown')}`")

        lines.append(f"- local dirty files: `{len(status.get('changes') or [])}`")

        lines.append(f"- remote main: `{_short_hash(remote_main.get('head')) or 'unknown'}`")

        if repo.get("status_error"):

            lines.append(f"- status error: `{repo['status_error']}`")

        if repo.get("branch_error"):

            lines.append(f"- branch-list error: `{repo['branch_error']}`")

        if repo.get("log_error"):

            lines.append(f"- log error: `{repo['log_error']}`")

        lines.append("")

        lines.append("Open non-main remote branches:")

        if non_main:

            for branch in non_main:

                desc = _desc_line(branch.get("description"))

                desc_suffix = f" - {desc}" if desc else ""

                lines.append(

                    f"- `{branch.get('name')}` `{_short_hash(branch.get('head'))}`{desc_suffix}"

                )

        else:

            lines.append("- none")

        lines.append("")

        lines.append("Recent local log:")

        recent = repo.get("recent_log") or []

        if recent:

            for entry in recent[:8]:

                desc = entry.get("description_or_subject") or ""

                lines.append(

                    f"- `{_short_hash(entry.get('hash'))}` `{entry.get('branch')}` {desc}"

                )

        else:

            lines.append("- unavailable")

        lines.append("")

    return "\n".join(lines).rstrip() + "\n"

def main(argv: Optional[list[str]] = None) -> int:

    parser = argparse.ArgumentParser(description="Read-only Oak remote/local field map")

    parser.add_argument(

        "--repo",

        action="append",

        required=True,

        help="Path to an existing local Oak clone. Pass once per repo.",

    )

    parser.add_argument("--json", action="store_true", help="Emit machine-readable JSON")

    args = parser.parse_args(argv)

    repos = inspect_repos([Path(path) for path in args.repo])

    if args.json:

        print(json.dumps({"schema_version": 1, "repos": repos}, indent=2, sort_keys=True))

    else:

        print(render_markdown(repos), end="")

    errors = [

        repo for repo in repos

        if repo.get("status_error") or repo.get("branch_error") or repo.get("log_error")

    ]

    return 1 if errors else 0

if __name__ == "__main__":

    raise SystemExit(main())