pyPhotoAlbum/tests/test_zorder.py

"""
Unit tests for z-order operations in pyPhotoAlbum
"""

import pytest
from pyPhotoAlbum.models import ImageData, TextBoxData, PlaceholderData
from pyPhotoAlbum.page_layout import PageLayout
from pyPhotoAlbum.commands import ChangeZOrderCommand, CommandHistory


class TestZOrderBasics:
    """Tests for basic z-order functionality"""
    
    def test_list_order_is_render_order(self):
        """Test that list order determines render order"""
        layout = PageLayout(width=210, height=297)
        
        # Add elements in order
        elem1 = ImageData(x=10, y=10, width=50, height=50)
        elem2 = TextBoxData(x=20, y=20, width=50, height=50)
        elem3 = PlaceholderData(x=30, y=30, width=50, height=50)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Verify order
        assert layout.elements[0] is elem1
        assert layout.elements[1] is elem2
        assert layout.elements[2] is elem3
    
    def test_element_at_end_renders_on_top(self):
        """Test that element at end of list renders on top"""
        layout = PageLayout(width=210, height=297)
        
        elem1 = ImageData(x=10, y=10)
        elem2 = ImageData(x=20, y=20)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        
        # elem2 should be last (on top)
        assert layout.elements[-1] is elem2
        assert layout.elements.index(elem2) > layout.elements.index(elem1)


class TestChangeZOrderCommand:
    """Tests for ChangeZOrderCommand"""
    
    def test_move_element_forward(self):
        """Test moving an element forward one position"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        elem3 = PlaceholderData(x=30, y=30)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Move elem1 forward (swap with elem2)
        cmd = ChangeZOrderCommand(layout, elem1, old_index=0, new_index=1)
        cmd.execute()
        
        assert layout.elements.index(elem1) == 1
        assert layout.elements.index(elem2) == 0
        assert layout.elements.index(elem3) == 2
    
    def test_move_element_backward(self):
        """Test moving an element backward one position"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        elem3 = PlaceholderData(x=30, y=30)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Move elem2 backward (swap with elem1)
        cmd = ChangeZOrderCommand(layout, elem2, old_index=1, new_index=0)
        cmd.execute()
        
        assert layout.elements.index(elem2) == 0
        assert layout.elements.index(elem1) == 1
        assert layout.elements.index(elem3) == 2
    
    def test_move_to_front(self):
        """Test moving an element to the front (end of list)"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        elem3 = PlaceholderData(x=30, y=30)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Move elem1 to front
        cmd = ChangeZOrderCommand(layout, elem1, old_index=0, new_index=2)
        cmd.execute()
        
        assert layout.elements[-1] is elem1
        assert layout.elements.index(elem1) == 2
    
    def test_move_to_back(self):
        """Test moving an element to the back (start of list)"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        elem3 = PlaceholderData(x=30, y=30)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Move elem3 to back
        cmd = ChangeZOrderCommand(layout, elem3, old_index=2, new_index=0)
        cmd.execute()
        
        assert layout.elements[0] is elem3
        assert layout.elements.index(elem3) == 0
    
    def test_undo_redo(self):
        """Test undo/redo functionality"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        elem3 = PlaceholderData(x=30, y=30)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        original_order = list(layout.elements)
        
        # Move elem1 forward
        cmd = ChangeZOrderCommand(layout, elem1, old_index=0, new_index=1)
        cmd.execute()
        
        assert layout.elements.index(elem1) == 1
        
        # Undo
        cmd.undo()
        assert layout.elements == original_order
        
        # Redo
        cmd.redo()
        assert layout.elements.index(elem1) == 1
    
    def test_command_with_history(self):
        """Test ChangeZOrderCommand with CommandHistory"""
        layout = PageLayout()
        history = CommandHistory()
        
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        elem3 = PlaceholderData(x=30, y=30)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Execute command through history
        cmd = ChangeZOrderCommand(layout, elem1, old_index=0, new_index=2)
        history.execute(cmd)
        
        assert layout.elements.index(elem1) == 2
        assert history.can_undo()
        
        # Undo through history
        history.undo()
        assert layout.elements.index(elem1) == 0
        assert history.can_redo()
        
        # Redo through history
        history.redo()
        assert layout.elements.index(elem1) == 2


class TestZOrderSerialization:
    """Tests for z-order serialization and deserialization"""
    
    def test_serialize_preserves_order(self):
        """Test that serialization preserves element order"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10, z_index=0)
        elem2 = TextBoxData(x=20, y=20, z_index=1)
        elem3 = PlaceholderData(x=30, y=30, z_index=2)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Serialize
        data = layout.serialize()
        
        # Elements should be in order
        assert len(data['elements']) == 3
        assert data['elements'][0]['type'] == 'image'
        assert data['elements'][1]['type'] == 'textbox'
        assert data['elements'][2]['type'] == 'placeholder'
    
    def test_deserialize_sorts_by_zindex(self):
        """Test that deserialization sorts by z_index for backward compatibility"""
        layout = PageLayout()
        
        # Create data with z_index values out of order
        data = {
            'size': (210, 297),
            'base_width': 210,
            'is_facing_page': False,
            'background_color': (1.0, 1.0, 1.0),
            'elements': [
                {'type': 'image', 'position': (10, 10), 'size': (50, 50), 
                 'rotation': 0, 'z_index': 2, 'image_path': '', 'crop_info': (0, 0, 1, 1)},
                {'type': 'textbox', 'position': (20, 20), 'size': (50, 50), 
                 'rotation': 0, 'z_index': 0, 'text_content': '', 
                 'font_settings': {}, 'alignment': 'left'},
                {'type': 'placeholder', 'position': (30, 30), 'size': (50, 50), 
                 'rotation': 0, 'z_index': 1, 'placeholder_type': 'image', 'default_content': ''},
            ]
        }
        
        layout.deserialize(data)
        
        # Elements should be sorted by z_index
        assert len(layout.elements) == 3
        assert isinstance(layout.elements[0], TextBoxData)  # z_index=0
        assert isinstance(layout.elements[1], PlaceholderData)  # z_index=1
        assert isinstance(layout.elements[2], ImageData)  # z_index=2
    
    def test_roundtrip_maintains_order(self):
        """Test that serialize/deserialize maintains element order"""
        layout1 = PageLayout()
        elem1 = ImageData(x=10, y=10, z_index=0)
        elem2 = TextBoxData(x=20, y=20, z_index=1)
        elem3 = PlaceholderData(x=30, y=30, z_index=2)
        
        layout1.add_element(elem1)
        layout1.add_element(elem2)
        layout1.add_element(elem3)
        
        # Serialize and deserialize
        data = layout1.serialize()
        layout2 = PageLayout()
        layout2.deserialize(data)
        
        # Order should be maintained
        assert len(layout2.elements) == 3
        assert isinstance(layout2.elements[0], ImageData)
        assert isinstance(layout2.elements[1], TextBoxData)
        assert isinstance(layout2.elements[2], PlaceholderData)


