"""
This module contains unit tests for classes and services provided in the
`geoguessr_mcp` library. It includes test cases for analyzing games,
evaluating statistical trends, and extracting detailed insights from
game performance data.
"""

from unittest.mock import patch

import pytest

from geoguessr_mcp.models import Game, RoundGuess
from geoguessr_mcp.services.analysis_service import AnalysisService, GameAnalysis


class TestGameAnalysis:
    """Tests for GameAnalysis dataclass."""

    def test_default_values(self):
        """Test GameAnalysis default values."""
        analysis = GameAnalysis()

        assert analysis.games_analyzed == 0
        assert analysis.total_score == 0
        assert analysis.average_score == 0.0
        assert analysis.perfect_round_percentage == 0.0
        assert analysis.score_trend == "stable"
        assert analysis.weak_areas == []
        assert analysis.strong_areas == []

    def test_to_dict(self):
        """Test GameAnalysis to_dict method."""
        analysis = GameAnalysis(
            games_analyzed=10,
            total_score=200000,
            average_score=20000.5,
            total_rounds=50,
            perfect_rounds=15,
            perfect_round_percentage=30.0,
            average_distance_meters=500.123,
            average_time_seconds=45.678,
            best_game_score=25000,
            worst_game_score=15000,
            score_trend="improving",
        )

        result = analysis.to_dict()

        assert result["games_analyzed"] == 10
        assert result["average_score"] == 20000.5
        assert result["perfect_round_percentage"] == 30.0
        assert result["score_trend"] == "improving"


