"""Tests for build/release version guards, report writing and preflight steps."""

from __future__ import annotations

import io
import json
import subprocess
import sys
import urllib.error
from pathlib import Path

import pytest

REPO_ROOT = Path(__file__).resolve().parents[1]
BUILD_ROOT = REPO_ROOT / "build"
if str(BUILD_ROOT) not in sys.path:
    sys.path.insert(0, str(BUILD_ROOT))

from release import report as report_mod  # noqa: E402
from release import version as version_mod  # noqa: E402
from release.preflight import Preflight, PreflightOptions  # noqa: E402

PYPROJECT = """
[project]
name = "orisys"
description = "synthetic"

[tool.setuptools.dynamic]
version = {attr = "orisys.__version__"}
""".lstrip()


def _make_repo(tmp_path: Path, *, version: str = "1.2.3", with_git: bool = False) -> Path:
    (tmp_path / "pyproject.toml").write_text(PYPROJECT, encoding="utf-8")
    package = tmp_path / "src" / "orisys"
    package.mkdir(parents=True)
    (package / "__init__.py").write_text(f'__version__ = "{version}"\n', encoding="utf-8")
    if with_git:
        (tmp_path / ".git").mkdir()
    return tmp_path


def _stage_wheel(repo: Path, version: str, name: str | None = None) -> Path:
    directory = repo / "SDK" / version
    directory.mkdir(parents=True, exist_ok=True)
    wheel = directory / (name or f"orisys-{version}-cp310-cp310-win_amd64.whl")
    wheel.write_bytes(b"not really a wheel")
    return wheel


class _FakeResponse:
    def __init__(self, payload: dict) -> None:
        self._buffer = io.BytesIO(json.dumps(payload).encode("utf-8"))

    def read(self, *args):
        return self._buffer.read(*args)

    def __enter__(self):
        return self

    def __exit__(self, *exc) -> bool:
        return False


def test_wheel_version_parsing():
    assert version_mod.wheel_version(Path("orisys-1.2.3-cp310-cp310-win_amd64.whl")) == "1.2.3"
    assert version_mod.wheel_version(Path("orisys-1.0.0-1-cp312-abi3-manylinux_2_28_x86_64.whl")) == "1.0.0"
    assert version_mod.wheel_version(Path("something-else.whl")) is None


def test_sdk_versions_are_numerically_sorted(tmp_path):
    for name in ("0.9.0", "0.4.10", "1.2.3"):
        (tmp_path / "SDK" / name).mkdir(parents=True)
    (tmp_path / "SDK" / "not-a-version").mkdir()
    assert version_mod.sdk_versions(tmp_path)[:3] == ["0.4.10", "0.9.0", "1.2.3"]


def test_sdk_versions_empty_without_sdk_dir(tmp_path):
    assert version_mod.sdk_versions(tmp_path) == []


def test_sdk_wheels_lists_only_that_version(tmp_path):
    repo = _make_repo(tmp_path)
    _stage_wheel(repo, "1.2.3")
    _stage_wheel(repo, "0.4.3")
    wheels = version_mod.sdk_wheels(repo, "1.2.3")
    assert [w.name for w in wheels] == ["orisys-1.2.3-cp310-cp310-win_amd64.whl"]


def test_dynamic_version_attr_read_from_pyproject(tmp_path):
    repo = _make_repo(tmp_path)
    assert version_mod.dynamic_version_attr(repo) == "orisys.__version__"


def test_dynamic_version_attr_none_when_absent(tmp_path):
    (tmp_path / "pyproject.toml").write_text("[project]\nname = 'x'\n", encoding="utf-8")
    assert version_mod.dynamic_version_attr(tmp_path) is None


def test_pypi_released_versions_parses_response(tmp_path, monkeypatch):
    fake = _FakeResponse({"releases": {"0.4.2": [{"filename": "a"}], "1.2.3": [{"filename": "b"}], "0.0.0": []}})
    monkeypatch.setattr(version_mod.urllib.request, "urlopen", lambda *a, **k: fake)
    versions, error = version_mod.pypi_released_versions()
    assert error is None
    # An empty file list means nothing was ever uploaded for that version.
    assert versions == ["0.4.2", "1.2.3"]


