"""Torch-free tests for the 13x13 difficulty ladder and the graded
generator behind it.

Run from the repository root with the package installed.
"""
from maze_lab.difficulty import (GRID_SIZE, LEVEL_SPECS, LEVELS, ROOMS, analyse,
                                 build, qualifies, search_seeds, suite)
from maze_lab.maze_generator import (_carve, _pick_start_goal, _room_path,
                                     generate_graded_maze)
from maze_lab.benchmark import score


def test_every_maze_is_exactly_13x13():
    for level, seed, m, _st in suite():
        assert len(m.grid) == GRID_SIZE == 13, f"L{level} seed={seed}: {len(m.grid)} rows"
        assert all(len(row) == 13 for row in m.grid), f"L{level} seed={seed}: ragged grid"


def test_every_maze_is_solvable():
    for level, seed, m, st in suite():
        assert m.bfs_distance_to_goal(m.start) is not None, f"L{level} seed={seed} unreachable"
        assert m.simulate(m.start, st["solution"])["reached_goal"]


def test_recorded_seeds_still_qualify():
    """The hardcoded LEVELS must match what LEVEL_SPECS asks for -- this is
    what stops a tweak to the generator from silently re-grading the suite."""
    for level, seeds in LEVELS.items():
        assert len(seeds) == 3, f"L{level} has {len(seeds)} seeds, expected 3"
        for seed in seeds:
            assert qualifies(level, build(level, seed)), (
                f"L{level} seed={seed} no longer meets {LEVEL_SPECS[level]}")


def test_seeds_are_distinct_across_levels():
    flat = [s for seeds in LEVELS.values() for s in seeds]
    assert len(flat) == len(set(flat)), "a seed is reused across levels"


def test_difficulty_increases_monotonically():
    """Mean route length and mean decision points must both rise with level
    -- otherwise the 'ladder' isn't one."""
    means = {}
    for level in sorted(LEVELS):
        rows = [analyse(build(level, s)) for s in LEVELS[level]]
        means[level] = (sum(r["moves"] for r in rows) / len(rows),
                        sum(r["decision_pts"] for r in rows) / len(rows))
    levels = sorted(means)
    for lo, hi in zip(levels, levels[1:]):
        assert means[hi][0] > means[lo][0], f"L{hi} no longer than L{lo}: {means}"
        assert means[hi][1] >= means[lo][1], f"L{hi} has fewer decisions than L{lo}: {means}"


def test_traps_never_create_a_shortcut():
    """The core safety property of graded traps: the route through the
    finished maze is exactly the room path, two char-moves per room hop.
    Any trap that opened a shortcut or a loop would make this shorter."""
    import random
    for seed in range(30):
        m = generate_graded_maze(seed, rooms=ROOMS, target_moves=40, n_traps=8, max_trap_depth=4)
        passages = _carve(random.Random(seed), ROOMS)
        a, b, _da = _pick_start_goal(passages, ROOMS, 40)
        expected = 2 * (len(_room_path(passages, ROOMS, a, b)) - 1)
        assert m.bfs_distance_to_goal(m.start) == expected, f"seed={seed} shortcut opened"


def test_graded_generator_is_deterministic():
    a = generate_graded_maze(5, rooms=ROOMS, target_moves=40, n_traps=6, max_trap_depth=3)
    b = generate_graded_maze(5, rooms=ROOMS, target_moves=40, n_traps=6, max_trap_depth=3)
    assert a.grid == b.grid and a.start == b.start and a.goal == b.goal


def test_graded_generator_beats_sparse_on_decision_points():
    """The reason generate_graded_maze exists at all -- if this stops being
    true, use generate_sparse_maze and delete the new one."""
    from maze_lab.maze_generator import generate_sparse_maze
    def mean_dp(fn):
        return sum(analyse(fn(s))["decision_pts"] for s in range(30)) / 30
    graded = mean_dp(lambda s: generate_graded_maze(s, rooms=ROOMS, target_moves=40,
                                                    n_traps=6, max_trap_depth=3))
    sparse = mean_dp(lambda s: generate_sparse_maze(s, rooms=ROOMS, target_moves=40,
                                                    n_traps=6, max_trap_depth=3))
    assert graded > sparse + 1.0, f"graded={graded:.2f} vs sparse={sparse:.2f}"


def test_search_is_reproducible():
    assert search_seeds(2, want=3, exclude=set(LEVELS[1])) == LEVELS[2]


def test_scoring_grades_each_failure_kind():
    _lvl, _seed, m, st = suite()[0]
    ident = lambda r: r

    good = score(m, st["solution"], ident)
    assert good["solved"] and good["failure"] is None

    assert score(m, None, ident)["failure"] == "no_final_answer"

    truncated = score(m, st["solution"][:3], ident)
    assert not truncated["solved"] and truncated["failure"] == "stopped_short"
    assert truncated["dist_remaining"] == len(st["solution"]) - 3

    gave_up = score(m, "no path exists.", ident)
    assert not gave_up["solved"] and gave_up["failure"] == "no_moves_in_answer"

    # first move of the real solution, reversed, must walk into a wall
    flip = {"U": "D", "D": "U", "L": "R", "R": "L"}
    wall = score(m, flip[st["solution"][0]], ident)
    assert not wall["solved"] and wall["failure"] == "hit_wall"
    assert wall["valid_prefix_len"] == 0


def _main():
    fns = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
    for fn in fns:
        fn()
        print(f"  ok  {fn.__name__}")
    print(f"\n{len(fns)} tests passed")


if __name__ == "__main__":
    _main()