class TestZOrderEdgeCases:
    """Tests for z-order edge cases"""
    
    def test_single_element(self):
        """Test operations with single element"""
        layout = PageLayout()
        elem = ImageData(x=10, y=10)
        layout.add_element(elem)
        
        # Try to move forward (should stay at index 0)
        cmd = ChangeZOrderCommand(layout, elem, old_index=0, new_index=0)
        cmd.execute()
        
        assert layout.elements.index(elem) == 0
    
    def test_empty_list(self):
        """Test operations with empty list"""
        layout = PageLayout()
        assert len(layout.elements) == 0
    
    def test_move_to_same_position(self):
        """Test moving element to its current position"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        
        # Move to same position
        cmd = ChangeZOrderCommand(layout, elem1, old_index=0, new_index=0)
        cmd.execute()
        
        assert layout.elements.index(elem1) == 0
        assert layout.elements.index(elem2) == 1
    
    def test_swap_adjacent_elements(self):
        """Test swapping two adjacent elements"""
        layout = PageLayout()
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        
        # Swap by moving elem1 forward
        elements = layout.elements
        index1 = elements.index(elem1)
        index2 = elements.index(elem2)
        elements[index1], elements[index2] = elements[index2], elements[index1]
        
        assert layout.elements[0] is elem2
        assert layout.elements[1] is elem1
    
    def test_multiple_zorder_changes(self):
        """Test multiple z-order changes in sequence"""
        layout = PageLayout()
        history = CommandHistory()
        
        elem1 = ImageData(x=10, y=10)
        elem2 = TextBoxData(x=20, y=20)
        elem3 = PlaceholderData(x=30, y=30)
        
        layout.add_element(elem1)
        layout.add_element(elem2)
        layout.add_element(elem3)
        
        # Move elem1 to front
        cmd1 = ChangeZOrderCommand(layout, elem1, old_index=0, new_index=2)
        history.execute(cmd1)
        assert layout.elements.index(elem1) == 2
        
        # Move elem2 to front
        cmd2 = ChangeZOrderCommand(layout, elem2, old_index=0, new_index=2)
        history.execute(cmd2)
        assert layout.elements.index(elem2) == 2
        
        # Undo both
        history.undo()
        assert layout.elements.index(elem2) == 0
        
        history.undo()
        assert layout.elements.index(elem1) == 0


class TestZOrderCommandSerialization:
    """Tests for ChangeZOrderCommand serialization"""
    
    def test_serialize_command(self):
        """Test serializing a ChangeZOrderCommand"""
        layout = PageLayout()
        elem = ImageData(x=10, y=10)
        layout.add_element(elem)
        
        cmd = ChangeZOrderCommand(layout, elem, old_index=0, new_index=1)
        
        data = cmd.serialize()
        
        assert data['type'] == 'change_zorder'
        assert data['old_index'] == 0
        assert data['new_index'] == 1
        assert 'element' in data
    
    def test_deserialize_command(self):
        """Test deserializing a ChangeZOrderCommand"""
        data = {
            'type': 'change_zorder',
            'element': {
                'type': 'image',
                'position': (10, 10),
                'size': (50, 50),
                'rotation': 0,
                'z_index': 0,
                'image_path': '',
                'crop_info': (0, 0, 1, 1)
            },
            'old_index': 0,
            'new_index': 1
        }
        
        cmd = ChangeZOrderCommand.deserialize(data, None)
        
        assert isinstance(cmd, ChangeZOrderCommand)
        assert cmd.old_index == 0
        assert cmd.new_index == 1
        assert isinstance(cmd.element, ImageData)