import json
import pytest
from users.serializers import HotkeysSerializer  # Import from your actual app


class TestHotkeysSerializer:
    """Tests for the HotkeysSerializer following pytest guidelines"""
    
    @pytest.fixture
    def valid_hotkeys(self):
        """Fixture providing valid hotkeys data for testing"""
        return {
            "editor:save": {"key": "ctrl+s", "active": True},
            "editor:open": {"key": "ctrl+o", "active": False},
            "editor:cut": {"key": "ctrl+x"},
            "navigation:home": {"key": "alt+h", "active": True}
        }
    
    @pytest.fixture
    def valid_serializer_data(self, valid_hotkeys):
        """Fixture providing valid serializer data"""
        return {"custom_hotkeys": valid_hotkeys}
    
    def test_valid_data(self, valid_serializer_data):
        """Test serializer validation with valid hotkeys data.
        
        This test validates:
        - Serializer accepts properly formatted hotkeys dictionary
        - All required fields are present and valid
        - Both active and inactive hotkeys are handled correctly
        - Optional 'active' field defaults appropriately
        
        Critical validation: Ensures well-formed hotkey configurations
        are accepted without errors for user customization features.
        """
        serializer = HotkeysSerializer(data=valid_serializer_data)
        assert serializer.is_valid()
    
    def test_invalid_format_not_dict(self):
        """Test serializer rejects non-dictionary custom_hotkeys.
        
        This test validates:
        - Serializer properly validates data type of custom_hotkeys field
        - Non-dictionary values (lists, strings, etc.) are rejected
        - Appropriate validation errors are returned
        
        Critical validation: Prevents malformed data from corrupting
        user hotkey preferences and ensures data integrity.
        """
        data = {"custom_hotkeys": ["not a dictionary"]}
        serializer = HotkeysSerializer(data=data)
        assert not serializer.is_valid()
        assert 'custom_hotkeys' in serializer.errors
    
    def test_invalid_action_key_format(self):
        """Test serializer rejects action keys without proper format.
        
        This test validates:
        - Action keys must follow 'category:action' format with colon separator
        - Malformed action keys (missing colon) are rejected
        - Validation error is properly raised and contains expected field
        
        Critical validation: Ensures hotkey action identifiers follow
        expected naming convention for proper system integration.
        """
        # Missing colon
        invalid_data = {
            "custom_hotkeys": {
                "editorsave": {"key": "ctrl+s"}
            }
        }
        serializer = HotkeysSerializer(data=invalid_data)
        assert not serializer.is_valid()
        assert 'custom_hotkeys' in serializer.errors
    
    def test_empty_action_key(self):
        """Test serializer rejects empty action keys.
        
        This test validates:
        - Empty string action keys are not allowed
        - Validation properly catches and rejects empty identifiers
        - Error response includes the problematic field
        
        Critical validation: Prevents creation of hotkeys with
        undefined action identifiers that would break functionality.
        """
        invalid_data = {
            "custom_hotkeys": {
                "": {"key": "ctrl+s"}
            }
        }
        serializer = HotkeysSerializer(data=invalid_data)
        assert not serializer.is_valid()
        assert 'custom_hotkeys' in serializer.errors
    
    def test_missing_key_in_hotkey_data(self):
        """Test serializer rejects hotkey data without required 'key' field.
        
        This test validates:
        - The 'key' field is mandatory for each hotkey configuration
        - Hotkey objects missing the 'key' field are rejected
        - Validation error properly identifies the missing required field
        
        Critical validation: Ensures all hotkeys have keyboard combinations
        defined, preventing non-functional hotkey configurations.
        """
        invalid_data = {
            "custom_hotkeys": {
                "editor:save": {"active": True}  # Missing 'key'
            }
        }
        serializer = HotkeysSerializer(data=invalid_data)
        assert not serializer.is_valid()
        assert 'custom_hotkeys' in serializer.errors
    
    def test_invalid_key_value(self):
        """Test serializer rejects invalid key values.
        
        This test validates:
        - Empty string key values are not allowed
        - Key field must contain actual keyboard combination
        - Validation catches and rejects meaningless key definitions
        
        Critical validation: Ensures hotkeys have valid keyboard
        combinations that can be processed by the frontend system.
        """
        invalid_data = {
            "custom_hotkeys": {
                "editor:save": {"key": ""}  # Empty key
            }
        }
        serializer = HotkeysSerializer(data=invalid_data)
        assert not serializer.is_valid()
        assert 'custom_hotkeys' in serializer.errors
    
    def test_invalid_active_flag(self):
        """Test serializer rejects non-boolean active flags.
        
        This test validates:
        - The 'active' field must be a boolean value when provided
        - String representations like 'yes'/'no' are not accepted
        - Type validation is properly enforced for optional fields
        
        Critical validation: Ensures hotkey enable/disable state
        is properly typed for consistent system behavior.
        """
        invalid_data = {
            "custom_hotkeys": {
                "editor:save": {"key": "ctrl+s", "active": "yes"}  # Should be boolean
            }
        }
        serializer = HotkeysSerializer(data=invalid_data)
        assert not serializer.is_valid()
        assert 'custom_hotkeys' in serializer.errors