from __future__ import annotations

import importlib.util
import os
import stat
import subprocess
import sys
import tomllib
from pathlib import Path
from zipfile import ZipFile

import pytest

SCRIPT_PATH = Path(__file__).resolve().parents[2] / "scripts" / "build_wheelhouse_zip.py"
REPO_ROOT = SCRIPT_PATH.parents[1]
WORKFLOW_PATH = REPO_ROOT / ".github" / "workflows" / "wheelhouse-release.yml"
INTERNAL_RELEASE_MARKERS = (
    "INTERNAL_ORG_NAME",
    "github.com/internal-org/opensquilla",
    ".internal/evidence",
    "INTERNAL_RELEASE_NOTE.md",
    "LOCAL_AGENT_NOTES.md",
)


def assert_executable_on_posix(path: Path) -> None:
    if os.name != "nt":
        assert path.stat().st_mode & stat.S_IXUSR


def load_script():
    spec = importlib.util.spec_from_file_location("build_wheelhouse_zip", SCRIPT_PATH)
    assert spec is not None
    assert spec.loader is not None
    module = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = module
    spec.loader.exec_module(module)
    return module


def test_build_wheel_retries_once_after_transient_uv_failure(monkeypatch, tmp_path: Path) -> None:
    module = load_script()
    wheel_path = tmp_path / "wheels" / "opensquilla-0.1.0-py3-none-any.whl"
    calls = []

    def fake_run(args, *, cwd, env):
        calls.append((args, cwd, env))
        if len(calls) == 1:
            raise subprocess.CalledProcessError(4294967295, args)

    monkeypatch.setattr(module, "run", fake_run)
    monkeypatch.setattr(module.time, "sleep", lambda _: None)
    monkeypatch.setattr(module, "find_built_wheel", lambda wheel_dir: wheel_path)

    assert (
        module.build_wheel(tmp_path, tmp_path / "wheels", {"UV_CACHE_DIR": "cache"})
        == wheel_path
    )
    assert len(calls) == 2


def test_build_subprocess_env_keeps_uv_cache_outside_repo_root(tmp_path: Path) -> None:
    module = load_script()
    repo_root = tmp_path / "repo"
    work_dir = repo_root / "build" / "wheelhouse-zip"
    repo_root.mkdir()

    env = module.build_subprocess_env(work_dir, repo_root=repo_root)

    uv_cache = Path(env["UV_CACHE_DIR"]).resolve()
    pip_cache = Path(env["PIP_CACHE_DIR"]).resolve()
    assert not uv_cache.is_relative_to(repo_root.resolve())
    assert not pip_cache.is_relative_to(repo_root.resolve())
    assert uv_cache.name == "uv-cache"
    assert pip_cache.name == "pip-cache"


def test_release_name_records_platform_python_profile() -> None:
    module = load_script()

    wheelhouse_name = module.release_name(
        app_version="0.1.0",
        platform_tag="macos-arm64",
        python_major=3,
        python_minor=12,
        profile="recommended",
        portable=False,
    )
    portable_name = module.release_name(
        app_version="0.1.0",
        platform_tag="macos-arm64",
        python_major=3,
        python_minor=12,
        profile="recommended",
        portable=True,
    )

    assert wheelhouse_name == "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse"
    assert portable_name == "OpenSquilla-0.1.0-macos-arm64-py312-recommended-portable"


def test_python_runtime_asset_name_uses_platform_triple() -> None:
    module = load_script()

    macos = module.python_runtime_asset_name(
        python_version="3.12.13",
        runtime_release="20260414",
        platform_tag="macos-arm64",
    )
    windows = module.python_runtime_asset_name(
        python_version="3.12.13",
        runtime_release="20260414",
        platform_tag="windows-x64",
    )

    assert macos == (
        "cpython-3.12.13+20260414-aarch64-apple-darwin-install_only_stripped.tar.gz"
    )
    assert windows == (
        "cpython-3.12.13+20260414-x86_64-pc-windows-msvc-install_only_stripped.tar.gz"
    )


def test_cross_platform_wheelhouse_requires_target_host(tmp_path: Path) -> None:
    module = load_script()
    module.platform_tag = lambda: "linux-x64"
    wheel_path = tmp_path / "opensquilla-0.1.0-py3-none-any.whl"
    package_dir = tmp_path / "packages"

    with pytest.raises(SystemExit, match="must run on the target platform"):
        module.build_wheelhouse_command(
            package_dir,
            wheel_path,
            "recommended",
            target_platform_tag="windows-x64",
            python_major=3,
            python_minor=12,
        )


def test_portable_recommended_wheelhouse_uses_recommended_extra_only(tmp_path: Path) -> None:
    module = load_script()
    module.platform_tag = lambda: "windows-x64"
    wheel_path = tmp_path / "opensquilla-0.1.0-py3-none-any.whl"
    package_dir = tmp_path / "packages"

    command = module.build_wheelhouse_command(
        package_dir,
        wheel_path,
        "recommended",
        target_platform_tag="windows-x64",
        python_major=3,
        python_minor=12,
    )

    assert str(wheel_path) + "[recommended]" in command
    assert str(wheel_path) + "[recommended,feishu]" not in command

