#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import os
import re
import subprocess
import sys
from urllib import error, request


def warn(message: str) -> None:
    print(message, file=sys.stderr)


def parse_version(value: str | None) -> tuple[int, int, int] | None:
    if not value:
        return None
    match = re.match(r"^v?(\d+)\.(\d+)(?:\.(\d+))?", value)
    if not match:
        return None
    major = int(match.group(1))
    minor = int(match.group(2))
    patch = int(match.group(3) or 0)
    return major, minor, patch


def latest_tag_version(exclude_version: tuple[int, int, int] | None) -> tuple[int, int, int] | None:
    try:
        output = subprocess.check_output(["git", "tag", "--list", "v*"], text=True)
    except Exception as exc:
        warn(f"Milestone assignment skipped (failed to list tags: {exc}).")
        return None
    versions: list[tuple[int, int, int]] = []
    for tag in output.splitlines():
        parsed = parse_version(tag)
        if not parsed:
            continue
        if exclude_version and parsed == exclude_version:
            continue
        versions.append(parsed)
    if not versions:
        return None
    return max(versions)


def classify_bump(
    target: tuple[int, int, int] | None,
    previous: tuple[int, int, int] | None,
) -> str | None:
    if not target or not previous:
        return None
    if target < previous:
        warn("Milestone assignment skipped (release version is behind latest tag).")
        return None
    if target[0] != previous[0]:
        return "major"
    if target[1] != previous[1]:
        return "minor"
    return "patch"


def parse_milestone_title(title: str | None) -> tuple[int, int] | None:
    if not title:
        return None
    match = re.match(r"^(\d+)\.(\d+)\.x$", title)
    if not match:
        return None
    return int(match.group(1)), int(match.group(2))


def fetch_open_milestones(owner: str, repo: str, token: str) -> list[dict]:
    url = f"https://api.github.com/repos/{owner}/{repo}/milestones?state=open&per_page=100"
    headers = {
        "Accept": "application/vnd.github+json",
        "Authorization": f"Bearer {token}",
    }
    req = request.Request(url, headers=headers)
    try:
        with request.urlopen(req) as response:
            return json.load(response)
    except error.HTTPError as exc:
        warn(f"Milestone assignment skipped (failed to list milestones: {exc.code}).")
    except Exception as exc:
        warn(f"Milestone assignment skipped (failed to list milestones: {exc}).")
    return []


def select_milestone(milestones: list[dict], required_bump: str) -> str | None:
    parsed: list[dict] = []
    for milestone in milestones:
        parsed_title = parse_milestone_title(milestone.get("title"))
        if not parsed_title:
            continue
        parsed.append(
            {
                "milestone": milestone,
                "major": parsed_title[0],
                "minor": parsed_title[1],
            }
        )

    parsed.sort(key=lambda entry: (entry["major"], entry["minor"]))
    if not parsed:
        warn("Milestone assignment skipped (no open milestones matching X.Y.x).")
        return None

    majors = sorted({entry["major"] for entry in parsed})
    current_major = majors[0]
    next_major = majors[1] if len(majors) > 1 else None

    current_major_entries = [entry for entry in parsed if entry["major"] == current_major]
    patch_target = current_major_entries[0]
    minor_target = current_major_entries[1] if len(current_major_entries) > 1 else patch_target

    major_target = None
    if next_major is not None:
        next_major_entries = [entry for entry in parsed if entry["major"] == next_major]
        if next_major_entries:
            major_target = next_major_entries[0]

    target_entry = None
    if required_bump == "major":
        target_entry = major_target
    elif required_bump == "minor":
        target_entry = minor_target
    else:
        target_entry = patch_target

    if not target_entry:
        warn("Milestone assignment skipped (not enough open milestones for selection).")
        return None

    return target_entry["milestone"].get("title")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--version", help="Release version (e.g., 0.6.6).")
    parser.add_argument(
        "--required-bump",
        choices=("major", "minor", "patch"),
        help="Override bump type (major/minor/patch).",
    )
    parser.add_argument("--repo", help="GitHub repository (owner/repo).")
    parser.add_argument("--token", help="GitHub token.")
    args = parser.parse_args()

    required_bump = args.required_bump
    if not required_bump:
        target_version = parse_version(args.version)
        if not target_version:
            warn("Milestone assignment skipped (missing or invalid release version).")
            return 0
        previous_version = latest_tag_version(target_version)
        required_bump = classify_bump(target_version, previous_version)
        if not required_bump:
            warn("Milestone assignment skipped (unable to determine required bump).")
            return 0

    token = args.token or os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
    if not token:
        warn("Milestone assignment skipped (missing GitHub token).")
        return 0

    repo = args.repo or os.environ.get("GITHUB_REPOSITORY")
    if not repo or "/" not in repo:
        warn("Milestone assignment skipped (missing repository info).")
        return 0
    owner, name = repo.split("/", 1)

    milestones = fetch_open_milestones(owner, name, token)
    if not milestones:
        return 0

    milestone_title = select_milestone(milestones, required_bump)
    if milestone_title:
        print(milestone_title)
    return 0


if __name__ == "__main__":
    sys.exit(main())