#!/usr/bin/env python3
"""Unit tests for the Shader system (Issue #106)

Tests cover:
- Shader creation and compilation
- Static uniforms (float, vec2, vec3, vec4)
- PropertyBinding for dynamic uniform values
- CallableBinding for computed uniform values
- Shader assignment to various drawable types
- Dynamic flag propagation
"""

import mcrfpy
import sys


def test_shader_creation():
    """Test basic shader creation"""
    print("Testing shader creation...")

    # Valid shader
    shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        void main() {
            gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
        }
    ''')
    assert shader is not None, "Shader should be created"
    assert shader.is_valid, "Shader should be valid"
    assert shader.dynamic == False, "Shader should not be dynamic by default"

    # Dynamic shader
    dynamic_shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        uniform float time;
        void main() {
            gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
        }
    ''', dynamic=True)
    assert dynamic_shader.dynamic == True, "Shader should be dynamic when specified"

    print("  PASS: Basic shader creation works")


def test_shader_source():
    """Test that shader source is stored correctly"""
    print("Testing shader source storage...")

    source = '''uniform sampler2D texture;
void main() {
    gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
}'''
    shader = mcrfpy.Shader(source)
    assert source in shader.source, "Shader source should be stored"

    print("  PASS: Shader source is stored")


def test_static_uniforms():
    """Test static uniform values"""
    print("Testing static uniforms...")

    frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))

    # Test float uniform
    frame.uniforms['intensity'] = 0.5
    assert abs(frame.uniforms['intensity'] - 0.5) < 0.001, "Float uniform should match"

    # Test vec2 uniform
    frame.uniforms['offset'] = (10.0, 20.0)
    val = frame.uniforms['offset']
    assert len(val) == 2, "Vec2 should have 2 components"
    assert abs(val[0] - 10.0) < 0.001, "Vec2.x should match"
    assert abs(val[1] - 20.0) < 0.001, "Vec2.y should match"

    # Test vec3 uniform
    frame.uniforms['color_rgb'] = (1.0, 0.5, 0.0)
    val = frame.uniforms['color_rgb']
    assert len(val) == 3, "Vec3 should have 3 components"

    # Test vec4 uniform
    frame.uniforms['color'] = (1.0, 0.5, 0.0, 1.0)
    val = frame.uniforms['color']
    assert len(val) == 4, "Vec4 should have 4 components"

    print("  PASS: Static uniforms work")


def test_uniform_keys():
    """Test uniform collection keys/values/items"""
    print("Testing uniform collection methods...")

    frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
    frame.uniforms['a'] = 1.0
    frame.uniforms['b'] = 2.0
    frame.uniforms['c'] = 3.0

    keys = frame.uniforms.keys()
    assert 'a' in keys, "Key 'a' should be present"
    assert 'b' in keys, "Key 'b' should be present"
    assert 'c' in keys, "Key 'c' should be present"
    assert len(keys) == 3, "Should have 3 keys"

    # Test 'in' operator
    assert 'a' in frame.uniforms, "'in' operator should work"
    assert 'nonexistent' not in frame.uniforms, "'not in' should work"

    # Test deletion
    del frame.uniforms['b']
    assert 'b' not in frame.uniforms, "Deleted key should be gone"
    assert len(frame.uniforms.keys()) == 2, "Should have 2 keys after deletion"

    print("  PASS: Uniform collection methods work")


def test_property_binding():
    """Test PropertyBinding for dynamic uniform values"""
    print("Testing PropertyBinding...")

    # Create source and target frames
    source_frame = mcrfpy.Frame(pos=(100, 200), size=(50, 50))
    target_frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))

    # Create binding to source frame's x position
    binding = mcrfpy.PropertyBinding(source_frame, 'x')
    assert binding is not None, "PropertyBinding should be created"
    assert binding.property == 'x', "Property name should be stored"
    assert abs(binding.value - 100.0) < 0.001, "Initial value should be 100"
    assert binding.is_valid == True, "Binding should be valid"

    # Assign binding to uniform
    target_frame.uniforms['source_x'] = binding

    # Check that value tracks changes
    source_frame.x = 300
    assert abs(binding.value - 300.0) < 0.001, "Binding should track changes"

    print("  PASS: PropertyBinding works")