def test_release_wheel_allows_router_provenance_markdown() -> None:
    module = load_script()
    provenance = module.ROUTER_PROVENANCE_WHEEL_PATH
    tokenjuice_provenance = module.TOKENJUICE_PROVENANCE_WHEEL_PATH
    pptx_reference = "opensquilla/skills/bundled/pptx/references/python_pptx.md"
    unrelated_skill_reference = (
        "opensquilla/skills/bundled/example/references/private-notes.md"
    )
    skill_readme = "opensquilla/skills/bundled/filesystem/README.md"
    skill_license = "opensquilla/skills/bundled/filesystem/LICENSE.md"
    skill_card = "opensquilla/skills/bundled/filesystem/skill-card.md"
    unrelated_router_doc = (
        "opensquilla/squilla_router/models/v4.2_phase3_inference/README.md"
    )

    violations = module.forbidden_release_wheel_entries(
        (
            provenance,
            tokenjuice_provenance,
            unrelated_router_doc,
            "opensquilla/skills/bundled/example/SKILL.md",
            pptx_reference,
            unrelated_skill_reference,
            skill_readme,
            skill_license,
            skill_card,
        )
    )

    assert provenance not in violations
    assert tokenjuice_provenance not in violations
    assert "opensquilla/skills/bundled/example/SKILL.md" not in violations
    assert pptx_reference not in violations
    assert unrelated_router_doc in violations
    assert unrelated_skill_reference in violations
    assert skill_readme in violations
    assert skill_license in violations
    assert skill_card in violations


def test_pyproject_release_wheel_config_excludes_forbidden_skill_resources() -> None:
    module = load_script()
    pyproject = tomllib.loads((REPO_ROOT / "pyproject.toml").read_text(encoding="utf-8"))
    wheel_config = pyproject["tool"]["hatch"]["build"]["targets"]["wheel"]
    excludes = set(wheel_config.get("exclude", []))
    force_includes = wheel_config.get("force-include", {})

    assert "src/opensquilla/skills/bundled/**/THIRD_PARTY_NOTICES.md" in excludes
    assert "src/opensquilla/skills/bundled/**/README.md" in excludes
    assert "src/opensquilla/skills/bundled/**/LICENSE.md" in excludes
    assert "src/opensquilla/skills/bundled/**/skill-card.md" in excludes
    assert "src/opensquilla/skills/bundled/**/references/*.md" in excludes
    assert "src/opensquilla/skills/exp/**" in excludes
    assert "src/opensquilla/skills/meta/META_SKILL_AUTHORING.md" in excludes
    assert module.forbidden_release_wheel_entries(tuple(force_includes.values())) == []


def test_required_router_assets_include_provenance_and_manifest() -> None:
    module = load_script()

    assert "v4.2_phase3_inference/PROVENANCE.md" in module.ROUTER_ASSET_RELS
    assert "v4.2_phase3_inference/artifact_manifest.json" in module.ROUTER_ASSET_RELS


def test_project_release_metadata_avoids_internal_repository_markers() -> None:
    for rel_path in ("pyproject.toml", "README.release.md", "LICENSE"):
        text = (REPO_ROOT / rel_path).read_text(encoding="utf-8")
        for marker in INTERNAL_RELEASE_MARKERS:
            assert marker not in text


def test_public_release_docs_avoid_private_kol_language() -> None:
    for rel_path in ("README.md",):
        text = (REPO_ROOT / rel_path).read_text(encoding="utf-8").lower()
        assert "kol" not in text
        assert "private" not in text


def test_release_wheel_content_scanner_flags_internal_markers(tmp_path: Path) -> None:
    module = load_script()
    wheel_path = tmp_path / "opensquilla-0.1.0-py3-none-any.whl"

    with ZipFile(wheel_path, "w") as archive:
        archive.writestr("opensquilla/__init__.py", "__version__ = '0.1.0'\n")
        archive.writestr(
            "opensquilla-0.1.0.dist-info/METADATA",
            "\n".join(
                [
                    "Author: INTERNAL_ORG_NAME",
                    "Project-URL: Repository, https://github.com/internal-org/opensquilla",
                    "",
                ]
            ),
        )

    assert module.forbidden_release_text_hits(wheel_path) == [
        "opensquilla-0.1.0.dist-info/METADATA: INTERNAL_ORG_NAME",
        "opensquilla-0.1.0.dist-info/METADATA: github.com/internal-org/opensquilla",
    ]


