"""
Net-Games 主服务器
Flask-SocketIO 游戏服务 + 登录认证
"""
import os
import sys
import logging
import json
from datetime import datetime, timedelta
from functools import wraps
from typing import Dict, Any, Optional

from flask import Flask, request, jsonify, send_from_directory
from flask_socketio import SocketIO, emit, join_room, leave_room, disconnect, disconnect
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, login_user, logout_user, login_required, current_user
from flask_cors import CORS
from werkzeug.security import generate_password_hash, check_password_hash
import threading
import asyncio

# 添加当前目录到路径
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from config import (
    HOST, PORT, DEBUG, SOCKET_IO_CONFIG,
    LOG_LEVEL, LOG_FORMAT
)
from engine import RoomManager, HumanPlayer, AIPlayer

# 配置日志
logging.basicConfig(level=getattr(logging, LOG_LEVEL), format=LOG_FORMAT)
logger = logging.getLogger(__name__)

# 创建 Flask 应用
app = Flask(__name__)
app.config['SECRET_KEY'] = 'net-games-secret-key-2026'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///net_games_auth.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# Session cookie 配置
app.config['SESSION_COOKIE_HTTPONLY'] = True
app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'
app.config['SESSION_COOKIE_SECURE'] = False

# 初始化扩展
db = SQLAlchemy(app)
CORS(app, supports_credentials=True, origins='*')

# Flask-Login
login_manager = LoginManager()
login_manager.init_app(app)

# 创建 SocketIO
socketio = SocketIO(app, **SOCKET_IO_CONFIG)

# 获取房间管理器
room_manager = RoomManager()

# 存储 socket 到玩家的映射
socket_player_map: dict = {}

# 存储用户到 socket 的映射（用于单点登录，一个用户只能有一个活跃连接）
user_socket_map: dict = {}

# 存储用户到房间的映射（用于服务器端重连，支持跨浏览器）
user_room_map: dict = {}  # user_id/username -> room_id

# 回合超时管理
room_turn_timers: dict = {}  # room_id -> timer
player_timeout_count: dict = {}  # player_id -> count
TURN_TIMEOUT_SECONDS = 30  # 回合超时时间
MAX_TIMEOUT_COUNT = 3  # 最大超时次数，超过则托管

# 注册游戏类型
from engine.test_game import TestGame
from doudizhu import DoudizhuGame
room_manager.register_game('test_game', TestGame)
room_manager.register_game('doudizhu', DoudizhuGame)

# 导入AI适配器
from doudizhu.ai_adapters import create_doudizhu_ai, DoudizhuRuleAI


# ============ 数据库模型 ============

class User(db.Model):
    """用户模型"""
    __tablename__ = 'users'
    
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    nickname = db.Column(db.String(80), nullable=True)  # 昵称，默认同用户名
    password_hash = db.Column(db.String(200), nullable=False)
    created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
    
    # 用户角色：admin 或 user
    role = db.Column(db.String(20), default='user')
    
    # 各游戏独立积分
    game_scores = db.Column(db.Text, default='{}')
    
    def is_admin(self):
        """检查是否为管理员"""
        return self.role == 'admin'
    
    def get_nickname(self):
        """获取昵称，默认为用户名"""
        return self.nickname or self.username
    
    def set_password(self, password):
        self.password_hash = generate_password_hash(password)
    
    def check_password(self, password):
        return check_password_hash(self.password_hash, password)
    
    def get_game_score(self, game_id):
        try:
            scores = json.loads(self.game_scores or '{}')
            return scores.get(game_id, 0)
        except:
            return 0
    
    def add_game_score(self, game_id, points):
        try:
            scores = json.loads(self.game_scores or '{}')
            scores[game_id] = scores.get(game_id, 0) + points
            self.game_scores = json.dumps(scores)
            return scores[game_id]
        except:
            return 0
    
    def to_dict(self, include_role=False):
        data = {
            'id': self.id,
            'username': self.username,
            'nickname': self.get_nickname(),
            'created_at': self.created_at.isoformat() if self.created_at else None
        }
        if include_role:
            data['role'] = self.role
            data['is_admin'] = self.is_admin()
        return data
    
    # Flask-Login 要求的方法
    def is_authenticated(self):
        return True
    
    def is_active(self):
        return True
    
    def is_anonymous(self):
        return False
    
    def get_id(self):
        return str(self.id)


@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))


def init_default_users():
    """初始化默认用户"""
    default_users = [
        {'username': 'admin', 'password': 'zf9wx4xm7', 'nickname': '管理员', 'role': 'admin'}
    ]
    
    for user_data in default_users:
        existing = User.query.filter_by(username=user_data['username']).first()
        if not existing:
            user = User(
                username=user_data['username'],
                nickname=user_data.get('nickname', user_data['username']),
                role=user_data.get('role', 'user')
            )
            user.set_password(user_data['password'])
            db.session.add(user)
            logger.info(f"✅ 创建默认用户: {user_data['username']} (role={user_data.get('role', 'user')})")
        else:
            # 更新现有用户的角色（如果未设置）
            if not existing.role:
                existing.role = user_data.get('role', 'user')
                logger.info(f"🔄 更新用户角色: {user_data['username']} -> {existing.role}")
    
    db.session.commit()


def api_login_required(f):
    """API 登录检查"""
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not current_user.is_authenticated:
            return jsonify({
                'error': 'Unauthorized',
                'message': '请先登录',
                'code': 401
            }), 401
        return f(*args, **kwargs)
    return decorated_function


def admin_required(f):
    """管理员权限检查"""
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not current_user.is_authenticated:
            return jsonify({
                'error': 'Unauthorized',
                'message': '请先登录',
                'code': 401
            }), 401
        if not current_user.is_admin():
            return jsonify({
                'error': 'Forbidden',
                'message': '需要管理员权限',
                'code': 403
            }), 403
        return f(*args, **kwargs)
    return decorated_function


# ============ HTTP API ============

# 静态文件目录
CLIENT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'client')
HUB_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'hub')


@app.route('/')
def index():
    """首页 - 返回游戏大厅"""
    return send_from_directory(HUB_DIR, 'index.html')


@app.route('/doudizhu/')
def doudizhu_game():
    """斗地主游戏"""
    return send_from_directory(CLIENT_DIR, 'index.html')


# ============ 认证 API ============

@app.route('/api/auth/status')
def auth_status():
    """检查登录状态"""
    if current_user.is_authenticated:
        return jsonify({
            'authenticated': True,
            'user': current_user.to_dict(include_role=True)
        })
    return jsonify({'authenticated': False, 'user': None})


