import argparse
import json
from pathlib import Path


def script_repo_root():
    return Path(__file__).resolve().parents[1]


def default_releases_path():
    return script_repo_root() / ".prd_plugin" / "state" / "releases.json"


def _read_json(path):
    return json.loads(Path(path).read_text(encoding="utf-8-sig"))


def _release_versions(releases):
    return {
        str(release.get("version"))
        for release in releases.get("releases", [])
        if isinstance(release, dict) and release.get("version")
    }


def analyze_gap_audit(target_version, releases, config):
    findings = []
    release_config = config.get("release", {})
    if not release_config.get("gap_audit_required_before_version_bump", True):
        return findings

    versions = _release_versions(releases)
    if target_version not in versions:
        findings.append(
            {
                "severity": "high",
                "summary": "Target version is missing release metadata.",
                "required_action": f"Add an entry for {target_version} to .prd_plugin/state/releases.json and templates/releases.json before bumping.",
            }
        )

    return findings


def format_markdown(findings, target_version):
    lines = [
        "# PRD Plugin Gap Audit",
        "",
        f"Target version: `{target_version}`",
        "",
        "## Findings",
        "",
    ]
    if findings:
        lines.extend(
            f"- `{finding['severity']}`: {finding['summary']} {finding['required_action']}"
            for finding in findings
        )
    else:
        lines.append("- None")
    return "\n".join(lines) + "\n"


def main():
    parser = argparse.ArgumentParser(description="Run pre-version-bump PRD Plugin gap audit.")
    parser.add_argument("--target-version", required=True)
    parser.add_argument("--config", default=".prd_plugin/config.json")
    parser.add_argument("--releases", help="Path to PRD Plugin hub releases.json. Defaults to the hub repo beside this script.")
    parser.add_argument("--output")
    parser.add_argument("--no-fail", action="store_true")
    args = parser.parse_args()

    releases_path = Path(args.releases) if args.releases else default_releases_path()
    try:
        config = _read_json(args.config)
    except FileNotFoundError as exc:
        raise SystemExit(f"Config not found at {args.config}. Pass --config with the PRD Plugin config.json path.") from exc
    except ValueError as exc:
        raise SystemExit(f"Config at {args.config} is not valid JSON: {exc}") from exc
    if not isinstance(config, dict):
        raise SystemExit(f"Config at {args.config} must be a JSON object.")
    try:
        releases = _read_json(releases_path)
    except FileNotFoundError as exc:
        raise SystemExit(
            f"Release metadata not found at {releases_path}. Pass --releases with the PRD Plugin hub releases.json path."
        ) from exc
    findings = analyze_gap_audit(args.target_version, releases, config)
    markdown = format_markdown(findings, args.target_version)

    if args.output:
        output_path = Path(args.output)
        output_path.parent.mkdir(parents=True, exist_ok=True)
        output_path.write_text(markdown, encoding="utf-8")
    else:
        print(markdown, end="")

    if findings and not args.no_fail:
        raise SystemExit(1)


if __name__ == "__main__":
    main()