def test_install_scripts_install_from_local_wheelhouse_and_run_onboarding() -> None:
    module = load_script()

    sh_script = module.render_install_sh(
        wheel_name="opensquilla-0.1.0-py3-none-any.whl",
        profile="recommended",
        python_major=3,
        python_minor=12,
    )
    ps_script = module.render_install_ps1(
        wheel_name="opensquilla-0.1.0-py3-none-any.whl",
        profile="recommended",
        python_major=3,
        python_minor=12,
    )

    assert 'PACKAGE_DIR="${SCRIPT_DIR}/packages"' in sh_script
    assert 'REQUIRED_PYTHON_MINOR=12' in sh_script
    assert "uv tool install" in sh_script
    assert '--find-links "${PACKAGE_DIR}"' in sh_script
    assert '"${PACKAGE_DIR}/opensquilla-0.1.0-py3-none-any.whl[recommended]"' in sh_script
    assert '"${OPENSQUILLA_BIN}" onboard' in sh_script
    assert '"${OPENSQUILLA_BIN}" onboard --if-needed' in sh_script
    assert "opensquilla gateway run" in sh_script

    assert "$PackageDir = Join-Path $ScriptDir 'packages'" in ps_script
    assert "$RequiredPythonMinor = 12" in ps_script
    assert "uv tool install" in ps_script
    assert "--find-links" in ps_script
    assert "opensquilla-0.1.0-py3-none-any.whl[recommended]" in ps_script
    assert "& $OpenSquillaBin onboard --if-needed" in ps_script
    assert 'throw "OpenSquilla installation failed with exit code $LASTEXITCODE."' in ps_script
    assert 'throw "OpenSquilla onboarding failed with exit code $LASTEXITCODE."' in ps_script
    assert "opensquilla gateway run" in ps_script