@app.route('/api/auth/login', methods=['POST'])
def login():
    """用户登录"""
    data = request.get_json()
    
    if not data:
        return jsonify({'error': '请求数据为空'}), 400
    
    username = data.get('username', '').strip()
    password = data.get('password', '').strip()
    
    if not username or not password:
        return jsonify({'error': '用户名和密码不能为空'}), 400
    
    user = User.query.filter_by(username=username).first()
    
    if not user or not user.check_password(password):
        return jsonify({'error': '用户名或密码错误'}), 401
    
    login_user(user, remember=True, duration=timedelta(days=30))
    
    return jsonify({
        'success': True,
        'message': '登录成功',
        'user': user.to_dict(include_role=True)
    })


@app.route('/api/auth/register', methods=['POST'])
def register():
    """用户注册"""
    data = request.get_json()
    
    if not data:
        return jsonify({'error': '请求数据为空'}), 400
    
    username = data.get('username', '').strip()
    password = data.get('password', '').strip()
    
    if not username or not password:
        return jsonify({'error': '用户名和密码不能为空'}), 400
    
    if len(username) < 3 or len(username) > 20:
        return jsonify({'error': '用户名长度需在3-20个字符之间'}), 400
    
    if len(password) < 6:
        return jsonify({'error': '密码长度至少6位'}), 400
    
    # 检查用户名是否已存在
    if User.query.filter_by(username=username).first():
        return jsonify({'error': '用户名已被注册'}), 409
    
    # 创建新用户（昵称默认为用户名）
    new_user = User(username=username, nickname=username)
    new_user.set_password(password)
    
    db.session.add(new_user)
    db.session.commit()
    
    # 自动登录
    login_user(new_user, remember=True, duration=timedelta(days=30))
    
    return jsonify({
        'success': True,
        'message': '注册成功',
        'user': new_user.to_dict()
    })


@app.route('/api/auth/logout', methods=['POST'])
@login_required
def logout():
    """用户登出"""
    logout_user()
    return jsonify({
        'success': True,
        'message': '已登出'
    })


@app.route('/api/user/profile', methods=['GET'])
@api_login_required
def get_profile():
    """获取用户个人资料"""
    return jsonify({
        'success': True,
        'user': current_user.to_dict()
    })


@app.route('/api/user/profile', methods=['PUT'])
@api_login_required
def update_profile():
    """更新用户个人资料（昵称）"""
    data = request.get_json()
    if not data:
        return jsonify({'error': '请求数据为空'}), 400
    
    nickname = data.get('nickname', '').strip()
    
    if nickname:
        if len(nickname) < 2 or len(nickname) > 20:
            return jsonify({'error': '昵称长度需在2-20个字符之间'}), 400
        current_user.nickname = nickname
        db.session.commit()
    
    return jsonify({
        'success': True,
        'message': '个人资料已更新',
        'user': current_user.to_dict()
    })


@app.route('/api/user/password', methods=['PUT'])
@api_login_required
def update_password():
    """修改密码"""
    data = request.get_json()
    if not data:
        return jsonify({'error': '请求数据为空'}), 400
    
    old_password = data.get('old_password', '')
    new_password = data.get('new_password', '')
    
    if not old_password or not new_password:
        return jsonify({'error': '请填写旧密码和新密码'}), 400
    
    if len(new_password) < 6:
        return jsonify({'error': '新密码长度至少6位'}), 400
    
    # 验证旧密码
    if not current_user.check_password(old_password):
        return jsonify({'error': '旧密码错误'}), 401
    
    # 更新密码
    current_user.set_password(new_password)
    db.session.commit()
    
    return jsonify({
        'success': True,
        'message': '密码修改成功，请重新登录'
    })


@app.route('/api/user/score', methods=['POST'])
@api_login_required
def update_score():
    """更新游戏积分"""
    data = request.get_json()
    if not data:
        return jsonify({'error': '请求数据为空'}), 400
    
    game_id = data.get('game')
    points = data.get('points', 0)
    
    if not game_id:
        return jsonify({'error': '缺少游戏ID'}), 400
    
    new_score = current_user.add_game_score(game_id, points)
    db.session.commit()
    
    return jsonify({
        'success': True,
        'game': game_id,
        'new_score': new_score
    })


@app.route('/doudizhu/<path:filename>')
def doudizhu_static(filename):
    """斗地主游戏静态文件"""
    return send_from_directory(CLIENT_DIR, filename)


@app.route('/<path:filename>')
def static_files(filename):
    """静态文件服务"""
    return send_from_directory(CLIENT_DIR, filename)


@app.route('/api/rooms')
def get_rooms():
    """获取房间列表"""
    game_type = request.args.get('game_type')
    status = request.args.get('status', 'waiting')
    
    rooms = room_manager.get_all_rooms(game_type=game_type, status=status)
    
    return jsonify({
        'success': True,
        'rooms': [room.to_dict(include_game_state=False) for room in rooms]
    })


@app.route('/api/rooms/<room_code>')
def get_room_info(room_code: str):
    """获取房间信息"""
    room = room_manager.get_room(room_code=room_code)
    if not room:
        return jsonify({'success': False, 'error': '房间不存在'}), 404
    
    return jsonify({
        'success': True,
        'room': room.to_dict(include_game_state=True)
    })


@app.route('/api/stats')
def get_stats():
    """获取服务统计（公开接口）"""
    all_rooms = room_manager.get_all_rooms()
    
    return jsonify({
        'success': True,
        'stats': {
            'total_rooms': len(all_rooms),
            'waiting_rooms': len([r for r in all_rooms if r.status == 'waiting']),
            'playing_rooms': len([r for r in all_rooms if r.status == 'playing']),
            'total_players': sum(r.player_count for r in all_rooms),
        }
    })


@app.route('/api/user/scores')
@api_login_required
def get_user_scores():
    """获取当前用户各游戏积分"""
    game_id = request.args.get('game')
    
    if game_id:
        # 获取特定游戏积分
        score = current_user.get_game_score(game_id)
        return jsonify({
            'success': True,
            'game_id': game_id,
            'score': score
        })
    else:
        # 获取所有游戏积分
        try:
            scores = json.loads(current_user.game_scores or '{}')
        except:
            scores = {}
        return jsonify({
            'success': True,
            'scores': scores
        })