def test_callable_binding():
    """Test CallableBinding for computed uniform values"""
    print("Testing CallableBinding...")

    counter = [0]  # Use list for closure

    def compute_value():
        counter[0] += 1
        return counter[0] * 0.1

    binding = mcrfpy.CallableBinding(compute_value)
    assert binding is not None, "CallableBinding should be created"
    assert binding.is_valid == True, "Binding should be valid"

    # Each access should call the function
    v1 = binding.value
    v2 = binding.value
    v3 = binding.value

    assert abs(v1 - 0.1) < 0.001, "First call should return 0.1"
    assert abs(v2 - 0.2) < 0.001, "Second call should return 0.2"
    assert abs(v3 - 0.3) < 0.001, "Third call should return 0.3"

    # Assign to uniform
    frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
    frame.uniforms['computed'] = binding

    print("  PASS: CallableBinding works")


def test_shader_on_frame():
    """Test shader assignment to Frame"""
    print("Testing shader on Frame...")

    shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        uniform float intensity;
        void main() {
            vec4 color = texture2D(texture, gl_TexCoord[0].xy);
            color.rgb *= intensity;
            gl_FragColor = color;
        }
    ''')

    frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
    assert frame.shader is None, "Shader should be None initially"

    frame.shader = shader
    assert frame.shader is not None, "Shader should be assigned"

    frame.uniforms['intensity'] = 0.8
    assert abs(frame.uniforms['intensity'] - 0.8) < 0.001, "Uniform should be set"

    # Test shader removal
    frame.shader = None
    assert frame.shader is None, "Shader should be removable"

    print("  PASS: Shader on Frame works")


def test_shader_on_sprite():
    """Test shader assignment to Sprite"""
    print("Testing shader on Sprite...")

    shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        void main() {
            gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
        }
    ''')

    sprite = mcrfpy.Sprite(pos=(0, 0))
    assert sprite.shader is None, "Shader should be None initially"

    sprite.shader = shader
    assert sprite.shader is not None, "Shader should be assigned"

    sprite.uniforms['test'] = 1.0
    assert abs(sprite.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"

    print("  PASS: Shader on Sprite works")


def test_shader_on_caption():
    """Test shader assignment to Caption"""
    print("Testing shader on Caption...")

    shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        void main() {
            gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
        }
    ''')

    caption = mcrfpy.Caption(text="Test", pos=(0, 0))
    assert caption.shader is None, "Shader should be None initially"

    caption.shader = shader
    assert caption.shader is not None, "Shader should be assigned"

    caption.uniforms['test'] = 1.0
    assert abs(caption.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"

    print("  PASS: Shader on Caption works")


def test_shader_on_grid():
    """Test shader assignment to Grid"""
    print("Testing shader on Grid...")

    shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        void main() {
            gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
        }
    ''')

    grid = mcrfpy.Grid(grid_size=(10, 10), pos=(0, 0), size=(200, 200))
    assert grid.shader is None, "Shader should be None initially"

    grid.shader = shader
    assert grid.shader is not None, "Shader should be assigned"

    grid.uniforms['test'] = 1.0
    assert abs(grid.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"

    print("  PASS: Shader on Grid works")


def test_shader_on_entity():
    """Test shader assignment to Entity"""
    print("Testing shader on Entity...")

    shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        void main() {
            gl_FragColor = texture2D(texture, gl_TexCoord[0].xy);
        }
    ''')

    entity = mcrfpy.Entity()
    assert entity.shader is None, "Shader should be None initially"

    entity.shader = shader
    assert entity.shader is not None, "Shader should be assigned"

    entity.uniforms['test'] = 1.0
    assert abs(entity.uniforms['test'] - 1.0) < 0.001, "Uniform should be set"

    print("  PASS: Shader on Entity works")


def test_shared_shader():
    """Test that multiple drawables can share the same shader"""
    print("Testing shared shader...")

    shader = mcrfpy.Shader('''
        uniform sampler2D texture;
        uniform float intensity;
        void main() {
            vec4 color = texture2D(texture, gl_TexCoord[0].xy);
            color.rgb *= intensity;
            gl_FragColor = color;
        }
    ''')

    frame1 = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
    frame2 = mcrfpy.Frame(pos=(100, 0), size=(100, 100))

    # Assign same shader to both
    frame1.shader = shader
    frame2.shader = shader

    # But different uniform values
    frame1.uniforms['intensity'] = 0.5
    frame2.uniforms['intensity'] = 1.0

    assert abs(frame1.uniforms['intensity'] - 0.5) < 0.001, "Frame1 intensity should be 0.5"
    assert abs(frame2.uniforms['intensity'] - 1.0) < 0.001, "Frame2 intensity should be 1.0"

    print("  PASS: Shared shader with different uniforms works")


def test_shader_animation_properties():
    """Test that shader uniforms can be animated via the animation system"""
    print("Testing shader animation properties...")

    frame = mcrfpy.Frame(pos=(0, 0), size=(100, 100))

    # Set initial uniform value
    frame.uniforms['intensity'] = 0.0

    # Test animate() method with shader.X property syntax
    # This uses hasProperty/setProperty internally
    try:
        frame.animate('shader.intensity', 1.0, 0.5, mcrfpy.Easing.LINEAR)
        animation_works = True
    except Exception as e:
        animation_works = False
        print(f"    Animation error: {e}")

    assert animation_works, "Animating shader uniforms should work"

    # Test with different drawable types
    sprite = mcrfpy.Sprite(pos=(0, 0))
    sprite.uniforms['glow'] = 0.0
    try:
        sprite.animate('shader.glow', 2.0, 1.0, mcrfpy.Easing.EASE_IN)
        sprite_animation_works = True
    except Exception as e:
        sprite_animation_works = False
        print(f"    Sprite animation error: {e}")

    assert sprite_animation_works, "Animating Sprite shader uniforms should work"

    # Test Caption
    caption = mcrfpy.Caption(text="Test", pos=(0, 0))
    caption.uniforms['alpha'] = 1.0
    try:
        caption.animate('shader.alpha', 0.0, 0.5, mcrfpy.Easing.EASE_OUT)
        caption_animation_works = True
    except Exception as e:
        caption_animation_works = False
        print(f"    Caption animation error: {e}")

    assert caption_animation_works, "Animating Caption shader uniforms should work"

    # Test Grid
    grid = mcrfpy.Grid(grid_size=(5, 5), pos=(0, 0), size=(100, 100))
    grid.uniforms['zoom_effect'] = 1.0
    try:
        grid.animate('shader.zoom_effect', 2.0, 1.0, mcrfpy.Easing.LINEAR)
        grid_animation_works = True
    except Exception as e:
        grid_animation_works = False
        print(f"    Grid animation error: {e}")

    assert grid_animation_works, "Animating Grid shader uniforms should work"

    print("  PASS: Shader animation properties work")


def run_all_tests():
    """Run all shader tests"""
    print("=" * 50)
    print("Shader System Unit Tests")
    print("=" * 50)
    print()

    try:
        test_shader_creation()
        test_shader_source()
        test_static_uniforms()
        test_uniform_keys()
        test_property_binding()
        test_callable_binding()
        test_shader_on_frame()
        test_shader_on_sprite()
        test_shader_on_caption()
        test_shader_on_grid()
        test_shader_on_entity()
        test_shared_shader()
        test_shader_animation_properties()

        print()
        print("=" * 50)
        print("ALL TESTS PASSED")
        print("=" * 50)
        sys.exit(0)

    except AssertionError as e:
        print(f"  FAIL: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"  ERROR: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    run_all_tests()