def test_pypi_released_versions_reports_http_404_as_empty(monkeypatch):
    def _raise(*args, **kwargs):
        raise urllib.error.HTTPError(version_mod.PYPI_JSON_URL, 404, "not found", {}, None)

    monkeypatch.setattr(version_mod.urllib.request, "urlopen", _raise)
    assert version_mod.pypi_released_versions() == ([], None)


def test_pypi_released_versions_returns_error_on_failure(monkeypatch):
    def _raise(*args, **kwargs):
        raise urllib.error.URLError("no network")

    monkeypatch.setattr(version_mod.urllib.request, "urlopen", _raise)
    versions, error = version_mod.pypi_released_versions()
    assert versions is None
    assert error and "URLError" in error


def test_python_for_tag_uses_envs_root(tmp_path):
    executable = tmp_path / "py310" / "python.exe"
    executable.parent.mkdir(parents=True)
    executable.write_bytes(b"")
    assert version_mod.python_for_tag("cp310", envs_root=tmp_path) == executable
    assert version_mod.python_for_tag("cp311", envs_root=tmp_path) is None


# --- report -----------------------------------------------------------------


def test_write_report_round_trips(tmp_path):
    payload = {
        "version": "1.2.3",
        "ok": False,
        "git": {"commit": "abc", "branch": "dev", "dirty": True},
        "interpreter": {"version": "3.10.19", "executable": "python"},
        "duration_s": 1.5,
        "options": {"skip_tests": True},
        "steps": [{"name": "tests", "ok": True, "detail": "skipped", "duration_s": 0.0, "data": {}}],
        "wheels": [{"name": "w.whl", "size": 12, "sha256": "deadbeef"}],
    }
    json_path, text_path = report_mod.write_report(payload, tmp_path / "reports")
    loaded = json.loads(json_path.read_text(encoding="utf-8"))
    assert loaded["schema"] == report_mod.SCHEMA_VERSION
    assert loaded["wheels"][0]["sha256"] == "deadbeef"

    text = text_path.read_text(encoding="utf-8")
    assert "FAIL" in text
    assert "deadbeef" in text
    assert "waived guards: skip_tests" in text


# --- preflight steps --------------------------------------------------------


def test_preflight_resolves_version_from_pyproject(tmp_path):
    repo = _make_repo(tmp_path, version="0.6.0")
    preflight = Preflight(PreflightOptions(), repo_root=repo)
    assert preflight.version == "0.6.0"
    assert preflight.version_source == "pyproject.toml dynamic attr"


def test_preflight_explicit_version_wins(tmp_path):
    repo = _make_repo(tmp_path, version="0.6.0")
    preflight = Preflight(PreflightOptions(version="0.7.0"), repo_root=repo)
    assert preflight.version == "0.7.0"
    assert preflight.version_source == "explicit --version"


def test_repo_state_fails_outside_git(tmp_path, capsys):
    repo = _make_repo(tmp_path)
    step = Preflight(PreflightOptions(), repo_root=repo)._repo_state()
    assert not step.ok
    assert "not a git repository" in step.detail


def test_version_consistency_detects_mismatch(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    step = Preflight(PreflightOptions(version="9.9.9"), repo_root=repo)._version_consistency()
    assert not step.ok
    assert "1.2.3" in step.detail and "9.9.9" in step.detail


def test_version_consistency_passes_on_match(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    step = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)._version_consistency()
    assert step.ok, step.detail


def test_duplicate_guard_allows_staged_sdk_dir(tmp_path, monkeypatch):
    """A populated SDK/<version>/ is the normal preflight input, not a hazard."""
    repo = _make_repo(tmp_path, version="1.2.3")
    _stage_wheel(repo, "1.2.3")
    monkeypatch.setattr(version_mod, "git_tags", lambda root: [])
    step = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)._duplicate_guard()
    assert step.ok, step.detail
    assert "staged wheel(s) to verify" in step.detail


