# model3d_test.py - Unit test for Model3D 3D model resource

import mcrfpy
import sys

def test_model3d_cube():
    """Test Model3D.cube() creates valid model"""
    cube = mcrfpy.Model3D.cube(2.0)

    assert cube.name == "cube", f"Expected name='cube', got '{cube.name}'"
    assert cube.vertex_count == 24, f"Expected 24 vertices, got {cube.vertex_count}"
    assert cube.triangle_count == 12, f"Expected 12 triangles, got {cube.triangle_count}"
    assert cube.has_skeleton == False, f"Expected has_skeleton=False, got {cube.has_skeleton}"
    assert cube.mesh_count == 1, f"Expected 1 mesh, got {cube.mesh_count}"

    # Check bounds for size=2.0 cube
    bounds = cube.bounds
    assert bounds is not None, "Bounds should not be None"
    min_b, max_b = bounds
    assert min_b == (-1.0, -1.0, -1.0), f"Expected min=(-1,-1,-1), got {min_b}"
    assert max_b == (1.0, 1.0, 1.0), f"Expected max=(1,1,1), got {max_b}"

    print("[PASS] test_model3d_cube")

def test_model3d_cube_default_size():
    """Test Model3D.cube() with default size"""
    cube = mcrfpy.Model3D.cube()

    # Default size is 1.0, so bounds should be -0.5 to 0.5
    bounds = cube.bounds
    min_b, max_b = bounds
    assert abs(min_b[0] - (-0.5)) < 0.001, f"Expected min.x=-0.5, got {min_b[0]}"
    assert abs(max_b[0] - 0.5) < 0.001, f"Expected max.x=0.5, got {max_b[0]}"

    print("[PASS] test_model3d_cube_default_size")

def test_model3d_plane():
    """Test Model3D.plane() creates valid model"""
    plane = mcrfpy.Model3D.plane(4.0, 2.0, 2)

    assert plane.name == "plane", f"Expected name='plane', got '{plane.name}'"
    # 2 segments = 3x3 grid = 9 vertices
    assert plane.vertex_count == 9, f"Expected 9 vertices, got {plane.vertex_count}"
    # 2x2 quads = 8 triangles
    assert plane.triangle_count == 8, f"Expected 8 triangles, got {plane.triangle_count}"
    assert plane.has_skeleton == False, f"Expected has_skeleton=False"

    # Bounds should be width/2, 0, depth/2
    bounds = plane.bounds
    min_b, max_b = bounds
    assert abs(min_b[0] - (-2.0)) < 0.001, f"Expected min.x=-2, got {min_b[0]}"
    assert abs(max_b[0] - 2.0) < 0.001, f"Expected max.x=2, got {max_b[0]}"
    assert abs(min_b[2] - (-1.0)) < 0.001, f"Expected min.z=-1, got {min_b[2]}"
    assert abs(max_b[2] - 1.0) < 0.001, f"Expected max.z=1, got {max_b[2]}"

    print("[PASS] test_model3d_plane")

def test_model3d_plane_default():
    """Test Model3D.plane() with default parameters"""
    plane = mcrfpy.Model3D.plane()

    # Default is 1x1 with 1 segment = 4 vertices, 2 triangles
    assert plane.vertex_count == 4, f"Expected 4 vertices, got {plane.vertex_count}"
    assert plane.triangle_count == 2, f"Expected 2 triangles, got {plane.triangle_count}"

    print("[PASS] test_model3d_plane_default")

def test_model3d_sphere():
    """Test Model3D.sphere() creates valid model"""
    sphere = mcrfpy.Model3D.sphere(1.0, 8, 6)

    assert sphere.name == "sphere", f"Expected name='sphere', got '{sphere.name}'"
    # vertices = (segments+1) * (rings+1) = 9 * 7 = 63
    assert sphere.vertex_count == 63, f"Expected 63 vertices, got {sphere.vertex_count}"
    # triangles = 2 * segments * rings = 2 * 8 * 6 = 96
    assert sphere.triangle_count == 96, f"Expected 96 triangles, got {sphere.triangle_count}"

    # Bounds should be radius in all directions
    bounds = sphere.bounds
    min_b, max_b = bounds
    assert abs(min_b[0] - (-1.0)) < 0.001, f"Expected min.x=-1, got {min_b[0]}"
    assert abs(max_b[0] - 1.0) < 0.001, f"Expected max.x=1, got {max_b[0]}"

    print("[PASS] test_model3d_sphere")