def test_start_scripts_use_bundled_python_runtime() -> None:
    module = load_script()

    sh_script = module.render_start_sh()
    ps_script = module.render_start_ps1()
    cmd_script = module.render_start_cmd()

    assert sh_script.startswith('#!/bin/sh\nif [ -z "${BASH_VERSION:-}" ]; then')
    assert 'exec /usr/bin/env bash "$0" "$@"' in sh_script
    assert 'PYTHON_BIN="${SCRIPT_DIR}/runtime/python/bin/python3"' in sh_script
    assert "OPENSQUILLA_WHEEL=" in sh_script
    assert "WHEEL_HASH=" in sh_script
    assert 'VENV_DIR="${SCRIPT_DIR}/.venv-${WHEEL_HASH}"' in sh_script
    assert "--without-pip" in sh_script
    assert (
        'export PATH="${SCRIPT_DIR}:${VENV_DIR}/bin:${SCRIPT_DIR}/runtime/python/bin:${PATH}"'
        in sh_script
    )
    assert (
        'PORTABLE_DATA_DIR="${OPENSQUILLA_PORTABLE_HOME:-${DATA_BASE}/OpenSquilla/'
        'portable/${RELEASE_ID}}"' in sh_script
    )
    assert 'if [[ -z "${OPENSQUILLA_GATEWAY_CONFIG_PATH:-}" ]]; then' in sh_script
    assert (
        'export OPENSQUILLA_GATEWAY_CONFIG_PATH="${PORTABLE_DATA_DIR}/config.toml"'
        in sh_script
    )
    assert (
        'if [[ -z "${OPENSQUILLA_LLM_API_KEY:-}" && -n "${OPENROUTER_API_KEY:-}" ]]; then'
        in sh_script
    )
    assert 'export OPENSQUILLA_STATE_DIR="${PORTABLE_DATA_DIR}"' in sh_script
    assert (
        'export OPENSQUILLA_GATEWAY_STATE_DIR="${OPENSQUILLA_STATE_DIR}/state"'
        in sh_script
    )
    assert (
        'export OPENSQUILLA_GATEWAY_WORKSPACE_DIR="${OPENSQUILLA_STATE_DIR}/workspace"'
        in sh_script
    )
    assert 'mkdir -p "${OPENSQUILLA_STATE_DIR}"' in sh_script
    assert '"${PYTHON_BIN}" -m venv --without-pip "${VENV_DIR}"' in sh_script
    assert "-m pip install" not in sh_script
    assert "Installing OpenSquilla from bundled wheels..." in sh_script
    assert 'OPENSQUILLA_MODULE=( "-m" "opensquilla.cli.main" )' in sh_script
    assert (
        'if [[ ! -f "${OPENSQUILLA_GATEWAY_CONFIG_PATH}" && '
        '-n "${OPENROUTER_API_KEY:-}" ]]; then' in sh_script
    )
    assert (
        '"${OPENSQUILLA_BIN}" "${OPENSQUILLA_MODULE[@]}" onboard \\\n'
        "    --provider openrouter" in sh_script
    )
    assert "--api-key-env OPENROUTER_API_KEY" in sh_script
    assert "--minimal" in sh_script
    assert '"${OPENSQUILLA_BIN}" "${OPENSQUILLA_MODULE[@]}" onboard' in sh_script
    assert '"${OPENSQUILLA_BIN}" onboard --if-needed' not in sh_script
    assert "if [[ -t 1 ]]; then" in sh_script
    assert 'exec "${OPENSQUILLA_BIN}" "${OPENSQUILLA_MODULE[@]}" gateway run' in sh_script
    assert "else" in sh_script
    assert 'CONSOLE_LOG="${OPENSQUILLA_STATE_DIR}/logs/gateway-console.log"' in sh_script
    assert 'tee -a "${CONSOLE_LOG}"' in sh_script
    assert sh_script.index("if [[ -t 1 ]]; then") < sh_script.index(
        'tee -a "${CONSOLE_LOG}"'
    )
    assert sh_script.index(
        'export OPENSQUILLA_GATEWAY_CONFIG_PATH="${PORTABLE_DATA_DIR}/config.toml"'
    ) < sh_script.index('"${OPENSQUILLA_BIN}" "${OPENSQUILLA_MODULE[@]}" onboard')

    assert "$PythonBin = Join-Path $ScriptDir 'runtime\\python\\python.exe'" in ps_script
    assert "$OpenSquillaWheel = Get-ChildItem -Path $PackageDir" in ps_script
    assert "$WheelHashFull = -join" in ps_script
    assert "$WheelHash = $WheelHashFull.Substring(0, 12).ToLowerInvariant()" in ps_script
    assert "Get-FileHash" not in ps_script
    assert "[System.IO.File]::OpenRead($OpenSquillaWheel.FullName)" in ps_script
    assert "$Sha256.ComputeHash($WheelStream)" in ps_script
    assert "$VenvDir = Join-Path $VenvRoot $ReleaseId" in ps_script
    assert '$env:PATH = "$VenvDir\\Scripts;$env:PATH"' in ps_script
    assert 'Join-Path $VenvBase "OpenSquilla\\portable\\$ReleaseId"' in ps_script
    assert (
        "$env:OPENSQUILLA_GATEWAY_CONFIG_PATH = Join-Path $PortableDataDir 'config.toml'"
        in ps_script
    )
    assert "$env:OPENSQUILLA_LLM_API_KEY = $env:OPENROUTER_API_KEY" in ps_script
    assert "$env:OPENSQUILLA_STATE_DIR = $PortableDataDir" in ps_script
    assert (
        "$env:OPENSQUILLA_GATEWAY_STATE_DIR = Join-Path "
        "$env:OPENSQUILLA_STATE_DIR 'state'" in ps_script
    )
    assert (
        "$env:OPENSQUILLA_GATEWAY_WORKSPACE_DIR = Join-Path "
        "$env:OPENSQUILLA_STATE_DIR 'workspace'" in ps_script
    )
    assert "New-Item -ItemType Directory -Path $env:OPENSQUILLA_STATE_DIR -Force" in ps_script
    assert "& $PythonBin -m venv --without-pip $VenvDir" in ps_script
    assert "-m pip install" not in ps_script
    assert "-c $WheelInstallScript" not in ps_script
    assert "$WheelInstallScript | & $PythonBin - $PackageDir $SitePackages" in ps_script
    assert "Installing OpenSquilla from bundled wheels..." in ps_script
    assert '$OpenSquillaArgs = @("-m", "opensquilla.cli.main")' in ps_script
    assert (
        "if ((-not (Test-Path $env:OPENSQUILLA_GATEWAY_CONFIG_PATH)) "
        "-and $env:OPENROUTER_API_KEY) {" in ps_script
    )
    assert "& $VenvPython @OpenSquillaArgs onboard `" in ps_script
    assert "--provider openrouter `" in ps_script
    assert "--api-key-env OPENROUTER_API_KEY `" in ps_script
    assert "& $VenvPython @OpenSquillaArgs onboard" in ps_script
    assert "& $OpenSquillaBin onboard --if-needed" not in ps_script
    assert "OpenSquilla environment creation failed" in ps_script
    assert "OpenSquilla installation failed" not in ps_script
    assert 'throw "OpenSquilla onboarding failed with exit code $LASTEXITCODE."' in ps_script
    assert "$OutputRedirected = [Console]::IsOutputRedirected" in ps_script
    assert "if (-not $OutputRedirected) {" in ps_script
    assert "& $VenvPython @OpenSquillaArgs gateway run" in ps_script
    assert "$ConsoleLog = Join-Path $LogDir 'gateway-console.log'" in ps_script
    assert "$PreviousErrorActionPreference = $ErrorActionPreference" in ps_script
    assert "$ErrorActionPreference = \"Continue\"" in ps_script
    assert "$_ -is [System.Management.Automation.ErrorRecord]" in ps_script
    assert "Tee-Object -FilePath $ConsoleLog -Append" in ps_script
    assert ps_script.index("if (-not $OutputRedirected) {") < ps_script.index(
        "Tee-Object -FilePath $ConsoleLog -Append"
    )
    assert ps_script.index(
        "$env:OPENSQUILLA_GATEWAY_CONFIG_PATH = Join-Path $PortableDataDir 'config.toml'"
    ) < ps_script.index("& $VenvPython @OpenSquillaArgs onboard")
    assert ps_script.index(
        "$env:OPENSQUILLA_GATEWAY_STATE_DIR = Join-Path "
        "$env:OPENSQUILLA_STATE_DIR 'state'"
    ) < ps_script.index("& $VenvPython @OpenSquillaArgs onboard")

    assert cmd_script == (
        "@echo off\r\n"
        "title OpenSquilla Gateway\r\n"
        'cd /d "%~dp0"\r\n'
        'set "OSQ_POWERSHELL=powershell.exe"\r\n'
        'where pwsh.exe >nul 2>nul && set "OSQ_POWERSHELL=pwsh.exe"\r\n'
        '"%OSQ_POWERSHELL%" -NoLogo -NoExit -NoProfile -ExecutionPolicy Bypass '
        '-File "%~dp0start.ps1"\r\n'
    )


