"""The Hugging Face Space's wiring: the knobs, the shipped cache, and the build pins.

Every one of these is a thing that fails only on the Hub, minutes into a build or on the first
visitor, where the feedback loop is slow and the error is someone else's log.
"""
import importlib
import os
import re
from pathlib import Path

import numpy as np
import pytest

from ulens import axes, basis

ROOT = Path(__file__).resolve().parents[1]
CACHE = ROOT / "space" / "cache"


# ---------------------------------------------------------------------- the shipped cache
def test_the_stack_ships_so_startup_needs_no_lens():
    """Without it the first visitor waits on a 388 MB checkpoint and a basis build."""
    st = axes.load_stack(CACHE / "stacks" / "qwen3.5-4b-v1.npz")
    assert st.U.shape[1:] == (2560, 4)
    assert len(st.blocks) == 31
    assert st.meta.get("terms_version") == "v1", "field() rebuilds when the version disagrees"


@pytest.mark.parametrize("block", [20, 23])
def test_both_single_block_bases_ship(block):
    """20 is where the state is read, 23 where the axes decode; both are asked for by name."""
    cone = basis.load(CACHE / "bases" / f"qwen3.5-4b-b{block}-v1.npz")
    assert cone.block == block
    assert cone.names[0] == "ambiguity"


def test_the_vocabulary_norms_ship_for_the_decode_block():
    n = np.load(CACHE / "vocab_norms" / "qwen3.5-4b-b23.npy")
    assert n.ndim == 1 and n.dtype == np.float32 and np.all(n > 0)


def test_the_cache_layout_is_the_one_the_resolvers_look_in(monkeypatch):
    """`ULENS_CACHE` is the only thing pointing the package at these files."""
    monkeypatch.setenv("ULENS_CACHE", str(CACHE))
    assert basis.stack_path("qwen3.5-4b").exists()
    assert basis.cache_path("qwen3.5-4b", 20).exists()
    assert basis.cache_path("qwen3.5-4b", 23).exists()


# ---------------------------------------------------------------------- the knobs
@pytest.mark.parametrize("env,tokens,default,think", [
    ({}, 2048, 1024, "on"),
    ({"ULENS_APP_MAX_TOKENS": "512", "ULENS_APP_THINK": "off"}, 512, 512, "off"),
    ({"ULENS_APP_MAX_TOKENS": "1"}, 256, 256, "on"),        # the slider's floor wins
    ({"ULENS_APP_THINK": "0"}, 2048, 1024, "off"),
])
def test_the_budget_and_thinking_knobs(monkeypatch, env, tokens, default, think):
    """The Space pays for a run out of the visitor's quota, so it ships smaller defaults."""
    for k in ("ULENS_APP_MAX_TOKENS", "ULENS_APP_THINK"):
        monkeypatch.delenv(k, raising=False)
    for k, v in env.items():
        monkeypatch.setenv(k, v)
    monkeypatch.setenv("ULENS_APP_LOAD_MODEL", "0")
    app = importlib.reload(importlib.import_module("ulens.app"))
    try:
        assert (app.MAX_TOKENS, app.BUDGET_DEFAULT, app.THINK_DEFAULT) == (tokens, default, think)
    finally:
        for k in ("ULENS_APP_MAX_TOKENS", "ULENS_APP_THINK"):
            os.environ.pop(k, None)
        importlib.reload(app)


# ---------------------------------------------------------------------- the build
def test_torch_is_pinned_below_what_zerogpu_refuses():
    """ZeroGPU supports 2.8.0 through 2.13.0. The package asks only for >=2.0, so pip would
    otherwise resolve to the newest release and the Space would never get a GPU."""
    req = (ROOT / "requirements.txt").read_text()
    m = re.search(r"^torch==(\d+)\.(\d+)\.", req, re.M)
    assert m, "requirements.txt must pin torch exactly"
    assert (int(m.group(1)), int(m.group(2))) <= (2, 13)


