"""
A module for testing the functionalities of `GameService` in the GeoGuessr
ecosystem.

This module contains a collection of test cases designed to validate
the correctness, edge cases, and error handling for various
asynchronous methods in the `GameService` class. These include
retrieving game details, unfinished games, streak games, activity
feeds, recent games, season statistics, and daily challenges.
"""

import pytest

from geoguessr_mcp.models import DailyChallenge, Game, SeasonStats


class TestGameService:
    """Tests for GameService."""

    @pytest.mark.asyncio
    async def test_get_game_details_success(
        self, game_service, mock_client, mock_game_data, mock_dynamic_response
    ):
        """Test successful game details retrieval."""
        mock_client.get.return_value = mock_dynamic_response(mock_game_data)

        game, response = await game_service.get_game_details("ABC123")

        assert isinstance(game, Game)
        assert game.token == "ABC123"
        assert game.map_name == "World"
        assert game.mode == "standard"
        assert len(game.rounds) == 5
        assert game.total_score == 23200  # Sum of all round scores

    @pytest.mark.asyncio
    async def test_get_game_details_with_session_token(
        self, game_service, mock_client, mock_game_data, mock_dynamic_response
    ):
        """Test game details with explicit session token."""
        mock_client.get.return_value = mock_dynamic_response(mock_game_data)

        game, response = await game_service.get_game_details("ABC123", session_token="test_token")

        call_args = mock_client.get.call_args
        assert call_args[0][1] == "test_token"

    @pytest.mark.asyncio
    async def test_get_game_details_failure(self, game_service, mock_client, mock_dynamic_response):
        """Test game details retrieval failure."""
        mock_client.get.return_value = mock_dynamic_response(
            {"error": "Game not found"}, success=False, status_code=404
        )

        with pytest.raises(ValueError, match="Failed to get game details"):
            await game_service.get_game_details("INVALID")

    @pytest.mark.asyncio
    async def test_get_unfinished_games(self, game_service, mock_client, mock_dynamic_response):
        """Test unfinished games retrieval."""
        unfinished_data = [
            {"token": "game-1", "map": {"name": "World"}},
            {"token": "game-2", "map": {"name": "Europe"}},
        ]
        mock_client.get.return_value = mock_dynamic_response(unfinished_data)

        response = await game_service.get_unfinished_games()

        assert response.is_success
        assert len(response.data) == 2

    @pytest.mark.asyncio
    async def test_get_streak_game(self, game_service, mock_client, mock_dynamic_response):
        """Test streak game retrieval."""
        streak_data = {
            "token": "streak-123",
            "currentStreak": 15,
            "bestStreak": 25,
        }
        mock_client.get.return_value = mock_dynamic_response(streak_data)

        response = await game_service.get_streak_game("streak-123")

        assert response.is_success
        assert response.data["currentStreak"] == 15

    @pytest.mark.asyncio
    async def test_get_activity_feed(
        self, game_service, mock_client, mock_activity_feed_data, mock_dynamic_response
    ):
        """Test activity feed retrieval."""
        mock_client.get.return_value = mock_dynamic_response(mock_activity_feed_data)

        response = await game_service.get_activity_feed(count=10, page=0)

        assert response.is_success
        assert len(response.data["entries"]) == 3

    @pytest.mark.asyncio
    async def test_get_activity_feed_pagination(
        self, game_service, mock_client, mock_dynamic_response
    ):
        """Test activity feed with pagination."""
        page_2_data = {"entries": [{"type": "PlayedGame", "payload": {"gameToken": "old-game"}}]}
        mock_client.get.return_value = mock_dynamic_response(page_2_data)

        response = await game_service.get_activity_feed(count=10, page=1)

        assert response.is_success
        mock_client.get.assert_called_once()

    @pytest.mark.asyncio
    async def test_get_recent_games_success(
        self,
        game_service,
        mock_client,
        mock_activity_feed_data,
        mock_game_data,
        mock_dynamic_response,
    ):
        """Test recent games retrieval."""
        # First call returns activity feed, subsequent calls return game details
        mock_client.get.side_effect = [
            mock_dynamic_response(mock_activity_feed_data),
            mock_dynamic_response(mock_game_data),
            mock_dynamic_response({**mock_game_data, "token": "game-token-2"}),
        ]

        games = await game_service.get_recent_games(count=2)

        assert len(games) == 2
        assert all(isinstance(g, Game) for g in games)

    @pytest.mark.asyncio
    async def test_get_recent_games_empty_feed(
        self, game_service, mock_client, mock_dynamic_response
    ):
        """Test recent games with empty activity feed."""
        mock_client.get.return_value = mock_dynamic_response({"entries": []})

        games = await game_service.get_recent_games(count=5)

        assert len(games) == 0

    @pytest.mark.asyncio
    async def test_get_recent_games_feed_failure(
        self, game_service, mock_client, mock_dynamic_response
    ):
        """Test recent games when feed fails."""
        mock_client.get.return_value = mock_dynamic_response({"error": "Failed"}, success=False)

        games = await game_service.get_recent_games(count=5)

        assert len(games) == 0

    @pytest.mark.asyncio
    async def test_get_recent_games_skips_failed_game_fetch(
        self,
        game_service,
        mock_client,
        mock_activity_feed_data,
        mock_game_data,
        mock_dynamic_response,
    ):
        """Test that failed individual game fetches are skipped."""
        mock_client.get.side_effect = [
            mock_dynamic_response(mock_activity_feed_data),
            Exception("Game fetch failed"),  # First game fails
            mock_dynamic_response(mock_game_data),  # Second game succeeds
        ]

        games = await game_service.get_recent_games(count=2)

        assert len(games) == 1

    @pytest.mark.asyncio
    async def test_get_season_stats_success(
        self, game_service, mock_client, mock_season_stats_data, mock_dynamic_response
    ):
        """Test season stats retrieval."""
        mock_client.get.return_value = mock_dynamic_response(mock_season_stats_data)

        stats, response = await game_service.get_season_stats()

        assert isinstance(stats, SeasonStats)
        assert stats.season_id == "season-2024-1"
        assert stats.rank == 150
        assert stats.rating == 1850
        assert stats.division == "Gold"

    @pytest.mark.asyncio
    async def test_get_season_stats_failure(self, game_service, mock_client, mock_dynamic_response):
        """Test season stats failure."""
        mock_client.get.return_value = mock_dynamic_response(
            {"error": "No active season"}, success=False, status_code=404
        )

        with pytest.raises(ValueError, match="Failed to get season stats"):
            await game_service.get_season_stats()

    @pytest.mark.asyncio
    async def test_get_daily_challenge_today(
        self, game_service, mock_client, mock_dynamic_response
    ):
        """Test daily challenge retrieval for today."""
        challenge_data = {
            "token": "daily-2024-01-15",
            "map": {"name": "World"},
            "date": "2024-01-15",
            "timeLimit": 180,
        }
        mock_client.get.return_value = mock_dynamic_response(challenge_data)

        challenge, response = await game_service.get_daily_challenge()

        assert isinstance(challenge, DailyChallenge)
        assert challenge.token == "daily-2024-01-15"
        assert challenge.time_limit == 180

    @pytest.mark.asyncio
    async def test_get_daily_challenge_specific_day(
        self, game_service, mock_client, mock_dynamic_response
    ):
        """Test daily challenge for specific day."""
        challenge_data = {
            "token": "daily-2024-01-10",
            "date": "2024-01-10",
        }
        mock_client.get.return_value = mock_dynamic_response(challenge_data)

        challenge, response = await game_service.get_daily_challenge(day="2024-01-10")

        assert challenge.date == "2024-01-10"

    @pytest.mark.asyncio
    async def test_get_daily_challenge_failure(
        self, game_service, mock_client, mock_dynamic_response
    ):
        """Test daily challenge failure."""
        mock_client.get.return_value = mock_dynamic_response(
            {"error": "Challenge not found"}, success=False, status_code=404
        )

        with pytest.raises(ValueError, match="Failed to get daily challenge"):
            await game_service.get_daily_challenge()

    @pytest.mark.asyncio
    async def test_get_battle_royale(self, game_service, mock_client, mock_dynamic_response):
        """Test battle royale game retrieval."""
        br_data = {
            "gameId": "br-123",
            "players": 10,
            "status": "in_progress",
        }
        mock_client.get.return_value = mock_dynamic_response(br_data)

        response = await game_service.get_battle_royale("br-123")

        assert response.is_success
        assert response.data["players"] == 10

    @pytest.mark.asyncio
    async def test_get_duel(self, game_service, mock_client, mock_dynamic_response):
        """Test duel game retrieval."""
        duel_data = {
            "duelId": "duel-456",
            "player1": {"id": "p1", "score": 5000},
            "player2": {"id": "p2", "score": 4500},
        }
        mock_client.get.return_value = mock_dynamic_response(duel_data)

        response = await game_service.get_duel("duel-456")

        assert response.is_success
        assert response.data["player1"]["score"] == 5000

    @pytest.mark.asyncio
    async def test_get_tournaments(self, game_service, mock_client, mock_dynamic_response):
        """Test tournaments retrieval."""
        tournaments_data = [
            {"id": "t1", "name": "Weekly Tournament", "status": "active"},
            {"id": "t2", "name": "Monthly Cup", "status": "upcoming"},
        ]
        mock_client.get.return_value = mock_dynamic_response(tournaments_data)

        response = await game_service.get_tournaments()

        assert response.is_success
        assert len(response.data) == 2