"""
TestGame 示例游戏
用于测试引擎的简单猜数字游戏
"""
import random
from typing import Dict, List, Optional, Any

from .game_base import GameBase, GamePhase


class TestGame(GameBase):
    """
    猜数字游戏
    用于测试引擎的简单游戏
    - 系统随机生成 1-100 的数字
    - 玩家轮流猜数字
    - 系统提示大了/小了/对了
    - 猜中者获胜
    """
    
    def __init__(self, room_id: str, game_type: str):
        super().__init__(room_id, game_type)
        
        self.target_number: Optional[int] = None
        self.min_guess = 1
        self.max_guess = 100
        self.guesses: Dict[str, List[int]] = {}  # player_id -> guesses
    
    @property
    def min_players(self) -> int:
        return 1
    
    @property
    def max_players(self) -> int:
        return 4
    
    def can_start(self) -> bool:
        return self.player_count >= self.min_players
    
    def start(self):
        """开始游戏"""
        if not self.can_start():
            raise ValueError("玩家不足")
        
        # 生成目标数字
        self.target_number = random.randint(self.min_guess, self.max_guess)
        
        # 初始化玩家猜测记录
        for player_id in self.players:
            self.guesses[player_id] = []
        
        # 设置第一个玩家
        if self.player_order:
            self.state.next_turn(self.player_order[0])
        
        self.state.start()
        self.is_started = True
        
        # 更新游戏状态数据
        self.state.data = {
            'min': self.min_guess,
            'max': self.max_guess,
            'target': self.target_number,  # 只有服务端知道
        }
    
    def handle_action(self, player_id: str, action: str, data: Dict) -> Dict[str, Any]:
        """处理玩家操作"""
        # 检查是否是当前玩家回合
        if self.state.current_turn_player_id != player_id:
            return {
                'success': False,
                'message': '不是你的回合'
            }
        
        if action != 'guess':
            return {
                'success': False,
                'message': f'无效的操作: {action}'
            }
        
        # 获取猜测的数字
        guess = data.get('number')
        if not isinstance(guess, int) or guess < self.min_guess or guess > self.max_guess:
            return {
                'success': False,
                'message': f'请输入 {self.min_guess}-{self.max_guess} 之间的整数'
            }
        
        # 记录猜测
        self.guesses[player_id].append(guess)
        
        # 判断结果
        if guess == self.target_number:
            # 猜中了
            self.state.data['last_result'] = {
                'player_id': player_id,
                'guess': guess,
                'result': 'correct'
            }
            self.end_game(player_id)
            return {
                'success': True,
                'message': f'恭喜！{guess} 是正确的数字！',
                'result': 'correct',
                'winner': player_id
            }
        elif guess < self.target_number:
            result = 'too_small'
            message = f'{guess} 太小了'
        else:
            result = 'too_large'
            message = f'{guess} 太大了'
        
        self.state.data['last_result'] = {
            'player_id': player_id,
            'guess': guess,
            'result': result
        }
        
        # 记录历史
        self.state.add_history('guess', player_id, {'guess': guess, 'result': result})
        
        # 切换到下一个玩家
        self.next_player()
        
        return {
            'success': True,
            'message': message,
            'result': result,
            'next_turn': self.state.current_turn_player_id
        }
    
    def get_valid_actions(self, player_id: str) -> List[str]:
        """获取可用操作"""
        if self.state.current_turn_player_id != player_id:
            return []
        return ['guess']
    
    def check_winner(self) -> Optional[str]:
        """检查获胜者"""
        return self.state.winner_id
    
    def to_dict(self) -> Dict[str, Any]:
        """序列化游戏状态"""
        data = super().to_dict()
        
        # 添加游戏特定数据（隐藏目标数字）
        client_data = dict(self.state.data)
        client_data.pop('target', None)  # 客户端看不到目标数字
        
        data['state']['data'] = client_data
        data['guesses'] = self.guesses
        
        return data