def test_install_script_reexecs_under_bash_before_pipefail() -> None:
    module = load_script()

    script = module.render_install_sh(
        wheel_name="opensquilla-0.1.0-py3-none-any.whl",
        profile="recommended",
        python_major=3,
        python_minor=12,
    )

    assert script.startswith('#!/bin/sh\nif [ -z "${BASH_VERSION:-}" ]; then')
    assert 'exec /usr/bin/env bash "$0" "$@"' in script
    assert script.index('exec /usr/bin/env bash "$0" "$@"') < script.index(
        "set -euo pipefail"
    )


def test_render_readme_is_platform_specific_for_windows_portable() -> None:
    module = load_script()

    readme = module.render_readme(
        app_version="0.1.0",
        profile="recommended",
        platform_tag="windows-x64",
        python_major=3,
        python_minor=12,
        portable=True,
    )

    assert "## Windows" in readme
    assert "# OpenSquilla 0.1.0 Portable Release" in readme
    assert "Wheelhouse Release" not in readme
    assert "Right-click `Start OpenSquilla.cmd`" in readme
    assert "Run as administrator" in readme
    assert "Smart App Control" in readme
    assert ".\\start.ps1" in readme
    assert "## macOS / Linux" not in readme
    assert "bash start.sh" not in readme
    assert "Python is bundled in this zip." in readme
    assert "Complete onboarding." in readme
    assert "Feishu" not in readme
    assert "Advanced portable usage" in readme
    assert "OPENROUTER_API_KEY" in readme
    assert "writes an OpenRouter env-reference config" in readme
    assert "supported portable launch\n  path is administrator launch" in readme
    assert "Microsoft documents that SmartScreen checks downloaded apps" in readme
    assert "skip setup when it is complete" not in readme
    assert "does not install a global `opensquilla` command" in readme
    assert (
        "Config, workspace, logs, memory, and runtime state use the normal "
        "user-level OpenSquilla directory." in readme
    )


def test_render_readme_is_platform_specific_for_macos_portable() -> None:
    module = load_script()

    readme = module.render_readme(
        app_version="0.1.0",
        profile="recommended",
        platform_tag="macos-arm64",
        python_major=3,
        python_minor=12,
        portable=True,
    )

    assert "## macOS / Linux" in readme
    assert "# OpenSquilla 0.1.0 Portable Release" in readme
    assert "Wheelhouse Release" not in readme
    assert "bash start.sh" in readme
    assert "## Windows PowerShell" not in readme
    assert ".\\start.ps1" not in readme
    assert "Python is bundled in this zip." in readme
    assert "Complete onboarding." in readme
    assert "Feishu" not in readme
    assert "later starts let you review or change the config" in readme
    assert "skip setup when it is complete" not in readme
    assert "does not install a global `opensquilla` command" not in readme
    assert (
        "Config, workspace, logs, memory, and runtime state use the normal "
        "user-level OpenSquilla directory." in readme
    )
    assert ".opensquilla/config.toml" not in readme


def test_prepare_release_tree_writes_user_surface_and_manifest(tmp_path: Path) -> None:
    module = load_script()
    release_root = tmp_path / "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse"
    wheel_path = tmp_path / "opensquilla-0.1.0-py3-none-any.whl"
    wheel_path.write_bytes(b"wheel")

    bundled_wheel = module.prepare_release_tree(
        release_root,
        wheel_path,
        app_version="0.1.0",
        profile="recommended",
        platform_tag="macos-arm64",
        python_major=3,
        python_minor=12,
        include_router_assets=True,
        portable=False,
        runtime_release="",
        runtime_asset="",
    )

    assert bundled_wheel == release_root / "packages" / wheel_path.name
    assert bundled_wheel.read_bytes() == b"wheel"
    assert (release_root / "README.md").is_file()
    assert (release_root / "install.sh").is_file()
    assert (release_root / "install.ps1").is_file()
    assert (release_root / "LICENSE").is_file()
    assert (release_root / "THIRD_PARTY_NOTICES.md").is_file()
    assert not (release_root / "runtime").exists()
    assert not (release_root / "start.sh").exists()
    assert not (release_root / "start.ps1").exists()
    assert (release_root / "manifest.json").is_file()
    assert_executable_on_posix(release_root / "install.sh")
    readme = (release_root / "README.md").read_text(encoding="utf-8")
    manifest = (release_root / "manifest.json").read_text(encoding="utf-8")
    assert "bash install.sh" in readme
    assert ".\\install.ps1" not in readme
    assert "Build target:" in readme
    assert "Configuration" not in readme
    assert "Notes" not in readme
    assert "Git repository" not in readme
    assert '"platform_tag": "macos-arm64"' in manifest
    assert '"profile": "recommended"' in manifest
    assert '"include_router_assets": true' in manifest