@app.route('/api/admin/stats')
@admin_required
def get_admin_stats():
    """获取管理员详细统计"""
    all_rooms = room_manager.get_all_rooms()
    
    # 按游戏类型统计
    game_stats = {}
    for room in all_rooms:
        game_type = room.game_type
        if game_type not in game_stats:
            game_stats[game_type] = {
                'total': 0,
                'waiting': 0,
                'playing': 0,
                'players': 0
            }
        game_stats[game_type]['total'] += 1
        game_stats[game_type]['players'] += room.player_count
        if room.status == 'waiting':
            game_stats[game_type]['waiting'] += 1
        elif room.status == 'playing':
            game_stats[game_type]['playing'] += 1
    
    # 房间详情
    rooms_detail = []
    for room in all_rooms:
        rooms_detail.append({
            'code': room.code,
            'game_type': room.game_type,
            'status': room.status,
            'player_count': room.player_count,
            'max_players': room.max_players,
            'host_id': room.host_id,
            'created_at': room.created_at,
            'players': [
                {
                    'id': p.id,
                    'name': p.name,
                    'type': 'AI' if p.is_ai else 'Human',
                    'is_connected': p.is_connected,
                    'is_ai_controlled': p.is_ai_controlled
                }
                for p in room.players.values()
            ]
        })
    
    # 在线用户统计
    online_users = len(active_usernames)
    
    return jsonify({
        'success': True,
        'stats': {
            'total_rooms': len(all_rooms),
            'waiting_rooms': len([r for r in all_rooms if r.status == 'waiting']),
            'playing_rooms': len([r for r in all_rooms if r.status == 'playing']),
            'total_players': sum(r.player_count for r in all_rooms),
            'online_users': online_users,
            'by_game': game_stats,
            'rooms': rooms_detail
        }
    })


@app.route('/api/admin/rooms/<room_code>', methods=['DELETE'])
@admin_required
def admin_close_room(room_code: str):
    """管理员强制关闭房间"""
    room = room_manager.get_room(room_code=room_code)
    if not room:
        return jsonify({'error': '房间不存在'}), 404
    
    # 通知房间内玩家
    socketio.emit('room_closed', {
        'message': '房间已被管理员关闭',
        'by_admin': True
    }, room=room.id)
    
    # 关闭房间并清理
    room.close()
    room_manager._cleanup_room(room.id)
    
    # 清理用户-房间映射
    for username, mapped_room_id in list(user_room_map.items()):
        if mapped_room_id == room.id:
            del user_room_map[username]
    
    logger.info(f"管理员关闭了房间: {room_code}")
    
    return jsonify({
        'success': True,
        'message': f'房间 {room_code} 已关闭'
    })


@app.route('/test_client.html')
def serve_test_client():
    """提供测试客户端"""
    return send_from_directory('.', 'test_client.html')


# ============ Socket.IO Events ============

@socketio.on('connect')
def handle_connect():
    """客户端连接"""
    socket_id = request.sid
    logger.info(f"Client connected: {socket_id}")
    
    # 检查是否已登录用户
    if current_user.is_authenticated:
        user_id = current_user.id
        
        # 检查该用户是否已有活跃连接
        old_socket_id = user_socket_map.get(user_id)
        if old_socket_id and old_socket_id != socket_id:
            logger.info(f"User {user_id} 新连接 {socket_id}，踢掉旧连接 {old_socket_id}")
            
            # 清理旧连接的游戏状态
            old_player_id = socket_player_map.get(old_socket_id)
            if old_player_id:
                old_room = room_manager.get_room_by_player(old_player_id)
                if old_room:
                    old_player = old_room.players.get(old_player_id)
                    if old_player:
                        # 标记旧玩家为断开状态，允许重连匹配
                        old_player.disconnect()
                        logger.info(f"Player {old_player.name} marked as disconnected (kicked)")
                        
                        # 从 active_usernames 中移除旧连接
                        old_identity = old_player.name
                        if old_identity in active_usernames and active_usernames[old_identity] == old_player_id:
                            del active_usernames[old_identity]
                            logger.info(f"Removed {old_identity} from active_usernames (kicked)")
            
            # 通知旧连接被踢下线
            socketio.emit('kicked', {
                'reason': 'new_login',
                'message': '您的账号已在其他页面登录'
            }, room=old_socket_id)
            
            # 断开旧连接
            socketio.server.disconnect(old_socket_id, namespace='/')
            
            # 清理旧连接的映射
            if old_socket_id in socket_player_map:
                del socket_player_map[old_socket_id]
        
        # 记录新连接
        user_socket_map[user_id] = socket_id
        logger.info(f"User {user_id} 绑定到 socket {socket_id}")
        
        # 检查用户是否有正在进行的游戏
        if current_user.is_authenticated:
            username = current_user.username
            if username in user_room_map:
                room_id = user_room_map[username]
                room = room_manager.get_room(room_id=room_id)
                if room:
                    logger.info(f"User {username} has active game in room {room.code}")
    
    # 发送连接响应，包含用户当前游戏状态
    response = {
        'socket_id': socket_id,
        'message': '欢迎连接到 Net-Games'
    }
    
    # 如果是登录用户且有正在进行的游戏，告诉客户端
    if current_user.is_authenticated:
        username = current_user.username
        if username in user_room_map:
            room_id = user_room_map[username]
            room = room_manager.get_room(room_id=room_id)
            if room:
                response['has_active_game'] = True
                response['room_code'] = room.code
                response['room_id'] = room.id
                logger.info(f"Notifying user {username} of active game in room {room.code}")
    
    emit('connected', response)


@socketio.on('disconnect')
def handle_disconnect():
    """客户端断开"""
    socket_id = request.sid
    logger.info(f"Client disconnected: {socket_id}")
    
    # 清理用户-socket映射（如果是当前活跃连接）
    if current_user.is_authenticated:
        user_id = current_user.id
        if user_socket_map.get(user_id) == socket_id:
            del user_socket_map[user_id]
            logger.info(f"User {user_id} 断开连接，清理映射")
    
    # 如果玩家在某个房间，处理离线（但不移除玩家，支持重连）
    player_id = socket_player_map.get(socket_id)
    if player_id:
        room = room_manager.get_room_by_player(player_id)
        if room:
            player = room.players.get(player_id)
            if player:
                player.disconnect()
                logger.info(f"Player {player.name} disconnected from room {room.code}, waiting for reconnect")
                
                # 从 active_usernames 中移除，允许用相同身份重新加入
                identity_key = current_user.username if current_user.is_authenticated else player.name
                if identity_key in active_usernames and active_usernames[identity_key] == player_id:
                    del active_usernames[identity_key]
                    logger.info(f"Removed {identity_key} from active_usernames")
                
                # 通知房间其他玩家
                emit('player_disconnected', {
                    'player_id': player_id,
                    'player_name': player.name,
                    'will_ai_control': True  # 提示将启用AI托管
                }, room=room.id, broadcast=True)
                
                # 启动定时器：30秒后启用AI托管
                socketio.start_background_task(
                    ai_control_after_timeout, 
                    room.id, 
                    player_id, 
                    timeout=30
                )
        
        # 清理映射（但保留玩家-房间关系）
        del socket_player_map[socket_id]