def test_duplicate_guard_blocks_released_tag(tmp_path, monkeypatch):
    repo = _make_repo(tmp_path, version="1.2.3")
    _stage_wheel(repo, "1.2.3")
    monkeypatch.setattr(version_mod, "git_tags", lambda root: ["v1.2.3", "v0.5.1"])
    step = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)._duplicate_guard()
    assert not step.ok
    assert "already mark 1.2.3 as released" in step.detail
    assert "--force" in step.detail


def test_duplicate_guard_force_accepts_released_tag(tmp_path, monkeypatch):
    repo = _make_repo(tmp_path, version="1.2.3")
    monkeypatch.setattr(version_mod, "git_tags", lambda root: ["1.2.3"])
    step = Preflight(
        PreflightOptions(version="1.2.3", force=True), repo_root=repo
    )._duplicate_guard()
    assert step.ok, step.detail
    assert "accepted via --force" in step.detail


def test_duplicate_guard_reports_unreleased_version(tmp_path, monkeypatch):
    repo = _make_repo(tmp_path, version="0.5.3")
    monkeypatch.setattr(version_mod, "git_tags", lambda root: ["v1.2.3"])
    step = Preflight(PreflightOptions(version="0.5.3"), repo_root=repo)._duplicate_guard()
    assert step.ok, step.detail
    assert "no local git tag marks 0.5.3" in step.detail


def test_duplicate_guard_flags_published_version(tmp_path, monkeypatch):
    repo = _make_repo(tmp_path, version="1.2.3")
    monkeypatch.setattr(version_mod, "git_tags", lambda root: [])
    monkeypatch.setattr(version_mod, "pypi_released_versions", lambda *a, **k: (["1.2.3"], None))
    step = Preflight(
        PreflightOptions(version="1.2.3", check_pypi=True), repo_root=repo
    )._duplicate_guard()
    assert not step.ok
    assert "already published on PyPI" in step.detail


def test_released_tags_for_matches_version_spellings():
    tags = ["v0.5.1", "0.5.1", "v0.4.3", "0.50"]
    assert version_mod.released_tags_for("0.5.1", tags) == ["0.5.1", "v0.5.1"]
    assert version_mod.released_tags_for("1.2.3", tags) == []


def test_git_tags_reads_repo_tags(tmp_path):
    repo = tmp_path / "repo"
    repo.mkdir()
    for command in (
        ["git", "init", "-q"],
        ["git", "config", "user.email", "test@example.invalid"],
        ["git", "config", "user.name", "test"],
    ):
        subprocess.run(command, cwd=repo, check=True, capture_output=True)
    (repo / "f.txt").write_text("x", encoding="utf-8")
    subprocess.run(["git", "add", "f.txt"], cwd=repo, check=True, capture_output=True)
    subprocess.run(["git", "commit", "-qm", "init"], cwd=repo, check=True, capture_output=True)
    subprocess.run(["git", "tag", "v1.2.3"], cwd=repo, check=True, capture_output=True)

    assert "v1.2.3" in version_mod.git_tags(repo)


def test_version_string_scan_flags_stale_literal(tmp_path):
    repo = tmp_path / "repo"
    (repo / "docs").mkdir(parents=True)
    (repo / "docs" / "a.md").write_text("版本：0.4.0\n", encoding="utf-8")
    (repo / "README.md").write_text("release 1.2.3\n", encoding="utf-8")
    hits = version_mod.find_version_literals(repo, "1.2.3")
    assert [(path, line) for path, line, _ in hits] == [("docs/a.md", 1)]


def test_version_string_scan_ignores_dependency_constraints(tmp_path):
    repo = tmp_path / "repo"
    repo.mkdir()
    (repo / "docs.md").write_text(
        "pip install numpy>=1.24.4 scipy==1.13 opencv-python>=4.10.0.84\n",
        encoding="utf-8",
    )
    assert version_mod.find_version_literals(repo, "1.2.3") == []


