"""Tests for data models."""

import pytest
from src.shared.models import Position, Snake, Food, GameState


class TestPosition:
    """Test suite for Position class."""

    def test_position_creation(self) -> None:
        """Test creating a position."""
        pos = Position(5, 10)
        assert pos.x == 5
        assert pos.y == 10

    def test_position_addition(self) -> None:
        """Test adding a direction to a position."""
        pos = Position(5, 10)
        new_pos = pos + (1, -1)
        assert new_pos.x == 6
        assert new_pos.y == 9

    def test_position_to_tuple(self) -> None:
        """Test converting position to tuple."""
        pos = Position(3, 7)
        assert pos.to_tuple() == (3, 7)

    def test_position_from_tuple(self) -> None:
        """Test creating position from tuple."""
        pos = Position.from_tuple((3, 7))
        assert pos.x == 3
        assert pos.y == 7


class TestSnake:
    """Test suite for Snake class."""

    def test_snake_creation(self) -> None:
        """Test creating a snake."""
        snake = Snake(player_id="test123")
        assert snake.player_id == "test123"
        assert snake.alive is True
        assert snake.score == 0
        assert snake.direction == (1, 0)

    def test_get_head(self) -> None:
        """Test getting snake head position."""
        snake = Snake(
            player_id="test",
            body=[Position(5, 5), Position(4, 5), Position(3, 5)]
        )
        head = snake.get_head()
        assert head.x == 5
        assert head.y == 5

    def test_snake_serialization(self) -> None:
        """Test snake to_dict and from_dict."""
        snake = Snake(
            player_id="test123",
            body=[Position(5, 5), Position(4, 5)],
            direction=(0, 1),
            alive=False,
            score=100
        )

        # Serialize
        data = snake.to_dict()
        assert data["player_id"] == "test123"
        assert data["body"] == [(5, 5), (4, 5)]
        assert data["direction"] == (0, 1)
        assert data["alive"] is False
        assert data["score"] == 100

        # Deserialize
        snake2 = Snake.from_dict(data)
        assert snake2.player_id == snake.player_id
        assert len(snake2.body) == len(snake.body)
        assert snake2.body[0].x == snake.body[0].x
        assert snake2.direction == snake.direction
        assert snake2.alive == snake.alive
        assert snake2.score == snake.score


class TestFood:
    """Test suite for Food class."""

    def test_food_creation(self) -> None:
        """Test creating food."""
        food = Food(position=Position(10, 15))
        assert food.position.x == 10
        assert food.position.y == 15

    def test_food_serialization(self) -> None:
        """Test food to_dict and from_dict."""
        food = Food(position=Position(10, 15))

        # Serialize
        data = food.to_dict()
        assert data["position"] == (10, 15)

        # Deserialize
        food2 = Food.from_dict(data)
        assert food2.position.x == food.position.x
        assert food2.position.y == food.position.y


class TestGameState:
    """Test suite for GameState class."""

    def test_game_state_creation(self) -> None:
        """Test creating game state."""
        state = GameState()
        assert len(state.snakes) == 0
        assert len(state.food) == 0
        assert state.game_running is False

    def test_game_state_serialization(self) -> None:
        """Test game state to_dict and from_dict."""
        state = GameState()
        state.snakes.append(Snake(player_id="p1", body=[Position(5, 5)]))
        state.food.append(Food(position=Position(10, 10)))
        state.game_running = True

        # Serialize
        data = state.to_dict()
        assert len(data["snakes"]) == 1
        assert len(data["food"]) == 1
        assert data["game_running"] is True

        # Deserialize
        state2 = GameState.from_dict(data)
        assert len(state2.snakes) == 1
        assert len(state2.food) == 1
        assert state2.game_running is True
        assert state2.snakes[0].player_id == "p1"