"""v3 software families: render 1, oracle script 1, nothing/empty/one-value-perturbed 0, on three seeds per level,
plus the trap each level adds: the common mistake, replayed through the oracle script, scores 0."""

import json
import os
import sys
import tempfile

import pytest

if "TERMINAL_DESK_ROOTS" not in os.environ:
    _base = tempfile.mkdtemp(prefix="td-test-")
    os.chmod(_base, 0o755)  # nobody traverses it when the suite runs as root
    os.environ["TERMINAL_DESK_ROOTS"] = _base
sys.path.insert(0, os.path.dirname(__file__))

from terminal_desk.core.grading import render_artifact  # noqa: E402
from terminal_desk.families import FAMILIES  # noqa: E402
from terminal_desk.models import Tbench2Action  # noqa: E402
from terminal_desk.oracles import oracle_source, run_oracle  # noqa: E402
from terminal_desk.server.environment import TerminalDeskEnvironment  # noqa: E402
from test_episodes import _evaluate, _sh, _write_oracle  # noqa: E402

FAMS = ("sw3_fix_module", "sw3_rate_limit", "sw3_dep_lock")
IDS = [f"{f}-L{lv}" for f in FAMS for lv in (1, 2, 3)]
SEEDS = (1, 2, 3)


def _env(task_id, seed):
    env = TerminalDeskEnvironment(allow_seed=True)
    env.reset(task_id=task_id, seed=seed)
    return env, env._ep["built"]


def _write(env, path, content):
    obs = env.step(Tbench2Action(action_type="write_file", file_path=path, content=content))
    assert obs.success, obs.error


def _perturb(task_id, built) -> str:
    """The rendered answer with one value changed."""
    good = render_artifact(built.artifact)
    if task_id.startswith("sw3_rate_limit"):
        ids = json.loads(good)
        return json.dumps(ids[:-1] + [ids[-1] + 1])  # last rejected id swapped for its neighbour
    if task_id.startswith("sw3_dep_lock"):
        lines = good.split("\n")
        name, ver = lines[0].split("==")
        major, minor = ver.split(".")
        lines[0] = f"{name}=={major}.{int(minor) + 1}"
        return "\n".join(lines)
    # fix_module: the first buggy function keeps its planted bug, every other function is fixed
    name, bad = built.notes["buggy"][0], built.files[built.artifact.path]
    return good.replace(_block(good, name), _block(bad, name))


def _block(text: str, name: str) -> str:
    start = text.index(f"def {name}(")
    end = text.find("\n\n\ndef ", start)
    return text[start:] if end < 0 else text[start:end]


@pytest.mark.parametrize("task_id", IDS)
@pytest.mark.parametrize("seed", SEEDS)
def test_render_and_oracle_score_one(task_id, seed):
    env, built = _env(task_id, seed)
    assert 600 <= len(built.instruction) <= 1000 and f"{built.root}/{built.artifact.path}" in built.instruction
    _write_oracle(env)
    obs = _evaluate(env)
    assert obs.reward == 1.0, obs.output
    env.reset(task_id=task_id, seed=seed)
    out, obs = run_oracle(env, oracle_source(task_id.rpartition("-L")[0]))
    assert obs.reward == 1.0, (out, obs.output)


@pytest.mark.parametrize("task_id", IDS)
@pytest.mark.parametrize("seed", SEEDS)
def test_nothing_empty_and_perturbed_score_zero(task_id, seed):
    env, built = _env(task_id, seed)
    obs = _evaluate(env)  # fix_module's artifact is the unfixed input module; the others have no file yet
    assert obs.reward == 0.0 and "FAILED tests/test_outputs.py::test_" in obs.output
    env.reset(task_id=task_id, seed=seed)
    _write(env, built.artifact.path, "")
    assert _evaluate(env).reward == 0.0
    env.reset(task_id=task_id, seed=seed)
    _write(env, built.artifact.path, _perturb(task_id, built))
    obs = _evaluate(env)
    assert obs.reward == 0.0 and obs.info["assertions_passed"] >= 1, obs.output