def test_version_string_scan_honours_allowlist(tmp_path, monkeypatch):
    monkeypatch.setitem(
        version_mod.VERSION_STRING_ALLOWLIST, "docs.md", frozenset({"0.4.0"})
    )
    repo = tmp_path / "repo"
    repo.mkdir()
    (repo / "docs.md").write_text("历史版本：0.4.0\n", encoding="utf-8")
    assert version_mod.find_version_literals(repo, "1.2.3") == []


def test_version_string_scan_skips_tests_directory(tmp_path):
    repo = tmp_path / "repo"
    (repo / "tests").mkdir(parents=True)
    (repo / "tests" / "test_x.py").write_text('v = "0.1.2"\n', encoding="utf-8")
    assert version_mod.find_version_literals(repo, "1.2.3") == []


def test_version_string_scan_accepts_current_version_and_v_prefix(tmp_path):
    repo = tmp_path / "repo"
    repo.mkdir()
    (repo / "README.md").write_text("current 1.2.3 and tag v1.2.3\n", encoding="utf-8")
    assert version_mod.find_version_literals(repo, "1.2.3") == []


def test_preflight_version_strings_step_fails_on_leftover(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    (repo / "docs").mkdir()
    (repo / "docs" / "guide.md").write_text("版本：0.4.0\n", encoding="utf-8")
    step = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)._version_strings()
    assert not step.ok
    assert "0.4.0" in step.detail
    assert "VERSION_STRING_ALLOWLIST" in step.detail


def test_preflight_version_strings_step_passes_on_clean_tree(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    (repo / "README.md").write_text("no version literal here\n", encoding="utf-8")
    step = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)._version_strings()
    assert step.ok, step.detail


def test_repo_has_no_stale_version_literals():
    """The real repository must satisfy its own version-string gate."""
    from common.pyproject_utils import get_version

    version = get_version(REPO_ROOT)
    assert version_mod.find_version_literals(REPO_ROOT, version) == []


def test_bundle_precheck_fails_when_pattern_resolves_nothing(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    (repo / "pyproject.toml").write_text(
        PYPROJECT
        + """
[[tool.orisys.bundle.items]]
name = "configs"
source = "config"
target = "configs"
patterns = ["*.json"]
""",
        encoding="utf-8",
    )
    step = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)._bundle_precheck()
    assert not step.ok
    assert "resolved 0 files" in step.detail


def test_wheel_inspection_fails_without_wheels(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    step = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)._wheel_inspection()
    assert not step.ok
    assert "does not exist" in step.detail


def test_wheel_runtime_fails_without_video(tmp_path, monkeypatch):
    repo = _make_repo(tmp_path, version="1.2.3")
    _stage_wheel(repo, "1.2.3")
    monkeypatch.setattr("release.preflight.default_verification_video", lambda root: None)
    preflight = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)
    preflight._discover_wheels()
    step = preflight._wheel_runtime()
    assert not step.ok
    assert "never silently skipped" in step.detail


def test_wheel_runtime_skip_is_recorded(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    step = Preflight(
        PreflightOptions(version="1.2.3", no_runtime=True), repo_root=repo
    )._wheel_runtime()
    assert step.ok
    assert "SKIPPED" in step.detail


def test_tests_skip_is_loud_and_recorded(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    step = Preflight(
        PreflightOptions(version="1.2.3", skip_tests=True), repo_root=repo
    )._tests()
    assert step.ok
    assert "SKIPPED" in step.detail
    assert step.data["status"] == "skipped"


def test_execute_marks_failure_and_aborts(tmp_path, capsys):
    repo = _make_repo(tmp_path, version="1.2.3")
    preflight = Preflight(PreflightOptions(version="1.2.3"), repo_root=repo)
    preflight._execute(preflight._repo_state)
    assert preflight.aborted
    assert preflight.steps[-1].name == "repo-state"
    assert not preflight.steps[-1].ok


def test_execute_keep_going_does_not_abort(tmp_path):
    repo = _make_repo(tmp_path, version="1.2.3")
    preflight = Preflight(PreflightOptions(version="1.2.3", keep_going=True), repo_root=repo)
    preflight._execute(preflight._repo_state)
    assert not preflight.aborted