@socketio.on('create_room')
def handle_create_room(data: dict):
    """创建房间"""
    game_type = data.get('game_type', 'doudizhu')
    player_name = data.get('player_name', '玩家')
    config = data.get('config', {})
    ai_config = data.get('ai_config', {})  # {ai_count: 2, ai_types: ['rule', 'deepseek']}
    ai_players = data.get('ai_players', [])  # [{name: 'AI-1', ai_type: 'rule'}, ...]
    
    # 检查游戏类型是否已注册
    if game_type not in room_manager._game_registry:
        emit('error', {
            'code': 'GAME_NOT_REGISTERED',
            'message': f'游戏类型 {game_type} 未注册'
        })
        return
    
    # 单点登录检查：使用用户名（已登录）或昵称（未登录）
    identity_key = current_user.username if current_user.is_authenticated else player_name
    
    if identity_key in active_usernames:
        existing_player_id = active_usernames[identity_key]
        existing_room = room_manager.get_room_by_player(existing_player_id)
        if existing_room:
            existing_player = existing_room.players.get(existing_player_id)
            if existing_player and existing_player.is_connected:
                identity_type = "账号" if current_user.is_authenticated else "昵称"
                emit('error', {
                    'code': 'ALREADY_ONLINE',
                    'message': f'{identity_type} "{identity_key}" 已在游戏中，请先退出或等待30秒后重试'
                })
                return
            else:
                del active_usernames[identity_key]
    
    # 获取游戏配置
    max_players = config.get('max_players', 3)
    
    # 创建房间
    room = room_manager.create_room(game_type, max_players, config)
    if not room:
        emit('error', {
            'code': 'CREATE_FAILED',
            'message': '创建房间失败'
        })
        return
    
    # 创建玩家
    player = HumanPlayer(player_name)
    player.connect(request.sid)
    
    # 记录活跃玩家（使用用户名或昵称）
    active_usernames[identity_key] = player.id
    
    # 玩家加入房间
    success, message = room_manager.join_room(room.code, player)
    if not success:
        emit('error', {
            'code': 'JOIN_FAILED',
            'message': message
        })
        return
    
    # 记录用户-房间映射（支持服务器端重连）
    if current_user.is_authenticated:
        user_room_map[current_user.username] = room.id
        logger.info(f"User {current_user.username} mapped to room {room.code}")
    
    # 记录映射
    socket_player_map[request.sid] = player.id
    
    # 加入 Socket.IO 房间
    join_room(room.id)
    
    # 如果是斗地主，自动添加AI玩家
    if game_type == 'doudizhu':
        # 优先使用 ai_players 参数（新格式）
        if ai_players:
            for ai_info in ai_players:
                ai_name = ai_info.get('name', f"AI-{len(room.players)+1}")
                ai_type = ai_info.get('ai_type', 'rule')
                ai_player = AIPlayer(ai_name, ai_type)
                ai_player.ai_type = ai_type
                room.add_player(ai_player)
                logger.info(f"AI player {ai_player.name} added to room {room.code}")
        else:
            # 兼容旧格式 ai_config
            ai_count = ai_config.get('ai_count', 2)
            ai_types = ai_config.get('ai_types', ['rule', 'rule'])
            
            for i in range(ai_count):
                ai_type = ai_types[i] if i < len(ai_types) else 'rule'
                ai_player = AIPlayer(f"AI-{i+1}({ai_type})", ai_type)
                ai_player.ai_type = ai_type  # 保存AI类型
                room.add_player(ai_player)
                logger.info(f"AI player {ai_player.name} added to room {room.code}")
    
    logger.info(f"Room {room.code} created by {player_name}")
    
    emit('room_created', {
        'success': True,
        'room': room.to_dict(),
        'player': player.to_dict(include_private=True)
    })


@socketio.on('join_room')
def handle_join_room(data: dict):
    """加入房间"""
    room_code = data.get('room_code', '').upper()
    player_name = data.get('player_name', '玩家')
    
    if not room_code:
        emit('error', {
            'code': 'INVALID_CODE',
            'message': '房间号不能为空'
        })
        return
    
    # 单点登录检查：使用用户名（已登录）或昵称（未登录）
    identity_key = current_user.username if current_user.is_authenticated else player_name
    
    if identity_key in active_usernames:
        existing_player_id = active_usernames[identity_key]
        existing_room = room_manager.get_room_by_player(existing_player_id)
        if existing_room:
            existing_player = existing_room.players.get(existing_player_id)
            if existing_player and existing_player.is_connected:
                identity_type = "账号" if current_user.is_authenticated else "昵称"
                emit('error', {
                    'code': 'ALREADY_ONLINE',
                    'message': f'{identity_type} "{identity_key}" 已在游戏中，请先退出或等待30秒后重试'
                })
                return
            else:
                del active_usernames[identity_key]
    
    # 创建玩家
    player = HumanPlayer(player_name)
    player.connect(request.sid)
    
    # 记录活跃玩家（使用用户名或昵称）
    active_usernames[identity_key] = player.id
    
    # 加入房间
    success, message = room_manager.join_room(room_code, player)
    if not success:
        emit('error', {
            'code': 'JOIN_FAILED',
            'message': message
        })
        return
    
    room = room_manager.get_room_by_player(player.id)
    
    # 记录用户-房间映射（支持服务器端重连）
    if current_user.is_authenticated:
        user_room_map[current_user.username] = room.id
        logger.info(f"User {current_user.username} mapped to room {room.code}")
    
    # 记录映射
    socket_player_map[request.sid] = player.id
    
    # 加入 Socket.IO 房间
    join_room(room.id)
    
    logger.info(f"Player {player_name} joined room {room_code}")
    
    # 通知自己
    emit('room_joined', {
        'success': True,
        'room': room.to_dict(),
        'player': player.to_dict(include_private=True)
    })
    
    # 通知房间其他人
    emit('player_joined', {
        'player': player.to_dict()
    }, room=room.id, broadcast=True, include_self=False)