def test_prepare_portable_release_tree_includes_runtime_and_start_scripts(tmp_path: Path) -> None:
    module = load_script()
    release_root = tmp_path / "OpenSquilla-0.1.0-macos-arm64-py312-recommended-portable"
    wheel_path = tmp_path / "opensquilla-0.1.0-py3-none-any.whl"
    runtime_root = tmp_path / "runtime"
    (runtime_root / "bin").mkdir(parents=True)
    (runtime_root / "bin" / "python3").write_text("python", encoding="utf-8")
    (runtime_root / "Lib" / "__pycache__").mkdir(parents=True)
    (runtime_root / "Lib" / "module.py").write_text("print('ok')\n", encoding="utf-8")
    (runtime_root / "Lib" / "__pycache__" / "module.cpython-312.pyc").write_bytes(b"cache")
    wheel_path.write_bytes(b"wheel")

    module.prepare_release_tree(
        release_root,
        wheel_path,
        app_version="0.1.0",
        profile="recommended",
        platform_tag="macos-arm64",
        python_major=3,
        python_minor=12,
        include_router_assets=True,
        portable=True,
        runtime_release="20260414",
        runtime_asset="cpython-3.12.13+20260414-aarch64-apple-darwin-install_only_stripped.tar.gz",
        runtime_root=runtime_root,
    )

    assert (release_root / "runtime" / "python" / "bin" / "python3").is_file()
    assert (release_root / "runtime" / "python" / "Lib" / "module.py").is_file()
    assert not (release_root / "runtime" / "python" / "Lib" / "__pycache__").exists()
    assert (release_root / "start.sh").is_file()
    assert (release_root / "start.ps1").is_file()
    assert "opensquilla.cli.main" in (release_root / "start.sh").read_text(encoding="utf-8")
    assert "opensquilla.cli.main" in (release_root / "start.ps1").read_text(
        encoding="utf-8"
    )
    assert not (release_root / "Start OpenSquilla.cmd").exists()
    assert (release_root / "LICENSE").is_file()
    assert (release_root / "THIRD_PARTY_NOTICES.md").is_file()
    assert not (release_root / "install.sh").exists()
    assert not (release_root / "install.ps1").exists()
    assert_executable_on_posix(release_root / "start.sh")
    manifest = (release_root / "manifest.json").read_text(encoding="utf-8")
    assert '"portable": true' in manifest
    assert '"runtime_release": "20260414"' in manifest
    assert "install_only_stripped.tar.gz" in manifest


def test_prune_portable_runtime_removes_packaging_tools_and_bytecode(
    tmp_path: Path,
) -> None:
    module = load_script()
    runtime_root = tmp_path / "runtime"
    site_packages = runtime_root / "Lib" / "site-packages"
    long_license_path = (
        site_packages
        / "pip-26.0.1.dist-info"
        / "licenses"
        / "src"
        / "pip"
        / "_vendor"
        / "dependency_groups"
    )
    long_license_path.mkdir(parents=True)
    (long_license_path / "LICENSE.txt").write_text("license\n", encoding="utf-8")
    for name in ("pip", "setuptools", "wheel", "_distutils_hack", "pkg_resources"):
        package = site_packages / name
        package.mkdir(parents=True)
        (package / "__init__.py").write_text("", encoding="utf-8")
    for name in ("setuptools-80.0.0.dist-info", "wheel-0.45.0.dist-info"):
        dist_info = site_packages / name
        dist_info.mkdir(parents=True)
        (dist_info / "METADATA").write_text("Name: test\n", encoding="utf-8")
    (site_packages / "opensquilla_runtime_dep").mkdir(parents=True)
    (site_packages / "opensquilla_runtime_dep" / "__init__.py").write_text(
        "VALUE = 1\n",
        encoding="utf-8",
    )
    pycache = runtime_root / "Lib" / "__pycache__"
    pycache.mkdir(parents=True)
    (pycache / "module.cpython-312.pyc").write_bytes(b"cache")

    module.prune_portable_runtime(runtime_root)

    assert not (site_packages / "pip").exists()
    assert not (site_packages / "pip-26.0.1.dist-info").exists()
    assert not (site_packages / "setuptools").exists()
    assert not (site_packages / "setuptools-80.0.0.dist-info").exists()
    assert not (site_packages / "wheel").exists()
    assert not (site_packages / "wheel-0.45.0.dist-info").exists()
    assert not (site_packages / "_distutils_hack").exists()
    assert not (site_packages / "pkg_resources").exists()
    assert not pycache.exists()
    assert (site_packages / "opensquilla_runtime_dep" / "__init__.py").is_file()