@pytest.mark.parametrize("seed", SEEDS)
def test_rate_limit_traps_score_zero(seed):
    src = oracle_source("sw3_rate_limit")
    traps = {
        2: [src.replace('reqs.sort(key=lambda r: (float(r["ts"]), int(r["id"])))', ""),  # file order
            src.replace('exempt = set(cfg.get("exempt_keys", []))', "exempt = set()")],
        3: [src.replace('if os.path.exists("CHANGE_NOTICE.md"):', "if False:")],
    }
    for level in (1, 2, 3):
        variants = [src.replace("tokens = min(cap, tokens + (ts - last) * rate)",
                                "tokens = min(cap, tokens + int(ts - last) * rate)")]  # whole-second refill
        variants += [v for lv, vs in traps.items() if lv <= level for v in vs]
        for variant in variants:
            assert variant != src
            env, _ = _env(f"sw3_rate_limit-L{level}", seed)
            out, obs = run_oracle(env, variant)
            assert obs.reward == 0.0, (level, out)


@pytest.mark.parametrize("seed", SEEDS)
def test_dep_lock_traps_score_zero(seed):
    src = oracle_source("sw3_dep_lock")
    string_compare = src.replace('return tuple(int(x) for x in v.split("."))', 'return tuple(v.split("."))')
    ignore_yanked = src.replace('if os.path.exists("yanked.txt"):', "if False:")
    newest_each = src.replace("best = None", "best = None\nfor p in pkgs:\n    releases[p] = "
                              "{max(releases[p], key=vkey): releases[p][max(releases[p], key=vkey)]}")
    for level, variants in ((1, [newest_each]), (2, [string_compare, newest_each]),
                            (3, [string_compare, ignore_yanked, newest_each])):
        for variant in variants:
            assert variant != src
            env, _ = _env(f"sw3_dep_lock-L{level}", seed)
            out, obs = run_oracle(env, variant)
            assert obs.reward == 0.0, (level, out)


@pytest.mark.parametrize("seed", SEEDS)
def test_fix_module_docstring_only_fix_fails_when_changelog_revises(seed):
    src = oracle_source("sw3_fix_module")
    src = src.replace(r'REV = sorted(set(re.findall(r"### Changed\n- `(\w+)`", log)))', "REV = []")
    assert "REV = []\n" in src
    for level in (2, 3):
        env, built = _env(f"sw3_fix_module-L{level}", seed)
        assert built.notes["revised"] and "CHANGELOG.md" in built.files
        out, obs = run_oracle(env, src)
        assert obs.reward == 0.0, out
        assert f"FAILED tests/test_outputs.py::test_{built.notes['revised']}" in obs.output


@pytest.mark.parametrize("level", (1, 2, 3))
def test_fix_module_visible_tests_fail_before_and_pass_after(level):
    env, built = _env(f"sw3_fix_module-L{level}", 5)
    before = _sh(env, "python3 -m unittest discover -s tests 2>&1 | tail -n 3")
    assert "FAILED (failures=1)" in before, before
    assert "FAIL: test_" in built.files["ci/nightly.log"]
    _write_oracle(env)
    after = _sh(env, "python3 -m unittest discover -s tests 2>&1 | tail -n 3")
    assert after.endswith("OK"), after
    if level == 3:
        assert built.notes["revised"] in built.notes["buggy"]
    if level == 2:
        assert built.notes["revised"] not in built.notes["buggy"]


def test_fix_module_reads_a_planted_symlink_as_missing():
    env, built = _env("sw3_fix_module-L1", 2)
    _sh(env, f"rm {built.artifact.path} && ln -s /etc/passwd {built.artifact.path}")
    obs = _evaluate(env)
    assert obs.reward == 0.0 and "FAILED tests/test_outputs.py::test_file_exists" in obs.output


def test_fresh_instances_per_reset():
    env = TerminalDeskEnvironment()
    for fam in FAMS:
        a = env.reset(task_id=f"{fam}-L2").instruction, dict(env._ep["built"].files)
        b = env.reset(task_id=f"{fam}-L2").instruction, dict(env._ep["built"].files)
        assert a != b
        assert FAMILIES[fam].v3