@socketio.on('leave_room')
def handle_leave_room():
    """离开房间"""
    socket_id = request.sid
    player_id = socket_player_map.get(socket_id)
    
    if not player_id:
        emit('error', {'code': 'NOT_IN_ROOM', 'message': '不在任何房间中'})
        return
    
    room = room_manager.get_room_by_player(player_id)
    if not room:
        emit('error', {'code': 'ROOM_NOT_FOUND', 'message': '房间不存在'})
        return
    
    player = room.players.get(player_id)
    player_name = player.name if player else 'Unknown'
    
    # 清理活跃玩家记录（根据用户名或昵称）
    identity_key = current_user.username if current_user.is_authenticated else player_name
    if identity_key in active_usernames:
        del active_usernames[identity_key]
    
    # 清理用户-房间映射
    if current_user.is_authenticated and current_user.username in user_room_map:
        del user_room_map[current_user.username]
        logger.info(f"User {current_user.username} room mapping cleared")
    
    # 离开房间
    room_manager.leave_room(player_id)
    
    # 离开 Socket.IO 房间
    leave_room(room.id)
    
    logger.info(f"Player {player_name} left room {room.code}")
    
    # 通知自己
    emit('room_left', {'success': True})
    
    # 通知房间其他人
    emit('player_left', {
        'player_id': player_id,
        'player_name': player_name
    }, room=room.id, broadcast=True, include_self=False)


@socketio.on('set_ready')
def handle_set_ready(data: dict):
    """设置准备状态"""
    socket_id = request.sid
    player_id = socket_player_map.get(socket_id)
    
    if not player_id:
        emit('error', {'code': 'NOT_IN_ROOM', 'message': '不在任何房间中'})
        return
    
    room = room_manager.get_room_by_player(player_id)
    if not room:
        emit('error', {'code': 'ROOM_NOT_FOUND', 'message': '房间不存在'})
        return
    
    player = room.players.get(player_id)
    if not player:
        emit('error', {'code': 'PLAYER_NOT_FOUND', 'message': '玩家不存在'})
        return
    
    ready = data.get('ready', True)
    player.set_ready(ready)
    
    logger.info(f"Player {player.name} ready={ready} in room {room.code}")
    
    # 广播状态更新
    emit('room_updated', {
        'room': room.to_dict()
    }, room=room.id, broadcast=True)


@socketio.on('start_game')
def handle_start_game():
    """开始游戏（仅房主）"""
    socket_id = request.sid
    player_id = socket_player_map.get(socket_id)
    
    if not player_id:
        emit('error', {'code': 'NOT_IN_ROOM', 'message': '不在任何房间中'})
        return
    
    room = room_manager.get_room_by_player(player_id)
    if not room:
        emit('error', {'code': 'ROOM_NOT_FOUND', 'message': '房间不存在'})
        return
    
    # 检查是否是房主
    if room.host_id != player_id:
        emit('error', {'code': 'NOT_HOST', 'message': '只有房主可以开始游戏'})
        return
    
    # 开始游戏
    success, message = room_manager.start_game(room.id)
    if not success:
        emit('error', {'code': 'START_FAILED', 'message': message})
        return
    
    logger.info(f"Game started in room {room.code}")
    
    # 广播游戏开始
    emit('game_started', {
        'room': room.to_dict(include_game_state=True)
    }, room=room.id, broadcast=True)
    
    # 启动回合超时定时器
    start_turn_timer(room.id)
    
    # 如果是斗地主且当前是AI回合，触发AI
    if room.game_type == 'doudizhu':
        check_and_trigger_ai(room.id)


@socketio.on('game_action')
def handle_game_action(data: dict):
    """处理游戏操作"""
    socket_id = request.sid
    player_id = socket_player_map.get(socket_id)
    
    if not player_id:
        emit('error', {'code': 'NOT_IN_ROOM', 'message': '不在任何房间中'})
        return
    
    room = room_manager.get_room_by_player(player_id)
    if not room or not room.game:
        emit('error', {'code': 'GAME_NOT_STARTED', 'message': '游戏未开始'})
        return
    
    action = data.get('action')
    action_data = data.get('data', {})
    
    # 处理托管切换请求
    if action == 'toggle_trustee':
        handle_toggle_trustee(room, player_id)
        return
    
    # 处理操作
    result = room.game.handle_action(player_id, action, action_data)
    
    # 更新房间活动时间
    room.update_activity()
    
    if result.get('success'):
        logger.info(f"Action {action} by {player_id} in room {room.code}")
        
        # 重置玩家超时计数（正常操作）
        reset_player_timeout(player_id)
        
        # 取消旧定时器，启动新定时器
        start_turn_timer(room.id)
        
        # 广播状态更新
        emit('state_update', {
            'action': action,
            'player_id': player_id,
            'result': result,
            'game_state': room.game.to_dict()
        }, room=room.id, broadcast=True)
        
        # 检查游戏是否结束
        winner_id = room.game.check_winner()
        if winner_id:
            room.end_game()
            cancel_turn_timer(room.id)  # 取消定时器
            broadcast_game_ended(room, winner_id)
        else:
            # 触发下一个AI
            check_and_trigger_ai(room.id)
    else:
        # 操作失败，只通知操作者
        emit('action_failed', {
            'action': action,
            'message': result.get('message', '操作失败')
        })


def calculate_and_update_scores(room, winner_id: str) -> Dict[str, Any]:
    """
    计算并更新积分
    规则：
    - 地主赢：+6分，地主输：-4分
    - 农民赢：+3分，农民输：-2分
    """
    game = room.game
    lord_id = game.lord_id
    score_changes = {}
    
    with app.app_context():
        for pid, player in game.players.items():
            if player.is_ai:
                # AI 玩家不计算积分
                score_changes[pid] = {'name': player.name, 'change': 0, 'total': 0, 'is_ai': True}
                continue
            
            is_lord = (pid == lord_id)
            is_winner = (pid == winner_id)
            
            # 计算积分变动
            if is_lord:
                change = 6 if is_winner else -4
            else:
                change = 3 if is_winner else -2
            
            # 更新数据库中的积分
            db_user = User.query.filter_by(username=player.name).first()
            if db_user:
                new_total = db_user.add_game_score('doudizhu', change)
                db.session.commit()
                score_changes[pid] = {
                    'name': player.name,
                    'change': change,
                    'total': new_total,
                    'is_lord': is_lord,
                    'is_winner': is_winner,
                    'is_ai': False
                }
            else:
                # 游客或找不到用户，只记录变动
                score_changes[pid] = {
                    'name': player.name,
                    'change': change,
                    'total': 0,
                    'is_lord': is_lord,
                    'is_winner': is_winner,
                    'is_ai': False,
                    'guest': True
                }
    
    return score_changes


