"""Offline geometry regressions; no Minecraft world, MCP server or map fixtures."""
from collections import deque
import importlib.util
import math
from pathlib import Path
import unittest

spec = importlib.util.spec_from_file_location('voxel_island', Path(__file__).with_name('voxel-island.py'))
islands = importlib.util.module_from_spec(spec)
spec.loader.exec_module(islands)


class FloatingIslandTests(unittest.TestCase):
    def test_same_input_is_reproducible_and_seed_changes_geometry(self):
        args = (120, -80, 18, 13, 144, 30)
        first = islands.columns(*args, 27)
        self.assertEqual(first, islands.columns(*args, 27))
        self.assertNotEqual(first, islands.columns(*args, 28))

    def test_negative_coordinate_envelope_and_inclusive_solid_columns(self):
        cx, cz, rx, rz, top, depth = -71, -39, 12, 9, 140, 27
        columns = islands.columns(cx, cz, rx, rz, top, depth, 11, .2)
        self.assertIn((cx, cz), columns)
        for (x, z), column in columns.items():
            self.assertLessEqual(abs(x-cx), rx*1.3)
            self.assertLessEqual(abs(z-cz), rz*1.3)
            self.assertEqual(top, column['top'])
            self.assertIs(type(column['bottom']), int)
            thickness = column['top'] - column['bottom'] + 1
            self.assertGreaterEqual(thickness, 3)
            self.assertLessEqual(thickness, math.ceil(depth + 5.5))
            self.assertGreaterEqual(column['radial'], 0)
            self.assertLessEqual(column['radial'], 1)
            # Adjacent columns all overlap at these top three levels.
            self.assertTrue(all(column['bottom'] <= y <= column['top'] for y in range(top-2, top+1)))

    def test_representative_lobed_ellipses_are_four_connected(self):
        for rx, rz in ((1, 1), (2, 8), (8, 2), (3, 17), (17, 3), (7, 11), (24, 22)):
            for contour in (0, .055, .2):
                for seed in range(12):
                    with self.subTest(rx=rx, rz=rz, contour=contour, seed=seed):
                        columns = islands.columns(0, 0, rx, rz, 140, 20, seed, contour)
                        reached, queue = set(), deque([(0, 0)])
                        while queue:
                            point = queue.popleft()
                            if point in reached or point not in columns:
                                continue
                            reached.add(point)
                            x, z = point
                            queue.extend(((x-1, z), (x+1, z), (x, z-1), (x, z+1)))
                        self.assertEqual(set(columns), reached)

    def test_translation_preserves_outline_but_not_world_anchored_underside(self):
        first = islands.columns(0, 0, 12, 9, 140, 20, 19)
        moved = islands.columns(43, -27, 12, 9, 140, 20, 19)
        self.assertEqual({(x+43, z-27) for x, z in first}, set(moved))
        self.assertTrue(any(first[x, z]['bottom'] != moved[x+43, z-27]['bottom'] for x, z in first))

    def test_tiny_positive_radii_still_include_the_centre(self):
        self.assertEqual({(-5, 8)}, set(islands.columns(-5, 8, .01, .01, 140, 1, 2)))

    def test_value_noise_is_bounded_and_continuous_at_negative_grid_edges(self):
        for seed in (0, 1, 100):
            for x, z in ((-3, .2), (.5, -7), (-4, -9), (0, 0)):
                value = islands.noise(x, z, seed)
                self.assertGreaterEqual(value, 0)
                self.assertLessEqual(value, 1)
                self.assertLess(abs(islands.noise(x-1e-7, z, seed)-islands.noise(x+1e-7, z, seed)), 1e-6)

    def test_invalid_geometry_is_rejected_before_sampling(self):
        for rx, rz, depth, contour in ((0, 5, 10, .1), (5, -1, 10, .1), (5, 5, 0, .1),
                                       (math.inf, 5, 10, .1), (5, math.nan, 10, .1),
                                       (5, 5, math.inf, .1), (5, 5, 10, -.01), (5, 5, 10, .201)):
            with self.subTest(rx=rx, rz=rz, depth=depth, contour=contour):
                with self.assertRaises(ValueError):
                    islands.columns(0, 0, rx, rz, 140, depth, 1, contour)
        with self.assertRaises(ValueError):
            islands.columns(.5, 0, 5, 5, 140, 10, 1)


if __name__ == '__main__':
    unittest.main()