user_data_manager.py

"""
用户数据管理器
负责管理多用户环境下的角色数据和游戏存档
"""

import json
import os
import uuid
from datetime import datetime
from typing import Dict, List, Optional, Any
from dataclasses import dataclass, asdict
import threading

# 用户数据存储路径
USER_DATA_DIR = "user_data"
SAVES_DIR = "saves"

# 确保目录存在
os.makedirs(USER_DATA_DIR, exist_ok=True)
os.makedirs(SAVES_DIR, exist_ok=True)


@dataclass
class UserProfile:
    """用户档案"""
    user_id: str
    username: str
    created_at: str
    last_login: str
    total_playtime: int = 0  # 总游戏时间（分钟）
    character_count: int = 0  # 角色数量


@dataclass
class GameSave:
    """游戏存档"""
    save_id: str
    user_id: str
    character_id: str
    session_data: Dict[str, Any]
    save_name: str
    created_at: str
    playtime_minutes: int
    chapter_info: Optional[str] = None
    screenshot: Optional[str] = None


class UserDataManager:
    """用户数据管理器"""

    def __init__(self):
        self.lock = threading.RLock()  # 线程安全锁
        self._users: Dict[str, UserProfile] = {}
        self._user_characters: Dict[str, List[Dict]] = {}  # user_id -> [characters]
        self._user_saves: Dict[str, List[GameSave]] = {}  # user_id -> [saves]
        self._load_data()

    def _load_data(self):
        """加载用户数据"""
        try:
            # 加载用户档案
            users_file = os.path.join(USER_DATA_DIR, "users.json")
            if os.path.exists(users_file):
                with open(users_file, 'r', encoding='utf-8') as f:
                    users_data = json.load(f)
                    for user_id, data in users_data.items():
                        self._users[user_id] = UserProfile(**data)

            # 加载角色数据
            for user_id in self._users.keys():
                chars_file = os.path.join(USER_DATA_DIR, f"characters_{user_id}.json")
                if os.path.exists(chars_file):
                    with open(chars_file, 'r', encoding='utf-8') as f:
                        self._user_characters[user_id] = json.load(f)
                else:
                    self._user_characters[user_id] = []

            # 加载存档数据
            for user_id in self._users.keys():
                saves_file = os.path.join(SAVES_DIR, f"saves_{user_id}.json")
                if os.path.exists(saves_file):
                    with open(saves_file, 'r', encoding='utf-8') as f:
                        saves_data = json.load(f)
                        self._user_saves[user_id] = [GameSave(**save) for save in saves_data]
                else:
                    self._user_saves[user_id] = []

        except Exception as e:
            print(f"加载用户数据失败: {e}")
            # 初始化空数据结构
            self._users = {}
            self._user_characters = {}
            self._user_saves = {}

    def _save_data(self):
        """保存用户数据"""
        try:
            with self.lock:
                # 保存用户档案
                users_file = os.path.join(USER_DATA_DIR, "users.json")
                users_data = {uid: asdict(profile) for uid, profile in self._users.items()}
                with open(users_file, 'w', encoding='utf-8') as f:
                    json.dump(users_data, f, ensure_ascii=False, indent=2)

                # 保存角色数据
                for user_id, characters in self._user_characters.items():
                    chars_file = os.path.join(USER_DATA_DIR, f"characters_{user_id}.json")
                    with open(chars_file, 'w', encoding='utf-8') as f:
                        json.dump(characters, f, ensure_ascii=False, indent=2)

                # 保存存档数据
                for user_id, saves in self._user_saves.items():
                    saves_file = os.path.join(SAVES_DIR, f"saves_{user_id}.json")
                    saves_data = [asdict(save) for save in saves]
                    with open(saves_file, 'w', encoding='utf-8') as f:
                        json.dump(saves_data, f, ensure_ascii=False, indent=2)

        except Exception as e:
            print(f"保存用户数据失败: {e}")

    def create_user(self, username: str) -> UserProfile:
        """创建新用户"""
        with self.lock:
            user_id = str(uuid.uuid4())
            now = datetime.now().isoformat()

            profile = UserProfile(
                user_id=user_id,
                username=username,
                created_at=now,
                last_login=now
            )

            self._users[user_id] = profile
            self._user_characters[user_id] = []
            self._user_saves[user_id] = []

            self._save_data()
            return profile

    def get_user(self, user_id: str) -> Optional[UserProfile]:
        """获取用户档案"""
        return self._users.get(user_id)

    def update_last_login(self, user_id: str):
        """更新最后登录时间"""
        with self.lock:
            if user_id in self._users:
                self._users[user_id].last_login = datetime.now().isoformat()
                self._save_data()

    def save_character(self, user_id: str, character_data: Dict) -> bool:
        """保存角色数据"""
        with self.lock:
            if user_id not in self._users:
                return False

            # 检查是否已存在相同角色
            char_id = character_data.get('id')
            characters = self._user_characters[user_id]

            if char_id:
                # 更新现有角色
                for i, char in enumerate(characters):
                    if char.get('id') == char_id:
                        characters[i] = character_data
                        break
                else:
                    # 添加新角色
                    characters.append(character_data)
            else:
                # 生成新ID并添加
                character_data['id'] = str(uuid.uuid4())
                characters.append(character_data)

            # 更新角色计数
            self._users[user_id].character_count = len(characters)

            self._save_data()
            return True

    def get_user_characters(self, user_id: str) -> List[Dict]:
        """获取用户的角色列表"""
        return self._user_characters.get(user_id, [])

    def create_save(self, user_id: str, character_id: str, session_data: Dict,
                   save_name: str, playtime_minutes: int = 0,
                   chapter_info: str = None) -> Optional[str]:
        """创建游戏存档"""
        with self.lock:
            if user_id not in self._users:
                return None

            save_id = str(uuid.uuid4())
            save = GameSave(
                save_id=save_id,
                user_id=user_id,
                character_id=character_id,
                session_data=session_data,
                save_name=save_name,
                created_at=datetime.now().isoformat(),
                playtime_minutes=playtime_minutes,
                chapter_info=chapter_info
            )

            if user_id not in self._user_saves:
                self._user_saves[user_id] = []

            self._user_saves[user_id].append(save)

            # 限制存档数量（最多20个）
            if len(self._user_saves[user_id]) > 20:
                self._user_saves[user_id] = sorted(
                    self._user_saves[user_id],
                    key=lambda x: x.created_at,
                    reverse=True
                )[:20]

            self._save_data()
            return save_id

    def get_user_saves(self, user_id: str) -> List[GameSave]:
        """获取用户的存档列表"""
        return sorted(
            self._user_saves.get(user_id, []),
            key=lambda x: x.created_at,
            reverse=True
        )

    def load_save(self, save_id: str) -> Optional[GameSave]:
        """加载存档数据"""
        with self.lock:
            for user_saves in self._user_saves.values():
                for save in user_saves:
                    if save.save_id == save_id:
                        return save
            return None

    def delete_save(self, user_id: str, save_id: str) -> bool:
        """删除存档"""
        with self.lock:
            if user_id not in self._user_saves:
                return False

            saves = self._user_saves[user_id]
            for i, save in enumerate(saves):
                if save.save_id == save_id:
                    del saves[i]
                    self._save_data()
                    return True
            return False

    def get_user_stats(self, user_id: str) -> Dict:
        """获取用户统计信息"""
        profile = self._users.get(user_id)
        if not profile:
            return {}

        saves = self._user_saves.get(user_id, [])
        total_saves = len(saves)

        return {
            "username": profile.username,
            "created_at": profile.created_at,
            "last_login": profile.last_login,
            "total_playtime": profile.total_playtime,
            "character_count": profile.character_count,
            "save_count": total_saves,
            "characters": self.get_user_characters(user_id),
            "recent_saves": saves[:5]  # 最近5个存档
        }


# 全局用户数据管理器实例
user_data_manager = UserDataManager()