def broadcast_game_ended(room, winner_id: str, message: str = None):
    """广播游戏结束，包含获胜者信息和积分变动"""
    game = room.game
    winner_player = game.players.get(winner_id)
    
    # 计算并更新积分
    score_changes = calculate_and_update_scores(room, winner_id)
    
    # 构建获胜者信息
    winner_info = None
    if winner_player:
        winner_info = {
            'id': winner_id,
            'player_id': winner_id,
            'name': winner_player.name,
            'is_lord': (winner_id == game.lord_id)
        }
    
    data = {
        'winner': winner_info,
        'winner_id': winner_id,
        'room': room.to_dict(include_game_state=True),
        'scores': score_changes
    }
    if message:
        data['message'] = message
    
    socketio.emit('game_ended', data, room=room.id)
    logger.info(f"游戏结束，获胜者: {winner_player.name if winner_player else winner_id}, 积分变动: {score_changes}")


def handle_toggle_trustee(room, player_id: str):
    """处理手动托管/取消托管"""
    player = room.game.players.get(player_id)
    if not player:
        emit('error', {'code': 'PLAYER_NOT_FOUND', 'message': '玩家不存在'})
        return
    
    if player.is_ai:
        emit('error', {'code': 'AI_PLAYER', 'message': 'AI玩家不能托管'})
        return
    
    if player.is_ai_controlled:
        # 取消托管
        player.disable_ai_control()
        reset_player_timeout(player_id)
        logger.info(f"Player {player.name} disabled AI control in room {room.code}")
        
        emit('trustee_changed', {
            'player_id': player_id,
            'is_trustee': False,
            'message': '已取消托管'
        })
        
        emit('trustee_changed', {
            'player_id': player_id,
            'player_name': player.name,
            'is_trustee': False,
            'message': f'{player.name} 取消了托管'
        }, room=room.id, broadcast=True, include_self=False)
    else:
        # 启用托管
        player.enable_ai_control()
        logger.info(f"Player {player.name} enabled AI control in room {room.code}")
        
        emit('trustee_changed', {
            'player_id': player_id,
            'is_trustee': True,
            'message': '已进入托管模式'
        })
        
        emit('trustee_changed', {
            'player_id': player_id,
            'player_name': player.name,
            'is_trustee': True,
            'message': f'{player.name} 进入了托管模式'
        }, room=room.id, broadcast=True, include_self=False)
        
        # 如果当前轮到该玩家，立即触发AI
        game = room.game
        state = game.get_state()
        current_turn = state.get('current_turn') or state.get('current_turn_player_id')
        if current_turn == player_id:
            socketio.start_background_task(process_ai_turn, room.id, player_id)


@socketio.on('ping')
def handle_ping(data: dict):
    """心跳"""
    emit('pong', {
        'timestamp': data.get('timestamp'),
        'server_time': datetime.now().timestamp()
    })


# ============ AI 处理 ============

# 存储 AI 实例
ai_instances: dict = {}  # player_id -> AIAdapter

# 存储活跃玩家（用于单点登录）- 使用用户名（唯一）
active_usernames: dict = {}  # username -> player_id

def get_or_create_ai(player_id: str, ai_type: str = 'rule') -> 'AIAdapter':
    """获取或创建AI实例"""
    if player_id not in ai_instances:
        if ai_type == 'deepseek':
            from config import DEEPSEEK_API_KEY
            ai_instances[player_id] = create_doudizhu_ai('deepseek', api_key=DEEPSEEK_API_KEY)
        else:
            ai_instances[player_id] = create_doudizhu_ai('rule')
    return ai_instances[player_id]

def process_ai_turn(room_id: str, player_id: str):
    """处理AI回合（在线程中运行）"""
    def run_ai():
        room = room_manager.get_room(room_id)
        if not room or not room.game:
            return
        
        game = room.game
        player = game.players.get(player_id)
        
        if not player:
            return
        
        # 检查是否是AI玩家或处于AI托管模式
        if not player.is_ai and not player.is_ai_controlled:
            return
        
        # 获取AI类型（AI托管的人类玩家使用rule类型）
        if player.is_ai:
            ai_type = getattr(player, 'ai_type', 'rule')
        else:
            ai_type = 'rule'  # AI托管的人类玩家使用规则AI
        ai = get_or_create_ai(player_id, ai_type)
        
        # 准备游戏状态
        game_state = game.to_dict()
        available_actions = game.get_valid_actions(player_id)
        
        # 准备玩家上下文
        player_cards = game.player_cards.get(player_id, [])
        is_lord = game.lord_id == player_id
        
        # 计算队友手牌数（对于农民）
        teammate_cards = 17
        if not is_lord and game.lord_id:
            for pid in game.players:
                if pid != player_id and pid != game.lord_id:
                    teammate_cards = len(game.player_cards.get(pid, []))
                    break
        
        player_context = {
            'cards': [c.to_dict() for c in player_cards],
            'is_lord': is_lord,
            'teammate_cards': teammate_cards
        }
        
        try:
            # 运行异步决策
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            decision = loop.run_until_complete(
                ai.make_decision(game_state, available_actions, player_context)
            )
            loop.close()
            
            # 执行决策
            action = decision['action']
            action_data = decision.get('data', {})
            
            # 添加延迟，模拟思考时间
            import time
            time.sleep(2)
            
            result = game.handle_action(player_id, action, action_data)
            room.update_activity()
            
            if result.get('success'):
                logger.info(f"AI {player.name} action: {action}")
                
                # 重置超时计数
                reset_player_timeout(player_id)
                
                # 重启回合定时器
                start_turn_timer(room_id)
                
                # 使用 SocketIO 广播
                with app.app_context():
                    socketio.emit('state_update', {
                        'action': action,
                        'player_id': player_id,
                        'result': result,
                        'game_state': game.to_dict(),
                        'ai_reasoning': decision.get('reasoning', '')
                    }, room=room.id)
                
                # 检查游戏是否结束
                winner_id = game.check_winner()
                if winner_id:
                    room.end_game()
                    cancel_turn_timer(room_id)  # 取消定时器
                    with app.app_context():
                        broadcast_game_ended(room, winner_id)
                else:
                    # 继续下一个AI
                    next_player = game.get_current_player()
                    if next_player and (next_player.is_ai or next_player.is_ai_controlled):
                        threading.Timer(0.5, process_ai_turn, args=[room_id, next_player.id]).start()
        
        except Exception as e:
            logger.error(f"AI processing error: {e}")
            import traceback
            traceback.print_exc()
    
    # 启动线程
    thread = threading.Thread(target=run_ai)
    thread.daemon = True
    thread.start()


def check_and_trigger_ai(room_id: str):
    """检查并触发AI行动"""
    room = room_manager.get_room(room_id)
    if not room or not room.game:
        return
    
    game = room.game
    current_player = game.get_current_player()
    
    # 触发AI：真正的AI玩家 或 处于AI托管模式的人类玩家
    if current_player and (current_player.is_ai or current_player.is_ai_controlled):
        threading.Timer(0.5, process_ai_turn, args=[room_id, current_player.id]).start()