def test_prepare_windows_portable_release_tree_includes_double_click_launcher(
    tmp_path: Path,
) -> None:
    module = load_script()
    release_root = tmp_path / "OpenSquilla-0.1.0-windows-x64-py312-recommended-portable"
    wheel_path = tmp_path / "opensquilla-0.1.0-py3-none-any.whl"
    runtime_root = tmp_path / "runtime"
    runtime_root.mkdir()
    (runtime_root / "python.exe").write_text("python", encoding="utf-8")
    wheel_path.write_bytes(b"wheel")

    module.prepare_release_tree(
        release_root,
        wheel_path,
        app_version="0.1.0",
        profile="recommended",
        platform_tag="windows-x64",
        python_major=3,
        python_minor=12,
        include_router_assets=True,
        portable=True,
        runtime_release="20260414",
        runtime_asset="cpython-3.12.13+20260414-x86_64-pc-windows-msvc-install_only_stripped.tar.gz",
        runtime_root=runtime_root,
    )

    launcher = release_root / "Start OpenSquilla.cmd"
    assert launcher.is_file()
    assert launcher.read_bytes() == module.render_start_cmd().encode("utf-8")
    cli = release_root / "opensquilla.cmd"
    assert cli.is_file()
    cli_text = cli.read_text(encoding="utf-8")
    assert "start.ps1\" -Cli %*" in cli_text
    shell = release_root / "OpenSquilla Shell.cmd"
    assert shell.is_file()
    shell_text = shell.read_text(encoding="utf-8")
    assert "function global:opensquilla" in shell_text
    assert "opensquilla.cmd" in shell_text
    readme = (release_root / "README.md").read_text(encoding="utf-8")
    assert "Right-click `Start OpenSquilla.cmd`" in readme
    assert "Run as administrator" in readme
    assert "Smart App Control" in readme
    assert "run\n`OpenSquilla Shell.cmd`" in readme
    assert ".\\opensquilla.cmd onboard" in readme
    assert "Closing it stops the gateway." in readme
    assert "Advanced portable usage" in readme
    start_ps1 = (release_root / "start.ps1").read_text(encoding="utf-8")
    assert "Test-WindowsVCRedistInstalled" in start_ps1
    assert "RuntimeInformation]::IsOSPlatform" in start_ps1
    assert "$RequiresRouterRuntime = $true" in start_ps1
    assert '"opensquilla[recommended,feishu]" -notmatch' not in start_ps1
    assert "OPENSQUILLA_SKIP_VC_REDIST" in start_ps1
    assert "Microsoft.VCRedist.2015+.x64" in start_ps1
    assert "https://aka.ms/vs/17/release/vc_redist.x64.exe" in start_ps1
    assert "safe router fallback" in start_ps1
    assert "If automatic installation fails, install it manually" in start_ps1
    assert "After installing, reopen PowerShell and restart OpenSquilla" in start_ps1
    assert "$env:PYTHONUTF8 = '1'" in start_ps1
    assert "$env:PYTHONIOENCODING = 'utf-8:replace'" in start_ps1


def test_install_portable_wheelhouse_preinstalls_into_bundled_python(
    tmp_path: Path,
) -> None:
    module = load_script()
    release_root = tmp_path / "release"
    package_dir = release_root / "packages"
    site_packages = release_root / "runtime" / "python" / "Lib" / "site-packages"
    package_dir.mkdir(parents=True)
    site_packages.mkdir(parents=True)
    wheel_path = package_dir / "demo-0.1.0-py3-none-any.whl"
    with ZipFile(wheel_path, "w") as wheel:
        wheel.writestr("demo_pkg/__init__.py", "VALUE = 1\n")
        wheel.writestr("demo-0.1.0.dist-info/METADATA", "Name: demo\n")
        wheel.writestr("demo-0.1.0.data/purelib/demo_extra.py", "EXTRA = 2\n")
        wheel.writestr("demo-0.1.0.data/scripts/demo-script.py", "print('skip')\n")

    module.install_portable_wheelhouse(release_root)

    assert (site_packages / "demo_pkg" / "__init__.py").read_text(encoding="utf-8") == (
        "VALUE = 1\n"
    )
    assert (site_packages / "demo_extra.py").read_text(encoding="utf-8") == "EXTRA = 2\n"
    assert not (site_packages / "demo-script.py").exists()


def test_create_zip_contains_release_directory_and_preserves_install_mode(tmp_path: Path) -> None:
    module = load_script()
    release_root = tmp_path / "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse"
    packages = release_root / "packages"
    packages.mkdir(parents=True)
    (packages / "opensquilla-0.1.0-py3-none-any.whl").write_bytes(b"wheel")
    install_script = release_root / "install.sh"
    install_script.write_text("#!/usr/bin/env bash\n", encoding="utf-8")
    install_script.chmod(0o755)
    (release_root / "install.ps1").write_text("Write-Host ok\n", encoding="utf-8")
    (release_root / "README.md").write_text("readme\n", encoding="utf-8")
    (release_root / "manifest.json").write_text("{}\n", encoding="utf-8")
    zip_path = tmp_path / "release.zip"

    module.create_zip(release_root, zip_path)

    with ZipFile(zip_path) as archive:
        names = set(archive.namelist())
        install_info = archive.getinfo(
            "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse/install.sh"
        )

    assert names == {
        "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse/README.md",
        "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse/install.ps1",
        "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse/install.sh",
        "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse/manifest.json",
        "OpenSquilla-0.1.0-macos-arm64-py312-recommended-wheelhouse/packages/opensquilla-0.1.0-py3-none-any.whl",
    }
    assert stat.S_IMODE(install_info.external_attr >> 16) & stat.S_IXUSR


def test_create_zip_preserves_runtime_executable_mode(tmp_path: Path) -> None:
    module = load_script()
    release_root = tmp_path / "OpenSquilla-0.1.0-macos-arm64-py312-recommended-portable"
    python_bin = release_root / "runtime" / "python" / "bin" / "python3"
    python_bin.parent.mkdir(parents=True)
    python_bin.write_bytes(b"python")
    python_bin.chmod(0o755)
    (release_root / "start.sh").write_text("#!/usr/bin/env bash\n", encoding="utf-8")
    (release_root / "manifest.json").write_text("{}\n", encoding="utf-8")
    zip_path = tmp_path / "release.zip"

    module.create_zip(release_root, zip_path)

    with ZipFile(zip_path) as archive:
        python_info = archive.getinfo(
            "OpenSquilla-0.1.0-macos-arm64-py312-recommended-portable/"
            "runtime/python/bin/python3"
        )

    assert stat.S_IMODE(python_info.external_attr >> 16) & stat.S_IXUSR


