"""
Comprehensive E2E Test Suite for FreeExile PoE2 Procedural Tile Map System.
Enforces 4-Tier Testing Methodology:
- Tier 1: Feature Coverage (>=5 test cases per feature area)
- Tier 2: Boundary & Corner Cases (>=5 test cases per feature area)
- Tier 3: Cross-Feature Combinations
- Tier 4: Real-World Application Scenarios
"""

from __future__ import annotations
import math
import struct
import pytest
from typing import List, Tuple

from server.world.map_data_types import TileType, MapGridData, EncounterZone, ObstacleInstance, ObstacleType
from server.world.wilderness_map_generator import WildernessMapGenerator, ZONE_DEFAULT_SIZES
from server.world.map_binary_serializer import serialize_map_grid, deserialize_map_grid
from server.world.procedural_map_engine import calculate_path_sinuosity, verify_path_connectivity
from server.world.zone_engine import ZoneEngine


def client_get_tile_at(grid: bytes, width: int, height: int, tx: int, ty: int) -> int:
    """Simulates client-side window.getTileAt(tx, ty) reading row-major Uint8Array."""
    if tx < 0 or tx >= width or ty < 0 or ty >= height:
        return TileType.WALL.value
    return grid[ty * width + tx]


class TestTier1FeatureCoverage:
    """Tier 1: Feature Coverage (>=5 test cases per feature area)."""

    # --- Feature 1: Procedural generation from seed (5 cases) ---
    def test_t1_gen_valid_grid(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(42)
        assert m.width == 60 and m.height == 45 and m.biome == "BLEACHED_BONE_CANYON"

    def test_t1_gen_canonical_zones(self) -> None:
        for zid, (w, h) in [("zone_tang_kiem_nhai", (60, 45)), ("zone_ancient_sword_barrow", (68, 52)), ("zone_boundless_celestial_palace", (120, 90))]:
            m = WildernessMapGenerator.for_zone(zid).generate(100)
            assert m.width == w and m.height == h

    def test_t1_gen_deterministic_reproducibility(self) -> None:
        m1 = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(999)
        m2 = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(999)
        assert m1.spawn_point == m2.spawn_point and m1.boss_gate == m2.boss_gate
        assert [c.tile_type for row in m1.tiles for c in row] == [c.tile_type for row in m2.tiles for c in row]

    def test_t1_gen_walkable_floors_exist(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(77)
        assert m.get_walkables_count() >= int(m.width * m.height * 0.15)

    def test_t1_gen_biome_attributes_respected(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai", biome_id="SAVAGE_MANGROVE_SWAMP").generate(55)
        assert m.biome == "SAVAGE_MANGROVE_SWAMP"

    # --- Feature 2: Binary serialization Uint8Array (5 cases) ---
    def test_t1_ser_magic_header(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(123)
        b = serialize_map_grid(m)
        assert b[:2] == b"FE" and b[2] == 1

    def test_t1_ser_header_dimensions(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(123)
        w, h = struct.unpack_from("<HH", serialize_map_grid(m), 4)
        assert w == 60 and h == 45

    def test_t1_ser_poi_and_enc_tables(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(123)
        assert len(serialize_map_grid(m)) == 16 + len(m.poi_points) * 3 + len(m.encounter_zones) * 5 + m.width * m.height

    def test_t1_ser_deserialization_fidelity(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(123)
        d = deserialize_map_grid(serialize_map_grid(m))
        assert d.width == m.width and d.height == m.height and d.spawn_point == m.spawn_point and d.boss_gate == m.boss_gate

    def test_t1_ser_tile_matrix_equality(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(123)
        d = deserialize_map_grid(serialize_map_grid(m))
        assert all(m.tiles[y][x].tile_type == d.tiles[y][x].tile_type for y in range(m.height) for x in range(m.width))

    # --- Feature 3: Safe radius 8 at spawn (5 cases) ---
    def test_t1_spawn_center_is_floor(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(321)
        sx, sy = m.spawn_point
        assert m.tiles[sy][sx].tile_type in (TileType.FLOOR, TileType.PATH) and m.tiles[sy][sx].walkable

    def test_t1_spawn_radius_8_all_floors(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(321)
        sx, sy = m.spawn_point
        safe_tiles = [m.tiles[y][x].tile_type for y in range(max(1, sy - 8), min(m.height - 1, sy + 9))
                      for x in range(max(1, sx - 8), min(m.width - 1, sx + 9)) if (x - sx) ** 2 + (y - sy) ** 2 <= 64]
        assert all(t in (TileType.FLOOR, TileType.PATH) for t in safe_tiles)

    def test_t1_spawn_radius_8_all_walkable(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(321)
        sx, sy = m.spawn_point
        assert all(m.tiles[y][x].walkable for y in range(max(1, sy - 8), min(m.height - 1, sy + 9))
                   for x in range(max(1, sx - 8), min(m.width - 1, sx + 9)) if (x - sx) ** 2 + (y - sy) ** 2 <= 64)

    def test_t1_spawn_radius_8_blocks_vision_false(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(321)
        sx, sy = m.spawn_point
        assert not any(m.tiles[y][x].blocks_vision for y in range(max(1, sy - 8), min(m.height - 1, sy + 9))
                       for x in range(max(1, sx - 8), min(m.width - 1, sx + 9)) if (x - sx) ** 2 + (y - sy) ** 2 <= 64)

    def test_t1_spawn_perimeter_connected(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(321)
        sx, sy = m.spawn_point
        assert any([m.tiles[sy][sx + 8].walkable, m.tiles[sy][sx - 8].walkable, m.tiles[sy + 8][sx].walkable])

    # --- Feature 4: Winding main path sinuosity >= 1.25 (5 cases) ---
    def test_t1_path_connectivity_exists(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(500)
        ok, path = verify_path_connectivity(m, m.spawn_point, m.boss_gate)
        assert ok is True and len(path) > 0

    def test_t1_path_sinuosity_tang_kiem_nhai(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(500)
        _, path = verify_path_connectivity(m, m.spawn_point, m.boss_gate)
        assert calculate_path_sinuosity(path, m.spawn_point, m.boss_gate) >= 1.25

    def test_t1_path_sinuosity_celestial_palace(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_boundless_celestial_palace").generate(500)
        _, path = verify_path_connectivity(m, m.spawn_point, m.boss_gate)
        assert calculate_path_sinuosity(path, m.spawn_point, m.boss_gate) >= 1.25

    def test_t1_path_contains_path_tiles(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(500)
        path_tiles = [c for row in m.tiles for c in row if c.tile_type == TileType.PATH]
        assert len(path_tiles) >= 20 and all(c.movement_cost == 0.8 for c in path_tiles)

    def test_t1_path_non_linear_nodes(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(500)
        _, path = verify_path_connectivity(m, m.spawn_point, m.boss_gate)
        assert len({p[1] for p in path}) >= 8

    # --- Feature 5: Encounter zone classification (5 cases) ---
    def test_t1_enc_zone_count_2_or_3(self) -> None:
        m_narrow = WildernessMapGenerator(width=48, height=36).generate(600)
        m_wide = WildernessMapGenerator.for_zone("zone_boundless_celestial_palace").generate(600)
        assert len(m_narrow.encounter_zones) == 2 and len(m_wide.encounter_zones) == 3

    def test_t1_enc_zone_tiers_assigned(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_boundless_celestial_palace").generate(600)
        assert [ez.tier for ez in m.encounter_zones] == [1, 2, 3]

    def test_t1_enc_tiles_classified(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(600)
        enc_types = {c.tile_type for row in m.tiles for c in row if c.tile_type in (TileType.ENCOUNTER_LOW, TileType.ENCOUNTER_MEDIUM, TileType.ENCOUNTER_HIGH)}
        assert len(enc_types) >= 2

    def test_t1_enc_zones_within_bounds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(600)
        assert all(0 <= ez.min_x < ez.max_x < m.width and 0 <= ez.min_y < ez.max_y < m.height for ez in m.encounter_zones)

    def test_t1_enc_zones_walkable(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(600)
        cells = [c for row in m.tiles for c in row if c.tile_type in (TileType.ENCOUNTER_LOW, TileType.ENCOUNTER_MEDIUM, TileType.ENCOUNTER_HIGH)]
        assert len(cells) > 0 and all(c.walkable for c in cells)

    # --- Feature 6: Dead ends (5 cases) ---
    def test_t1_dead_ends_count(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(700)
        assert 1 <= len(m.dead_end_points) <= 2

    def test_t1_dead_ends_secluded_from_boss(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(700)
        assert m.boss_room and not any(m.boss_room.contains(dx, dy) for dx, dy in m.dead_end_points)

    def test_t1_dead_ends_have_floor_clearing(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(700)
        assert all(m.tiles[dy][dx].tile_type in (TileType.FLOOR, TileType.POI, TileType.PATH) and m.tiles[dy][dx].walkable for dx, dy in m.dead_end_points)

    def test_t1_dead_ends_connected_to_path(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(700)
        assert all(verify_path_connectivity(m, m.spawn_point, de)[0] for de in m.dead_end_points)

    def test_t1_dead_ends_terminate(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(700)
        assert all(1 <= dx < m.width - 1 and 1 <= dy < m.height - 1 for dx, dy in m.dead_end_points)

    # --- Feature 7: Boss gate isolation (5 cases) ---
    def test_t1_boss_gate_exactly_one(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(800)
        gates = [c for row in m.tiles for c in row if c.tile_type == TileType.BOSS_GATE]
        assert len(gates) == 1 and m.boss_gate == (gates[0].x, gates[0].y)

    def test_t1_boss_gate_initially_blocked(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(800)
        gx, gy = m.boss_gate
        assert m.tiles[gy][gx].walkable is False and m.tiles[gy][gx].blocks_vision is True

    def test_t1_boss_arena_perimeter_sealed(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(800)
        br = m.boss_room
        assert br is not None
        perimeter = [(x, y) for x in range(br.x, br.x + br.w) for y in (br.y, br.y + br.h - 1)] + \
                    [(x, y) for y in range(br.y, br.y + br.h) for x in (br.x, br.x + br.w - 1)]
        assert all(m.tiles[y][x].tile_type == TileType.WALL for x, y in perimeter if (x, y) != m.boss_gate)

    def test_t1_boss_arena_interior_altar(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(800)
        altars = [c for row in m.tiles for c in row if c.tile_type == TileType.BOSS_ALTAR]
        runic = [c for row in m.tiles for c in row if c.tile_type == TileType.RUNIC_FLOOR]
        assert len(altars) == 1 and len(runic) >= 8

    def test_t1_boss_gate_breach_mutates(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(800)
        gx, gy = m.boss_gate
        m.tiles[gy][gx].tile_type, m.tiles[gy][gx].walkable = TileType.FLOOR, True
        assert m.tiles[gy][gx].walkable is True

    # --- Feature 8: POI placement (5 cases) ---
    def test_t1_poi_count_1_to_3(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(900)
        assert 1 <= len(m.poi_points) <= 3

    def test_t1_poi_tile_type(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(900)
        assert all(m.tiles[py][px].tile_type == TileType.POI for px, py, _ in m.poi_points)

    def test_t1_poi_walkable(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(900)
        assert all(m.tiles[py][px].walkable for px, py, _ in m.poi_points)

    def test_t1_poi_outside_boss_arena(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(900)
        assert m.boss_room and not any(m.boss_room.contains(px, py) for px, py, _ in m.poi_points)

    def test_t1_poi_valid_kinds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(900)
        assert all(k in {"cache_shrine", "merchant_post", "ancient_tablet"} for _, _, k in m.poi_points)

    # --- Feature 9: Client grid ingestion API simulation (5 cases) ---
    def test_t1_client_row_major_indexing(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(111)
        raw = bytes(c.tile_type.value for row in m.tiles for c in row)
        assert client_get_tile_at(raw, m.width, m.height, 10, 5) == m.tiles[5][10].tile_type.value

    def test_t1_client_get_tile_inside_bounds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(111)
        raw = bytes(c.tile_type.value for row in m.tiles for c in row)
        assert client_get_tile_at(raw, m.width, m.height, m.spawn_point[0], m.spawn_point[1]) in (1, 13)

    def test_t1_client_get_tile_out_of_bounds_wall(self) -> None:
        raw = bytes(60 * 45)
        assert client_get_tile_at(raw, 60, 45, -1, 0) == 2 and client_get_tile_at(raw, 60, 45, 60, 0) == 2

    def test_t1_client_passability_check(self) -> None:
        impassable = {TileType.VOID, TileType.WALL, TileType.DESTRUCTIBLE_BARRICADE, TileType.CHASM, TileType.BOSS_GATE, TileType.WATER}
        assert all(tt.is_passable() == (tt not in impassable) for tt in TileType)

    def test_t1_client_speed_modifiers(self) -> None:
        assert TileType.PATH.movement_cost() == 0.8 and TileType.DENSE_TERRAIN.movement_cost() == 1.43


class TestTier2BoundaryAndCornerCases:
    """Tier 2: Boundary & Corner Cases (>=5 test cases per feature area)."""

    # --- Area 1: Smallest vs largest grid scaling (5 cases) ---
    def test_t2_smallest_grid_dimensions(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(1)
        assert m.width == 60 and m.height == 45 and (m.width // 16 + 1) * (m.height // 16 + 1) == 12

    def test_t2_largest_grid_dimensions(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_boundless_celestial_palace").generate(1)
        assert m.width == 120 and m.height == 90 and (m.width // 16 + 1) * (m.height // 16 + 1) == 48

    def test_t2_intermediate_grids_scale(self) -> None:
        for z in ["zone_blood_scale_ruins", "zone_abyssal_ice_pond"]:
            m = WildernessMapGenerator.for_zone(z).generate(1)
            assert (m.width, m.height) == ZONE_DEFAULT_SIZES[z] and m.get_walkables_count() > 100

    def test_t2_memory_budget_under_8mb(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_boundless_celestial_palace").generate(1)
        assert len(serialize_map_grid(m)) < 15000  # < 15 KB wire stream << 8 MB budget

    def test_t2_chunk_bounds_clamping(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_boundless_celestial_palace").generate(1)
        assert m.get_chunk_coords(m.width - 1, m.height - 1) == ((120 - 1) // 16, (90 - 1) // 16)

    # --- Area 2: Boundary coordinates (5 cases) ---
    def test_t2_boundary_corner_0_0(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(2)
        assert m.tiles[0][0].tile_type == TileType.WALL and not m.tiles[0][0].walkable

    def test_t2_boundary_corner_w_h(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(2)
        assert m.tiles[m.height - 1][m.width - 1].tile_type == TileType.WALL

    def test_t2_boundary_top_right_bottom_left(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(2)
        assert m.tiles[0][m.width - 1].tile_type == TileType.WALL and m.tiles[m.height - 1][0].tile_type == TileType.WALL

    def test_t2_boundary_perimeter_impenetrable(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(2)
        assert all(m.tiles[0][x].tile_type == TileType.WALL and m.tiles[m.height - 1][x].tile_type == TileType.WALL for x in range(m.width))

    def test_t2_boundary_float_truncation(self) -> None:
        assert int(math.floor(0.99)) == 0 and int(math.floor(-0.01)) == -1

    # --- Area 3: Out-of-bounds getTileAt (5 cases) ---
    def test_t2_oob_negative_x(self) -> None:
        assert client_get_tile_at(bytes(100), 10, 10, -1, 5) == TileType.WALL.value

    def test_t2_oob_negative_y(self) -> None:
        assert client_get_tile_at(bytes(100), 10, 10, 5, -1) == TileType.WALL.value

    def test_t2_oob_large_x(self) -> None:
        assert client_get_tile_at(bytes(100), 10, 10, 10, 5) == 2 and client_get_tile_at(bytes(100), 10, 10, 999, 5) == 2

    def test_t2_oob_large_y(self) -> None:
        assert client_get_tile_at(bytes(100), 10, 10, 5, 10) == 2 and client_get_tile_at(bytes(100), 10, 10, 5, 999) == 2

    def test_t2_oob_both_negative(self) -> None:
        assert client_get_tile_at(bytes(100), 10, 10, -99, -99) == TileType.WALL.value

    # --- Area 4: Extreme seeds (5 cases) ---
    def test_t2_seed_zero(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(0)
        assert verify_path_connectivity(m, m.spawn_point, m.boss_gate)[0] is True

    def test_t2_seed_negative_small(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(-1)
        assert verify_path_connectivity(m, m.spawn_point, m.boss_gate)[0] is True

    def test_t2_seed_negative_large(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(-999999)
        assert verify_path_connectivity(m, m.spawn_point, m.boss_gate)[0] is True

    def test_t2_seed_int32_max(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(2147483647)
        assert verify_path_connectivity(m, m.spawn_point, m.boss_gate)[0] is True

    def test_t2_seed_uint32_max(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(4294967295)
        assert verify_path_connectivity(m, m.spawn_point, m.boss_gate)[0] is True

    # --- Area 5: Spawn near border clamping (5 cases) ---
    def test_t2_spawn_safe_zone_clamped_bounds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(5)
        assert 1 <= m.spawn_point[0] < m.width - 1 and 1 <= m.spawn_point[1] < m.height - 1

    def test_t2_spawn_safe_clearing_in_bounds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(5)
        assert all(m.tiles[y][0].tile_type == TileType.WALL and m.tiles[y][m.width - 1].tile_type == TileType.WALL for y in range(m.height))

    def test_t2_boss_arena_clamped_bounds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(5)
        br = m.boss_room
        assert br and 0 <= br.x and br.x + br.w <= m.width and 0 <= br.y and br.y + br.h <= m.height

    def test_t2_dead_end_clamped_bounds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(5)
        assert all(1 <= dx < m.width - 1 and 1 <= dy < m.height - 1 for dx, dy in m.dead_end_points)

    def test_t2_poi_clamped_bounds(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(5)
        assert all(1 <= px < m.width - 1 and 1 <= py < m.height - 1 for px, py, _ in m.poi_points)


class TestTier3CrossFeatureCombinations:
    """Tier 3: Cross-Feature State Interleaving & Pairwise Combinations."""

    def test_t3_seed_variation_divergent_layouts(self) -> None:
        m1 = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(1001)
        m2 = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(2002)
        assert sum(1 for y in range(m1.height) for x in range(m1.width) if m1.tiles[y][x].tile_type != m2.tiles[y][x].tile_type) > 50

    def test_t3_encounter_zones_along_main_path(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(3003)
        _, path = verify_path_connectivity(m, m.spawn_point, m.boss_gate)
        assert all(min(math.hypot(px - (ez.min_x + ez.max_x) / 2, py - (ez.min_y + ez.max_y) / 2) for px, py in path) <= 12.0 for ez in m.encounter_zones)

    def test_t3_boss_gate_unreachable_without_breach(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(4004)
        assert verify_path_connectivity(m, m.spawn_point, m.boss_point, allow_sealed_boss_gate=False)[0] is False
        assert verify_path_connectivity(m, m.spawn_point, m.boss_point, allow_sealed_boss_gate=True)[0] is True

    def test_t3_waypoint_safe_radius_in_tile_map(self) -> None:
        ze = ZoneEngine()
        assert ze.validate_monster_spawn("zone_tang_kiem_nhai", is_dummy=False, x=150.0, y=150.0)[0] is False
        assert ze.validate_monster_spawn("zone_tang_kiem_nhai", is_dummy=False, x=0.0, y=0.0)[0] is True

    def test_t3_serialize_deserialize_preserves_path(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(5005)
        d = deserialize_map_grid(serialize_map_grid(m))
        assert verify_path_connectivity(d, d.spawn_point, d.boss_gate)[0] is True


class TestTier4RealWorldScenarios:
    """Tier 4: Real-World End-to-End Application Scenarios."""

    def test_t4_full_player_journey_simulation(self) -> None:
        # Step 1: Server generates procedural map for zone entry
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(seed=777)
        wire_bytes = serialize_map_grid(m)
        client_map = deserialize_map_grid(wire_bytes)
        # Step 2: Player spawns safely
        px, py = client_map.spawn_point
        assert client_map.tiles[py][px].tile_type in (TileType.FLOOR, TileType.PATH) and client_map.tiles[py][px].walkable
        # Step 3: Player traverses main path toward boss gate
        ok, path = verify_path_connectivity(client_map, (px, py), client_map.boss_gate)
        assert ok is True and len(path) > 20
        # Step 4: Boss gate is initially sealed on server
        assert verify_path_connectivity(m, (px, py), m.boss_point, allow_sealed_boss_gate=False)[0] is False
        # Step 5: Gate breach event
        gx, gy = m.boss_gate
        m.tiles[gy][gx].tile_type, m.tiles[gy][gx].walkable, m.tiles[gy][gx].blocks_vision = TileType.FLOOR, True, False
        m.obstacles[m.boss_gate].is_destroyed, m.obstacles[m.boss_gate].blocks_movement = True, False
        m.boss_gate_breached = True
        # Step 6: Arena accessible
        assert verify_path_connectivity(m, (px, py), m.boss_point, allow_sealed_boss_gate=True)[0] is True

    def test_t4_terrain_speed_cost_optimization(self) -> None:
        path_cost, dense_cost = TileType.PATH.movement_cost(), TileType.DENSE_TERRAIN.movement_cost()
        assert path_cost < 1.0 < dense_cost
        assert round((1.0 - path_cost) / 1.0, 2) == 0.20 and round((dense_cost - 1.0) / dense_cost, 2) == 0.30

    def test_t4_poi_ambush_and_reward_cache_scenario(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_tang_kiem_nhai").generate(888)
        poi_x, poi_y, _ = m.poi_points[0]
        assert m.tiles[poi_y][poi_x].tile_type == TileType.POI and m.tiles[poi_y][poi_x].walkable
        assert verify_path_connectivity(m, m.spawn_point, (poi_x, poi_y))[0] is True

    def test_t4_fog_of_war_reveal_state_machine(self) -> None:
        w, h, fog = 30, 20, bytearray(30 * 20)
        px, py, r = 10, 10, 4
        for y in range(max(0, py - r), min(h, py + r + 1)):
            for x in range(max(0, px - r), min(w, px + r + 1)):
                if (x - px) ** 2 + (y - py) ** 2 <= r * r:
                    fog[y * w + x] = 2
        assert fog[10 * w + 10] == 2 and fog[0] == 0
        for i in range(len(fog)):
            if fog[i] == 2:
                fog[i] = 1
        assert fog[10 * w + 10] == 1

    def test_t4_endgame_apex_generation_scenario(self) -> None:
        m = WildernessMapGenerator.for_zone("zone_boundless_celestial_palace", biome_id="CORRUPTED_FIEND_RUINS").generate(9999)
        assert m.width == 120 and m.height == 90 and len(m.encounter_zones) == 3
        assert verify_path_connectivity(m, m.spawn_point, m.boss_gate)[0] is True

    def test_t4_unit_test_regression_guard(self) -> None:
        assert len(ZONE_DEFAULT_SIZES) >= 9 and "zone_tang_kiem_nhai" in ZONE_DEFAULT_SIZES