def test_the_space_front_matter_names_the_entry_point_that_exists():
    head = (ROOT / "README.md").read_text().split("---")[1]
    assert re.search(r"^sdk:\s*gradio\s*$", head, re.M), "ZeroGPU is Gradio-only"
    app_file = re.search(r"^app_file:\s*(\S+)\s*$", head, re.M)
    assert app_file and (ROOT / app_file.group(1)).exists()


def test_the_entry_point_sets_the_cache_before_importing_the_package():
    """Import order is load-bearing: `basis.cache_dir()` reads the variable at call time, but
    anything that resolves at import would miss a value set afterwards."""
    src = (ROOT / "space.py").read_text()
    assert src.index('os.environ.setdefault("ULENS_CACHE"') < src.index("from ulens")


def test_the_entry_point_puts_src_on_the_path_before_importing_it():
    """The package is imported from `src/`, not installed — see requirements.txt."""
    src = (ROOT / "space.py").read_text()
    assert 'sys.path.insert(0, str(HERE / "src"))' in src
    assert src.index("sys.path.insert") < src.index("from ulens")


def test_requirements_does_not_install_the_package_from_a_path():
    """The Hub mounts requirements.txt alone at /tmp and runs pip from a directory that is not
    the repo, so `.` and `-e .` have no pyproject.toml to find: the first build died on
    `Directory '.[app]' is not installable`."""
    for line in _req_lines():
        assert not line.startswith((".", "-e", "./")), line


def _req_lines() -> list[str]:
    return [ln.strip() for ln in (ROOT / "requirements.txt").read_text().splitlines()
            if ln.strip() and not ln.lstrip().startswith("#")]


def test_requirements_covers_every_dependency_of_the_app_extra():
    """requirements.txt restates what `pip install ulens[app]` would have pulled in, so it can
    drift from pyproject.toml. gradio is the one exception: the Hub installs the version named
    by `sdk_version` in the README and a second pin here would fight it."""
    import tomllib
    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text())
    proj = pyproject["project"]
    extras = proj["optional-dependencies"]

    def closure(name: str) -> set[str]:
        """Package names `ulens[<name>]` resolves to, following `ulens[...]` self-references."""
        out = set()
        for dep in extras[name]:
            if dep.startswith("ulens["):
                out |= closure(dep.split("[")[1].rstrip("]"))
            else:
                out.add(_name(dep))
        return out

    wanted = closure("app") | {_name(d) for d in proj["dependencies"]}
    have = {_name(ln) for ln in _req_lines()}
    missing = wanted - have - {"gradio"}
    assert not missing, f"requirements.txt is missing {sorted(missing)}"


def _name(dep: str) -> str:
    """The distribution name of a requirement line, normalised."""
    return re.split(r"[\[<>=!~ ;]", dep, maxsplit=1)[0].strip().lower().replace("_", "-")


def test_the_link_bar_clears_the_badge_the_hub_pins_over_the_page(monkeypatch):
    """A page served from hf.space gets an owner/likes badge fixed at the top right, ~280px
    wide, which covered "Read the blog" and "See the code" entirely on the first deploy."""
    monkeypatch.setenv("SPACE_ID", "loose-bits/u-space")
    monkeypatch.setenv("ULENS_APP_LOAD_MODEL", "0")
    app = importlib.reload(importlib.import_module("ulens.app"))
    try:
        assert app.ON_SPACE
        assert "ul-hosted" in app.intro_html()
        assert ".ul-hosted .ul-links { margin-right:" in app.CSS
    finally:
        os.environ.pop("SPACE_ID", None)
        importlib.reload(app)


def test_the_link_bar_is_unchanged_off_the_hub(monkeypatch):
    monkeypatch.delenv("SPACE_ID", raising=False)
    monkeypatch.setenv("ULENS_APP_LOAD_MODEL", "0")
    app = importlib.reload(importlib.import_module("ulens.app"))
    assert not app.ON_SPACE
    assert "ul-hosted" not in app.intro_html()