def ai_control_after_timeout(room_id: str, player_id: str, timeout: int = 30):
    """超时后启用AI托管"""
    import time
    time.sleep(timeout)
    
    room = room_manager.get_room(room_id)
    if not room:
        return
    
    player = room.players.get(player_id)
    if not player:
        return
    
    # 检查玩家是否已经重连（offline_since 为 None 表示已重连）
    if player.offline_since is None:
        logger.info(f"Player {player.name} has reconnected, skipping AI control")
        return
    
    # 如果玩家仍然离线且游戏进行中
    if not player.is_connected and room.status == 'playing':
        player.enable_ai_control()
        logger.info(f"Player {player.name} AI control enabled after {timeout}s timeout")
        
        # 清理活跃玩家记录（允许该名字重新进入游戏）
        # 尝试用昵称清理
        if player.name in active_usernames and active_usernames[player.name] == player_id:
            del active_usernames[player.name]
        
        # 通知房间其他玩家
        with app.app_context():
            socketio.emit('player_ai_controlled', {
                'player_id': player_id,
                'player_name': player.name,
                'message': f'{player.name} 已启用AI托管'
            }, room=room.id)
        
        # 如果当前是该玩家回合，触发AI
        if room.game and room.game.get_current_player() and room.game.get_current_player().id == player_id:
            check_and_trigger_ai(room_id)


@socketio.on('reconnect_room')
def handle_reconnect_room(data: dict):
    """断线重连"""
    socket_id = request.sid
    room_code = data.get('room_code')
    player_id = data.get('player_id')
    player_name = data.get('player_name', '玩家')
    
    # 如果没有提供 room_code，尝试从服务器端查找（登录用户）
    if not room_code and current_user.is_authenticated:
        username = current_user.username
        if username in user_room_map:
            room_id = user_room_map[username]
            room = room_manager.get_room(room_id=room_id)
            if room:
                room_code = room.code
                logger.info(f"Auto-resolved room_code {room_code} for user {username}")
    
    if not room_code:
        emit('error', {'code': 'MISSING_ROOM_CODE', 'message': '缺少房间号'})
        return
    
    room = room_manager.get_room(room_code=room_code)
    if not room:
        # 房间不存在，清理用户-房间映射
        if current_user.is_authenticated and current_user.username in user_room_map:
            del user_room_map[current_user.username]
            logger.info(f"Cleared stale room mapping for {current_user.username}")
        emit('error', {'code': 'ROOM_NOT_FOUND', 'message': '房间不存在或已关闭'})
        return
    
    # 尝试找到原玩家
    player = None
    
    # 对于已登录用户，优先通过 username 查找（支持跨浏览器重连）
    if current_user.is_authenticated:
        username = current_user.username
        for p in room.players.values():
            if p.name == username:
                player = p
                logger.info(f"Reconnected by username: {username}")
                break
    
    # 未登录用户或未找到，尝试用 player_id
    if not player and player_id and player_id in room.players:
        player = room.players[player_id]
        logger.info(f"Reconnected by player_id: {player_id}")
    
    # 最后用 player_name 匹配
    if not player:
        for p in room.players.values():
            if p.name == player_name:
                # 检查该玩家是否已有其他活跃连接
                if not p.is_connected:
                    # 玩家已断开，可以重连
                    player = p
                    logger.info(f"Reconnected by player_name (disconnected): {player_name}")
                    break
                elif player_name not in active_usernames:
                    # 玩家显示连接中，但没有活跃记录，可能是残留状态
                    player = p
                    player.disconnect()  # 强制重置状态
                    logger.info(f"Reconnected by player_name (stale state): {player_name}")
                    break
    
    if not player:
        logger.warning(f"Player not found for reconnect: player_id={player_id}, name={player_name}")
        emit('error', {'code': 'PLAYER_NOT_FOUND', 'message': '无法找到原玩家，可能房间已满或游戏已结束'})
        return
    
    # 单点登录检查：确保没有其他活跃连接使用相同身份
    identity_key = current_user.username if current_user.is_authenticated else player.name
    
    if identity_key in active_usernames:
        existing_player_id = active_usernames[identity_key]
        # 如果活跃记录不是当前要重连的玩家，说明有其他连接在使用
        if existing_player_id != player.id:
            existing_room = room_manager.get_room_by_player(existing_player_id)
            if existing_room:
                existing_player = existing_room.players.get(existing_player_id)
                if existing_player and existing_player.is_connected:
                    identity_type = "账号" if current_user.is_authenticated else "昵称"
                    emit('error', {
                        'code': 'ALREADY_ONLINE',
                        'message': f'{identity_type} "{identity_key}" 已在游戏中，请先退出或等待30秒后重试'
                    })
                    return
            # 旧连接已断开，清理记录
            del active_usernames[identity_key]
    
    # 重新连接玩家
    player.connect(socket_id)
    was_ai_controlled = player.is_ai_controlled
    player.disable_ai_control()  # 取消AI托管
    
    # 如果之前是托管状态，广播取消托管（让所有人知道玩家回来了）
    if was_ai_controlled:
        socketio.emit('trustee_changed', {
            'player_id': player.id,
            'player_name': player.name,
            'is_trustee': False,
            'message': f'{player.name} 重连并取消了托管'
        }, room=room.id, broadcast=True)
        logger.info(f"Player {player.name} reconnected and AI control disabled")
    
    # 重置超时计数
    reset_player_timeout(player.id)
    
    # 重新注册活跃玩家（使用用户名或昵称）
    identity_key = current_user.username if current_user.is_authenticated else player.name
    active_usernames[identity_key] = player.id
    
    # 更新映射
    socket_player_map[socket_id] = player.id
    
    # 加入Socket.IO房间
    join_room(room.id)
    
    logger.info(f"Player {player.name} reconnected to room {room.code}")
    
    # 检查游戏是否应该已经结束（防止残局）
    if room.game and not room.game.is_ended:
        # 检查是否有玩家已经出完所有牌
        for pid, cards in room.game.player_cards.items():
            if len(cards) == 0:
                # 有人没牌了，结束游戏
                logger.info(f"检测到玩家 {pid} 无牌，自动结束游戏")
                room.game.end_game(pid)
                room.end_game()
                cancel_turn_timer(room.id)
                broadcast_game_ended(room, pid, '游戏已结束（检测到无牌玩家）')
                break
    
    # 通知重连成功
    emit('reconnect_success', {
        'player_id': player.id,
        'player': player.to_dict(),
        'room': room.to_dict(include_game_state=True),
        'was_ai_controlled': was_ai_controlled,
        'message': '重连成功，欢迎回到游戏！'
    })
    
    # 通知房间其他玩家
    emit('player_reconnected', {
        'player_id': player.id,
        'player_name': player.name,
        'was_ai_controlled': was_ai_controlled,
        'message': f'{player.name} 已回到游戏'
    }, room=room.id, broadcast=True, include_self=False)