def test_create_zip_can_use_short_archive_root(tmp_path: Path) -> None:
    module = load_script()
    release_root = tmp_path / "OpenSquilla-0.1.0-windows-x64-py312-recommended-portable"
    (release_root / "runtime" / "python").mkdir(parents=True)
    (release_root / "runtime" / "python" / "python.exe").write_bytes(b"python")
    zip_path = tmp_path / "release.zip"

    module.create_zip(release_root, zip_path, archive_root="OpenSquilla-0.1.0")

    with ZipFile(zip_path) as archive:
        assert archive.namelist() == ["OpenSquilla-0.1.0/runtime/python/python.exe"]


def test_write_sha256s_records_all_release_zips(tmp_path: Path) -> None:
    module = load_script()
    first = tmp_path / "OpenSquilla-0.1.0-linux-x64-py312-recommended-portable.zip"
    second = tmp_path / "OpenSquilla-0.1.0-linux-x64-py312-recommended-wheelhouse.zip"
    first.write_bytes(b"portable")
    second.write_bytes(b"wheelhouse")

    checksum_path = module.write_sha256s((second, first), tmp_path / "SHA256SUMS")

    expected = [
        f"{module.sha256_digest(first)}  {first.name}",
        f"{module.sha256_digest(second)}  {second.name}",
    ]
    assert checksum_path == tmp_path / "SHA256SUMS"
    assert checksum_path.read_text(encoding="utf-8").splitlines() == expected


def test_release_workflow_publishes_wheel_and_electron_assets_without_portable() -> None:
    workflow = WORKFLOW_PATH.read_text(encoding="utf-8")

    assert "concurrency:" in workflow
    assert "release-assets-${{" in workflow
    assert "cancel-in-progress: false" in workflow
    assert "timeout-minutes: 90" in workflow
    assert workflow.count("timeout-minutes: 150") == 2
    assert workflow.count("timeout-minutes: 75") == 2
    assert "timeout-minutes: 20" in workflow
    assert "build-desktop-macos:" in workflow
    assert "build-desktop-windows:" in workflow
    assert "Validate workflow inputs" in workflow
    assert "python_runtime_release" not in workflow
    assert "python_runtime_version" not in workflow
    assert "persist-credentials: false" in workflow
    assert "bundle_python_runtime:" not in workflow
    assert "--platform-tag windows-x64" not in workflow
    assert "platform_tag: macos-arm64" not in workflow
    assert "platform_tag: linux-x64" not in workflow
    assert "for mode in portable wheelhouse" not in workflow
    assert "--bundle-python-runtime" not in workflow
    assert "uv build --wheel --out-dir dist" in workflow
    assert "expected one versioned portable zip" not in workflow
    assert "expected one versioned wheel" in workflow
    assert "manifest[\"portable\"] is True" not in workflow
    assert "SHA256SUMS" in workflow
    assert "manifest.version" not in workflow
    assert "GH_REPO: ${{ github.repository }}" in workflow
    assert "0.5+ release assets must not include Windows portable zips" in workflow
    assert "if not is_prerelease:" not in workflow
    assert "OpenSquilla-windows-x64-portable.zip" not in workflow
    assert "desktop_asset_version" in workflow
    assert "OpenSquilla-{desktop_version}-mac-arm64.dmg" in workflow
    assert "OpenSquilla-{desktop_version}-win-x64.exe" in workflow
    assert "opensquilla-latest-py3-none-any.whl" not in workflow
    assert "gh release upload \"${TAG}\" dist/* --clobber" in workflow
    assert "dist/*.zip dist/*.zip.sha256 dist/SHA256SUMS" not in workflow
    assert "Git LFS pointer leaked into wheel" in workflow
    assert "Verify GitHub Release assets" in workflow
    assert "release\", \"delete-asset\", tag, name, \"--yes\"" in workflow
    assert "name.endswith(\".sha256\")" in workflow
    assert '["gh", "release", "view", tag, "--json", "assets"]' in workflow
    assert "Unexpected GitHub Release assets" in workflow
    assert "\"unexpected\": unexpected" in workflow
    assert "zip_path.stem" not in workflow
    assert "archive_roots =" not in workflow
    assert "root = archive_roots[0] + \"/\"" not in workflow


def test_release_workflow_publishes_from_version_tags() -> None:
    workflow = WORKFLOW_PATH.read_text(encoding="utf-8")

    assert "tags:" in workflow
    assert '- "v*"' in workflow
    assert "contents: write" in workflow
    assert "RELEASE_TAG:" in workflow
    assert "RELEASE_PROFILE:" in workflow
    assert "github.ref_name" in workflow
    assert "github.event.inputs.tag" in workflow
    assert "github.event_name == 'push' || github.event.inputs.tag != ''" in workflow
    assert "TAG: ${{ env.RELEASE_TAG }}" in workflow