class TestAnalysisService:
    """Tests for AnalysisService."""

    def test_analyze_games_empty(self):
        """Test analyzing empty game list."""
        result = AnalysisService.analyze_games([])

        assert result.games_analyzed == 0
        assert result.total_score == 0
        assert result.average_score == 0.0

    def test_analyze_games_single_game(self):
        """Test analyzing single game."""
        rounds = [
            RoundGuess(round_number=1, score=5000, distance_meters=0, time_seconds=20),
            RoundGuess(round_number=2, score=4500, distance_meters=100, time_seconds=25),
            RoundGuess(round_number=3, score=4000, distance_meters=200, time_seconds=30),
        ]
        game = Game(
            token="test-game",
            map_name="World",
            mode="standard",
            total_score=13500,
            rounds=rounds,
            finished=True,
        )

        result = AnalysisService.analyze_games([game])

        assert result.games_analyzed == 1
        assert result.total_score == 13500
        assert result.average_score == 13500
        assert result.total_rounds == 3
        assert result.perfect_rounds == 1
        assert result.perfect_round_percentage == pytest.approx(33.33, rel=0.01)

    def test_analyze_games_multiple_games(self, sample_games):
        """Test analyzing multiple games."""
        result = AnalysisService.analyze_games(sample_games)

        assert result.games_analyzed == 5
        assert result.total_rounds == 25
        assert result.average_score == result.total_score / 5
        assert result.best_game_score >= result.worst_game_score

    def test_analyze_games_trend_improving(self):
        """Test score trend detection - improving."""
        # Create games with improving scores
        games = []
        for i in range(6):
            base_score = 15000 + (i * 2000)  # Increasing scores
            rounds = [
                RoundGuess(round_number=1, score=base_score, distance_meters=100, time_seconds=30)
            ]
            game = Game(
                token=f"game-{i}",
                map_name="World",
                mode="standard",
                total_score=base_score,
                rounds=rounds,
                finished=True,
            )
            games.append(game)

        result = AnalysisService.analyze_games(games)

        assert result.score_trend == "improving"

    def test_analyze_games_trend_declining(self):
        """Test score trend detection - declining."""
        # Create games with declining scores
        games = []
        for i in range(6):
            base_score = 25000 - (i * 2000)  # Decreasing scores
            rounds = [
                RoundGuess(round_number=1, score=base_score, distance_meters=100, time_seconds=30)
            ]
            game = Game(
                token=f"game-{i}",
                map_name="World",
                mode="standard",
                total_score=base_score,
                rounds=rounds,
                finished=True,
            )
            games.append(game)

        result = AnalysisService.analyze_games(games)

        assert result.score_trend == "declining"

    def test_analyze_games_weak_areas(self):
        """Test weak areas' identification."""
        rounds = [
            RoundGuess(round_number=1, score=5000, distance_meters=0, time_seconds=20),
            RoundGuess(round_number=2, score=1500, distance_meters=5000, time_seconds=60),  # Weak
            RoundGuess(round_number=3, score=1000, distance_meters=8000, time_seconds=90),  # Weak
        ]
        game = Game(
            token="test-game",
            map_name="World",
            mode="standard",
            total_score=7500,
            rounds=rounds,
            finished=True,
        )

        result = AnalysisService.analyze_games([game])

        assert len(result.weak_areas) == 2
        assert all(area["score"] < 2000 for area in result.weak_areas)

    def test_analyze_games_strong_areas(self):
        """Test strong areas' identification."""
        rounds = [
            RoundGuess(round_number=1, score=5000, distance_meters=0, time_seconds=20),
            RoundGuess(round_number=2, score=4800, distance_meters=50, time_seconds=25),
            RoundGuess(round_number=3, score=2000, distance_meters=500, time_seconds=30),
        ]
        game = Game(
            token="test-game",
            map_name="World",
            mode="standard",
            total_score=11800,
            rounds=rounds,
            finished=True,
        )

        result = AnalysisService.analyze_games([game])

        assert len(result.strong_areas) == 2
        assert all(area["score"] >= 4500 for area in result.strong_areas)

    @pytest.mark.asyncio
    async def test_analyze_recent_games(self, analysis_service, mock_game_service, sample_games):
        """Test analyze_recent_games method."""
        mock_game_service.get_recent_games.return_value = sample_games

        with patch.object(analysis_service, "analyze_games", wraps=AnalysisService.analyze_games):
            result = await analysis_service.analyze_recent_games(count=5)

        assert "analysis" in result
        assert "games" in result
        assert result["analysis"]["games_analyzed"] == 5
        mock_game_service.get_recent_games.assert_called_once_with(5, None)

    @pytest.mark.asyncio
    async def test_analyze_recent_games_with_session(
            self, analysis_service, mock_game_service, sample_games
    ):
        """Test analyze_recent_games with session token."""
        mock_game_service.get_recent_games.return_value = sample_games

        await analysis_service.analyze_recent_games(count=10, session_token="test_token")

        mock_game_service.get_recent_games.assert_called_once_with(10, "test_token")

    @pytest.mark.asyncio
    async def test_get_performance_summary(
            self,
            analysis_service,
            mock_game_service,
            mock_profile_service,
            mock_client,
            sample_games,
            mock_season_stats_data,
            mock_dynamic_response,
    ):
        """Test comprehensive performance summary."""
        mock_profile_service.get_comprehensive_profile.return_value = {
            "profile": {"nick": "TestPlayer"},
            "stats": {"games_played": 100},
        }

        mock_season_response = mock_dynamic_response(mock_season_stats_data)
        from geoguessr_mcp.models import SeasonStats

        mock_season_stats = SeasonStats.from_api_response(mock_season_stats_data)
        mock_game_service.get_season_stats.return_value = (mock_season_stats, mock_season_response)
        mock_game_service.get_recent_games.return_value = sample_games[:3]

        mock_client.get.return_value = mock_dynamic_response({"progress": 0.5})

        result = await analysis_service.get_performance_summary()

        assert result["profile"] is not None
        assert result["season"] is not None
        assert result["recent_games_analysis"] is not None
        assert "api_status" in result

    @pytest.mark.asyncio
    async def test_get_performance_summary_with_errors(
            self, analysis_service, mock_game_service, mock_profile_service, mock_client
    ):
        """Test performance summary handles errors gracefully."""
        mock_profile_service.get_comprehensive_profile.side_effect = Exception("Profile error")
        mock_game_service.get_season_stats.side_effect = Exception("Season error")
        mock_game_service.get_recent_games.return_value = []
        mock_client.get.side_effect = Exception("API error")

        result = await analysis_service.get_performance_summary()

        assert len(result["errors"]) > 0
        assert result["profile"] is None
        assert result["season"] is None

    @pytest.mark.asyncio
    async def test_get_strategy_recommendations_low_perfect_rate(
            self, analysis_service, mock_game_service
    ):
        """Test strategy recommendations for low perfect round rate."""
        # Create games with no perfect rounds
        rounds = [
            RoundGuess(round_number=i, score=3000, distance_meters=500, time_seconds=30)
            for i in range(5)
        ]
        games = [
            Game(
                token="g1",
                map_name="World",
                mode="standard",
                total_score=15000,
                rounds=rounds,
                finished=True,
            )
            for _ in range(5)
        ]
        mock_game_service.get_recent_games.return_value = games

        result = await analysis_service.get_strategy_recommendations()

        assert len(result["recommendations"]) > 0
        accuracy_recs = [r for r in result["recommendations"] if r["category"] == "accuracy"]
        assert len(accuracy_recs) > 0

    @pytest.mark.asyncio
    async def test_get_strategy_recommendations_fast_play(
            self, analysis_service, mock_game_service
    ):
        """Test strategy recommendations for fast play style."""
        # Create games with very short time
        rounds = [
            RoundGuess(round_number=i, score=3500, distance_meters=300, time_seconds=15)
            for i in range(5)
        ]
        games = [
            Game(
                token="g1",
                map_name="World",
                mode="standard",
                total_score=17500,
                rounds=rounds,
                finished=True,
            )
            for _ in range(5)
        ]
        mock_game_service.get_recent_games.return_value = games

        result = await analysis_service.get_strategy_recommendations()

        time_recs = [r for r in result["recommendations"] if r["category"] == "time_management"]
        assert len(time_recs) > 0

    @pytest.mark.asyncio
    async def test_get_strategy_recommendations_declining_trend(
            self, analysis_service, mock_game_service
    ):
        """Test strategy recommendations for declining performance."""
        # Create games with declining scores
        games = []
        for i in range(6):
            base_score = 25000 - (i * 3000)
            rounds = [
                RoundGuess(round_number=1, score=base_score, distance_meters=100, time_seconds=45)
            ]
            game = Game(
                token=f"game-{i}",
                map_name="World",
                mode="standard",
                total_score=base_score,
                rounds=rounds,
                finished=True,
            )
            games.append(game)
        mock_game_service.get_recent_games.return_value = games

        result = await analysis_service.get_strategy_recommendations()

        consistency_recs = [r for r in result["recommendations"] if r["category"] == "consistency"]
        assert len(consistency_recs) > 0
        assert result["analysis_summary"]["trend"] == "declining"

    @pytest.mark.asyncio
    async def test_get_strategy_recommendations_many_weak_areas(
            self, analysis_service, mock_game_service
    ):
        """Test strategy recommendations for many weak rounds."""
        # Create games with many low scores
        games = []
        for i in range(4):
            rounds = [
                RoundGuess(round_number=j, score=1500, distance_meters=5000, time_seconds=60)
                for j in range(5)
            ]
            game = Game(
                token=f"game-{i}",
                map_name="World",
                mode="standard",
                total_score=7500,
                rounds=rounds,
                finished=True,
            )
            games.append(game)
        mock_game_service.get_recent_games.return_value = games

        result = await analysis_service.get_strategy_recommendations()

        practice_recs = [r for r in result["recommendations"] if r["category"] == "practice"]
        assert len(practice_recs) > 0