# ============ 回合超时管理 ============

def start_turn_timer(room_id: str):
    """启动回合超时定时器"""
    # 取消已有的定时器
    cancel_turn_timer(room_id)
    
    # 启动新定时器
    timer = threading.Timer(TURN_TIMEOUT_SECONDS, handle_turn_timeout, args=[room_id])
    timer.daemon = True
    timer.start()
    room_turn_timers[room_id] = timer
    
    logger.debug(f"Room {room_id} turn timer started ({TURN_TIMEOUT_SECONDS}s)")


def cancel_turn_timer(room_id: str):
    """取消回合超时定时器"""
    if room_id in room_turn_timers:
        room_turn_timers[room_id].cancel()
        del room_turn_timers[room_id]
        logger.debug(f"Room {room_id} turn timer cancelled")


def handle_turn_timeout(room_id: str):
    """处理回合超时"""
    room = room_manager.get_room(room_id)
    if not room or not room.game:
        return
    
    game = room.game
    current_player = game.get_current_player()
    
    if not current_player:
        return
    
    player_id = current_player.id
    player_name = current_player.name
    
    # 增加超时次数
    player_timeout_count[player_id] = player_timeout_count.get(player_id, 0) + 1
    timeout_count = player_timeout_count[player_id]
    
    logger.info(f"Player {player_name} timeout #{timeout_count} in room {room.code}")
    
    # 检查是否超过最大超时次数
    if timeout_count >= MAX_TIMEOUT_COUNT:
        # 启用AI托管
        current_player.enable_ai_control()
        logger.info(f"Player {player_name} AI control enabled after {timeout_count} timeouts")
        
        # 通知所有人
        with app.app_context():
            socketio.emit('player_ai_controlled', {
                'player_id': player_id,
                'player_name': player_name,
                'reason': 'timeout',
                'message': f'{player_name} 超时{timeout_count}次，已启用AI托管'
            }, room=room.id)
        
        # 触发AI出牌
        check_and_trigger_ai(room_id)
    else:
        # 执行自动pass（不要）
        _execute_auto_pass(room, game, player_id, player_name, timeout_count)


def _execute_auto_pass(room, game, player_id: str, player_name: str, timeout_count: int):
    """执行自动不出"""
    try:
        # 检查是否可以pass（出牌阶段且不是必须出牌时）
        if game.doudizhu_phase.value != 'playing':
            # 叫地主阶段超时，默认不叫
            result = game.handle_action(player_id, 'pass', {'want': False})
            action_name = '不叫'
        else:
            # 出牌阶段超时
            # 检查是否必须出牌（自己最后出牌时不能pass）
            if game.last_played_id == player_id:
                # 必须出牌，但超时了，启用AI托管处理
                logger.info(f"Player {player_name} must play but timeout, enabling AI control")
                player = game.players.get(player_id)
                if player:
                    player.enable_ai_control()
                    with app.app_context():
                        socketio.emit('player_ai_controlled', {
                            'player_id': player_id,
                            'player_name': player_name,
                            'reason': 'must_play_timeout',
                            'message': f'{player_name} 必须出牌但超时，已启用AI托管'
                        }, room=room.id)
                    check_and_trigger_ai(room.id)
                return
            else:
                # 可以pass
                result = game.handle_action(player_id, 'pass', {})
                action_name = '不要'
        
        if result.get('success'):
            room.update_activity()
            
            # 广播超时自动操作
            with app.app_context():
                socketio.emit('turn_timeout_auto', {
                    'player_id': player_id,
                    'player_name': player_name,
                    'action': 'pass',
                    'action_name': action_name,
                    'timeout_count': timeout_count,
                    'game_state': game.to_dict(),
                    'message': f'{player_name} 超时，自动{action_name} ({timeout_count}/{MAX_TIMEOUT_COUNT})'
                }, room=room.id)
            
            logger.info(f"Auto {action_name} executed for {player_name}")
            
            # 检查游戏是否结束
            winner_id = game.check_winner()
            if winner_id:
                room.end_game()
                with app.app_context():
                    broadcast_game_ended(room, winner_id)
                cancel_turn_timer(room.id)
            else:
                # 继续下一个回合的定时器
                start_turn_timer(room.id)
                # 如果下一个是AI，触发AI
                check_and_trigger_ai(room.id)
        else:
            logger.warning(f"Auto pass failed for {player_name}: {result.get('message')}")
            
    except Exception as e:
        logger.error(f"Error in auto pass: {e}")
        import traceback
        traceback.print_exc()


def reset_player_timeout(player_id: str):
    """重置玩家超时计数（玩家正常操作时调用）"""
    if player_id in player_timeout_count:
        del player_timeout_count[player_id]
        logger.debug(f"Player {player_id} timeout count reset")


# ============ 房间清理任务 ============

def cleanup_rooms_periodically():
    """定期清理不活跃房间"""
    import time as time_module
    while True:
        try:
            time_module.sleep(300)  # 每5分钟检查一次
            removed = room_manager.cleanup_inactive_rooms(max_inactive_minutes=30)
            if removed > 0:
                logger.info(f"🧹 清理了 {removed} 个不活跃房间")
        except Exception as e:
            logger.error(f"清理房间时出错: {e}")

def start_cleanup_thread():
    """启动清理线程"""
    cleanup_thread = threading.Thread(target=cleanup_rooms_periodically, daemon=True)
    cleanup_thread.start()
    logger.info("🧹 房间清理线程已启动")

# ============ Main ============

def main():
    """启动服务器"""
    # 初始化数据库
    with app.app_context():
        db.create_all()
        init_default_users()
        logger.info("✅ 数据库初始化完成")
    
    # 启动清理线程
    start_cleanup_thread()
    
    logger.info(f"Starting Net-Games server on {HOST}:{PORT}")
    logger.info(f"Game Hub: http://{HOST}:{PORT}/hub/")
    logger.info(f"Debug mode: {DEBUG}")
    
    socketio.run(
        app,
        host=HOST,
        port=PORT,
        debug=DEBUG,
        use_reloader=DEBUG,
        allow_unsafe_werkzeug=True
    )


if __name__ == '__main__':
    main()