Tolan/backend/services/user_service.py

"""
用户服务模块（SQLAlchemy ORM 版本）
"""
import uuid
import logging
from typing import Dict, Optional
from datetime import datetime
from sqlalchemy import select, update, func
from sqlalchemy.ext.asyncio import AsyncSession
from database import db_manager
from models_db import User

logger = logging.getLogger(__name__)


class UserService:
    """用户管理服务"""
    
    async def create_guest_user(self, username: str = "", bot_name: Optional[str] = None) -> Dict:
        """
        创建游客用户
        
        Args:
            username: 用户名（默认为空字符串）
            bot_name: 用户给机器人取的名字（可选）
        
        Returns:
            用户信息字典（包含user_id）
        """
        try:
            # 生成唯一用户ID
            user_id = str(uuid.uuid4())
            
            # 使用 ORM 创建用户
            async with db_manager.get_session() as session:
                user = User(
                    user_id=user_id,
                    username=username,
                    user_type="guest",
                    bot_name=bot_name,
                )
                session.add(user)
                await session.commit()
                await session.refresh(user)
            
            logger.info(f"✅ 创建游客用户成功: user_id={user_id}, username={username}, bot_name={bot_name}")
            
            return {
                "user_id": user_id,
                "username": username,
                "user_type": "guest",
                "bot_name": bot_name,
                "created_at": datetime.now().isoformat()
            }
            
        except Exception as e:
            logger.error(f"❌ 创建用户失败: {e}")
            raise
    
    async def get_user(self, user_id: str) -> Optional[Dict]:
        """
        获取用户信息
        
        Args:
            user_id: 用户ID
        
        Returns:
            用户信息字典，如果不存在返回None
        """
        try:
            async with db_manager.get_session() as session:
                result = await session.execute(
                    select(User).where(User.user_id == user_id)
                )
                user = result.scalar_one_or_none()
            
            if user:
                return user.to_dict()
            return None
            
        except Exception as e:
            logger.error(f"❌ 获取用户信息失败: user_id={user_id}, error={e}")
            return None
    
    async def update_user_last_active(self, user_id: str):
        """
        更新用户最后活跃时间
        
        Args:
            user_id: 用户ID
        """
        try:
            async with db_manager.get_session() as session:
                await session.execute(
                    update(User)
                    .where(User.user_id == user_id)
                    .values(last_active_at=func.now())
                )
                await session.commit()
        except Exception as e:
            logger.warning(f"⚠️ 更新用户活跃时间失败: user_id={user_id}, error={e}")
    
    async def update_username(self, user_id: str, username: str) -> bool:
        """
        更新用户名
        
        Args:
            user_id: 用户ID
            username: 用户名
        
        Returns:
            是否更新成功
        """
        try:
            async with db_manager.get_session() as session:
                result = await session.execute(
                    update(User)
                    .where(User.user_id == user_id)
                    .values(username=username)
                )
                await session.commit()
                
                if result.rowcount > 0:
                    logger.info(f"✅ 更新用户名成功: user_id={user_id}, username={username}")
                    return True
                return False
        except Exception as e:
            logger.error(f"❌ 更新用户名失败: user_id={user_id}, error={e}")
            return False
    
    async def update_bot_name(self, user_id: str, bot_name: str) -> bool:
        """
        更新用户给机器人取的名字
        
        Args:
            user_id: 用户ID
            bot_name: 机器人名字
        
        Returns:
            是否更新成功
        """
        try:
            async with db_manager.get_session() as session:
                result = await session.execute(
                    update(User)
                    .where(User.user_id == user_id)
                    .values(bot_name=bot_name)
                )
                await session.commit()
                
                if result.rowcount > 0:
                    logger.info(f"✅ 更新机器人名字成功: user_id={user_id}, bot_name={bot_name}")
                    return True
                return False
        except Exception as e:
            logger.error(f"❌ 更新机器人名字失败: user_id={user_id}, error={e}")
            return False
    
    async def update_speech_duration(self, user_id: str, duration_ms: int) -> bool:
        """
        更新用户累积说话时长
        
        Args:
            user_id: 用户ID
            duration_ms: 本次说话时长（毫秒）
        
        Returns:
            是否更新成功
        """
        try:
            if duration_ms <= 0:
                return True  # 时长无效，跳过更新
            
            async with db_manager.get_session() as session:
                # 使用 SQL 表达式更新（原子操作）
                await session.execute(
                    update(User)
                    .where(User.user_id == user_id)
                    .values(total_speech_duration_ms=User.total_speech_duration_ms + duration_ms)
                )
                await session.commit()
            
            logger.info(f"✅ 更新用户说话时长成功: user_id={user_id}, duration_ms={duration_ms}")
            return True
        except Exception as e:
            logger.error(f"❌ 更新用户说话时长失败: user_id={user_id}, error={e}")
            return False


# 全局用户服务实例
user_service = UserService()