def test_model3d_sphere_default():
    """Test Model3D.sphere() with default parameters"""
    sphere = mcrfpy.Model3D.sphere()

    # Default radius=0.5, segments=16, rings=12
    # vertices = 17 * 13 = 221
    assert sphere.vertex_count == 221, f"Expected 221 vertices, got {sphere.vertex_count}"
    # triangles = 2 * 16 * 12 = 384
    assert sphere.triangle_count == 384, f"Expected 384 triangles, got {sphere.triangle_count}"

    print("[PASS] test_model3d_sphere_default")

def test_model3d_empty():
    """Test creating empty Model3D"""
    empty = mcrfpy.Model3D()

    assert empty.name == "unnamed", f"Expected name='unnamed', got '{empty.name}'"
    assert empty.vertex_count == 0, f"Expected 0 vertices, got {empty.vertex_count}"
    assert empty.triangle_count == 0, f"Expected 0 triangles, got {empty.triangle_count}"
    assert empty.mesh_count == 0, f"Expected 0 meshes, got {empty.mesh_count}"

    print("[PASS] test_model3d_empty")

def test_model3d_repr():
    """Test Model3D string representation"""
    cube = mcrfpy.Model3D.cube()
    repr_str = repr(cube)

    assert "Model3D" in repr_str, f"Expected 'Model3D' in repr, got {repr_str}"
    assert "cube" in repr_str, f"Expected 'cube' in repr, got {repr_str}"
    assert "24" in repr_str, f"Expected vertex count in repr, got {repr_str}"

    print("[PASS] test_model3d_repr")

def test_entity3d_model_property():
    """Test Entity3D.model property"""
    e = mcrfpy.Entity3D(pos=(0, 0))

    # Initially no model
    assert e.model is None, f"Expected model=None, got {e.model}"

    # Assign model
    cube = mcrfpy.Model3D.cube()
    e.model = cube
    assert e.model is not None, "Expected model to be set"
    assert e.model.name == "cube", f"Expected model.name='cube', got {e.model.name}"

    # Swap model
    sphere = mcrfpy.Model3D.sphere()
    e.model = sphere
    assert e.model.name == "sphere", f"Expected model.name='sphere', got {e.model.name}"

    # Clear model
    e.model = None
    assert e.model is None, f"Expected model=None after clearing"

    print("[PASS] test_entity3d_model_property")

def test_entity3d_model_type_error():
    """Test Entity3D.model raises TypeError for invalid input"""
    e = mcrfpy.Entity3D()

    try:
        e.model = "not a model"
        print("[FAIL] test_entity3d_model_type_error: Expected TypeError")
        return
    except TypeError:
        pass

    try:
        e.model = 123
        print("[FAIL] test_entity3d_model_type_error: Expected TypeError")
        return
    except TypeError:
        pass

    print("[PASS] test_entity3d_model_type_error")

def test_entity3d_with_model_in_viewport():
    """Test Entity3D with model in a Viewport3D"""
    vp = mcrfpy.Viewport3D()
    vp.set_grid_size(16, 16)

    # Create entity with model
    cube = mcrfpy.Model3D.cube(0.5)
    e = mcrfpy.Entity3D(pos=(8, 8))
    e.model = cube

    # Add to viewport
    vp.entities.append(e)

    # Verify model is preserved
    retrieved = vp.entities[0]
    assert retrieved.model is not None, "Expected model to be preserved"
    assert retrieved.model.name == "cube", f"Expected model.name='cube', got {retrieved.model.name}"

    print("[PASS] test_entity3d_with_model_in_viewport")

def run_all_tests():
    """Run all Model3D tests"""
    tests = [
        test_model3d_cube,
        test_model3d_cube_default_size,
        test_model3d_plane,
        test_model3d_plane_default,
        test_model3d_sphere,
        test_model3d_sphere_default,
        test_model3d_empty,
        test_model3d_repr,
        test_entity3d_model_property,
        test_entity3d_model_type_error,
        test_entity3d_with_model_in_viewport,
    ]

    passed = 0
    failed = 0

    for test in tests:
        try:
            test()
            passed += 1
        except AssertionError as e:
            print(f"[FAIL] {test.__name__}: {e}")
            failed += 1
        except Exception as e:
            print(f"[ERROR] {test.__name__}: {type(e).__name__}: {e}")
            failed += 1

    print(f"\n=== Results: {passed} passed, {failed} failed ===")
    return failed == 0

if __name__ == "__main__":
    success = run_all_tests()
    sys.exit(0 if success else 1)