# -*- coding: utf-8 -*-
"""
AIfeng/2025-07-15 14:41:21
数字人WebSocket服务实现
处理数字人相关的WebSocket通信和状态管理
"""

import asyncio
import json
from typing import Dict, Any, Optional, List
from aiohttp import web
from logger import logger
from .websocket_service_base import WebSocketServiceBase
from .unified_websocket_manager import WebSocketSession


class DigitalHumanWebSocketService(WebSocketServiceBase):
    """数字人WebSocket服务"""
    
    def __init__(self):
        super().__init__("digital_human_service")
        # 数字人状态管理
        self.digital_humans: Dict[str, Dict[str, Any]] = {}  # human_id -> human_info
        self.human_sessions: Dict[str, str] = {}  # session_id -> human_id
        self.session_humans: Dict[str, List[str]] = {}  # session_id -> [human_ids]
        
    async def _register_message_handlers(self):
        """注册数字人相关消息处理器"""
        self.manager.register_message_handler('register_digital_human', self._handle_register_digital_human)
        self.manager.register_message_handler('unregister_digital_human', self._handle_unregister_digital_human)
        self.manager.register_message_handler('digital_human_status', self._handle_digital_human_status)
        self.manager.register_message_handler('digital_human_action', self._handle_digital_human_action)
        self.manager.register_message_handler('digital_human_speak', self._handle_digital_human_speak)
        self.manager.register_message_handler('digital_human_emotion', self._handle_digital_human_emotion)
        self.manager.register_message_handler('get_digital_humans', self._handle_get_digital_humans)
        
    async def _on_session_disconnected(self, session: WebSocketSession):
        """会话断开时清理数字人注册"""
        await super()._on_session_disconnected(session)
        
        session_id = session.session_id
        
        # 清理该会话注册的数字人
        if session_id in self.session_humans:
            human_ids = self.session_humans.pop(session_id)
            for human_id in human_ids:
                if human_id in self.digital_humans:
                    human_info = self.digital_humans.pop(human_id)
                    logger.info(f'数字人已注销: {human_id} (会话断开)')
                    
                    # 通知其他会话数字人已离线
                    await self.broadcast_to_all('digital_human_offline', {
                        'human_id': human_id,
                        'name': human_info.get('name', ''),
                        'reason': 'session_disconnected'
                    })
                    
        # 清理会话到数字人的映射
        if session_id in self.human_sessions:
            del self.human_sessions[session_id]
            
    async def _handle_register_digital_human(self, websocket: web.WebSocketResponse, data: Dict[str, Any]):
        """处理数字人注册"""
        session = self.manager.get_session(websocket)
        if not session:
            return
            
        human_id = data.get('human_id')
        human_name = data.get('name', '')
        human_type = data.get('type', 'default')
        capabilities = data.get('capabilities', [])
        
        if not human_id:
            await session.send_message({
                "type": "error",
                "data": {"message": "缺少human_id"}
            })
            return
            
        # 检查数字人是否已存在
        if human_id in self.digital_humans:
            await session.send_message({
                "type": "register_digital_human_response",
                "data": {
                    "status": "error",
                    "message": f"数字人已存在: {human_id}"
                }
            })
            return
            
        # 注册数字人
        human_info = {
            'human_id': human_id,
            'name': human_name,
            'type': human_type,
            'capabilities': capabilities,
            'session_id': session.session_id,
            'status': 'online',
            'registered_at': asyncio.get_event_loop().time(),
            'last_activity': asyncio.get_event_loop().time()
        }
        
        self.digital_humans[human_id] = human_info
        self.human_sessions[session.session_id] = human_id
        
        # 记录会话注册的数字人
        if session.session_id not in self.session_humans:
            self.session_humans[session.session_id] = []
        self.session_humans[session.session_id].append(human_id)
        
        # 发送注册成功响应
        await session.send_message({
            "type": "register_digital_human_response",
            "data": {
                "status": "success",
                "human_id": human_id,
                "message": "数字人注册成功"
            }
        })
        
        # 通知其他会话新数字人上线
        await self.broadcast_to_all('digital_human_online', {
            'human_id': human_id,
            'name': human_name,
            'type': human_type,
            'capabilities': capabilities
        }, metadata={'exclude_session': session.session_id})
        
        logger.info(f'数字人已注册: {human_id} ({human_name})')
        
    async def _handle_unregister_digital_human(self, websocket: web.WebSocketResponse, data: Dict[str, Any]):
        """处理数字人注销"""
        session = self.manager.get_session(websocket)
        if not session:
            return
            
        human_id = data.get('human_id')
        
        if not human_id:
            await session.send_message({
                "type": "error",
                "data": {"message": "缺少human_id"}
            })
            return
            
        # 检查数字人是否存在且属于当前会话
        if human_id not in self.digital_humans:
            await session.send_message({
                "type": "unregister_digital_human_response",
                "data": {
                    "status": "error",
                    "message": f"数字人不存在: {human_id}"
                }
            })
            return
            
        human_info = self.digital_humans[human_id]
        if human_info['session_id'] != session.session_id:
            await session.send_message({
                "type": "unregister_digital_human_response",
                "data": {
                    "status": "error",
                    "message": "无权注销该数字人"
                }
            })
            return
            
        # 注销数字人
        del self.digital_humans[human_id]
        if session.session_id in self.human_sessions:
            del self.human_sessions[session.session_id]
            
        if session.session_id in self.session_humans:
            self.session_humans[session.session_id].remove(human_id)
            if not self.session_humans[session.session_id]:
                del self.session_humans[session.session_id]
                
        # 发送注销成功响应
        await session.send_message({
            "type": "unregister_digital_human_response",
            "data": {
                "status": "success",
                "human_id": human_id,
                "message": "数字人注销成功"
            }
        })
        
        # 通知其他会话数字人已离线
        await self.broadcast_to_all('digital_human_offline', {
            'human_id': human_id,
            'name': human_info.get('name', ''),
            'reason': 'manual_unregister'
        }, metadata={'exclude_session': session.session_id})
        
        logger.info(f'数字人已注销: {human_id}')
        
    async def _handle_digital_human_status(self, websocket: web.WebSocketResponse, data: Dict[str, Any]):
        """处理数字人状态更新"""
        session = self.manager.get_session(websocket)
        if not session:
            return
            
        human_id = data.get('human_id')
        status = data.get('status')
        
        if not human_id or not status:
            await session.send_message({
                "type": "error",
                "data": {"message": "缺少human_id或status"}
            })
            return
            
        if human_id not in self.digital_humans:
            await session.send_message({
                "type": "error",
                "data": {"message": f"数字人不存在: {human_id}"}
            })
            return
            
        human_info = self.digital_humans[human_id]
        if human_info['session_id'] != session.session_id:
            await session.send_message({
                "type": "error",
                "data": {"message": "无权更新该数字人状态"}
            })
            return
            
        # 更新状态
        old_status = human_info['status']
        human_info['status'] = status
        human_info['last_activity'] = asyncio.get_event_loop().time()
        
        # 广播状态变化
        await self.broadcast_to_all('digital_human_status_changed', {
            'human_id': human_id,
            'old_status': old_status,
            'new_status': status,
            'name': human_info.get('name', '')
        })
        
        logger.info(f'数字人状态更新: {human_id} {old_status} -> {status}')
        
    async def _handle_digital_human_action(self, websocket: web.WebSocketResponse, data: Dict[str, Any]):
        """处理数字人动作指令"""
        session = self.manager.get_session(websocket)
        if not session:
            return
            
        human_id = data.get('human_id')
        action = data.get('action')
        params = data.get('params', {})
        
        if not human_id or not action:
            await session.send_message({
                "type": "error",
                "data": {"message": "缺少human_id或action"}
            })
            return
            
        if human_id not in self.digital_humans:
            await session.send_message({
                "type": "error",
                "data": {"message": f"数字人不存在: {human_id}"}
            })
            return
            
        human_info = self.digital_humans[human_id]
        
        # 更新活动时间
        human_info['last_activity'] = asyncio.get_event_loop().time()
        
        # 转发动作指令到数字人会话
        target_session_id = human_info['session_id']
        await self.broadcast_to_session(target_session_id, 'digital_human_action_command', {
            'human_id': human_id,
            'action': action,
            'params': params,
            'from_session': session.session_id
        })
        
        logger.info(f'数字人动作指令: {human_id} -> {action}')
        
    async def _handle_digital_human_speak(self, websocket: web.WebSocketResponse, data: Dict[str, Any]):
        """处理数字人说话指令"""
        session = self.manager.get_session(websocket)
        if not session:
            return
            
        human_id = data.get('human_id')
        text = data.get('text')
        voice_config = data.get('voice_config', {})
        
        if not human_id or not text:
            await session.send_message({
                "type": "error",
                "data": {"message": "缺少human_id或text"}
            })
            return
            
        if human_id not in self.digital_humans:
            await session.send_message({
                "type": "error",
                "data": {"message": f"数字人不存在: {human_id}"}
            })
            return
            
        human_info = self.digital_humans[human_id]
        
        # 更新活动时间
        human_info['last_activity'] = asyncio.get_event_loop().time()
        
        # 转发说话指令到数字人会话
        target_session_id = human_info['session_id']
        await self.broadcast_to_session(target_session_id, 'digital_human_speak_command', {
            'human_id': human_id,
            'text': text,
            'voice_config': voice_config,
            'from_session': session.session_id
        })
        
        # 广播数字人说话事件
        await self.broadcast_to_all('digital_human_speaking', {
            'human_id': human_id,
            'name': human_info.get('name', ''),
            'text': text
        }, metadata={'exclude_session': target_session_id})
        
        logger.info(f'数字人说话指令: {human_id} -> "{text}"')
        
    async def _handle_digital_human_emotion(self, websocket: web.WebSocketResponse, data: Dict[str, Any]):
        """处理数字人情感状态"""
        session = self.manager.get_session(websocket)
        if not session:
            return
            
        human_id = data.get('human_id')
        emotion = data.get('emotion')
        intensity = data.get('intensity', 1.0)
        
        if not human_id or not emotion:
            await session.send_message({
                "type": "error",
                "data": {"message": "缺少human_id或emotion"}
            })
            return
            
        if human_id not in self.digital_humans:
            await session.send_message({
                "type": "error",
                "data": {"message": f"数字人不存在: {human_id}"}
            })
            return
            
        human_info = self.digital_humans[human_id]
        
        # 更新情感状态
        human_info['emotion'] = emotion
        human_info['emotion_intensity'] = intensity
        human_info['last_activity'] = asyncio.get_event_loop().time()
        
        # 广播情感变化
        await self.broadcast_to_all('digital_human_emotion_changed', {
            'human_id': human_id,
            'name': human_info.get('name', ''),
            'emotion': emotion,
            'intensity': intensity
        })
        
        logger.info(f'数字人情感更新: {human_id} -> {emotion} ({intensity})')
        
    async def _handle_get_digital_humans(self, websocket: web.WebSocketResponse, data: Dict[str, Any]):
        """处理获取数字人列表请求"""
        session = self.manager.get_session(websocket)
        if not session:
            return
            
        # 返回所有在线数字人信息
        humans_list = []
        for human_id, human_info in self.digital_humans.items():
            humans_list.append({
                'human_id': human_id,
                'name': human_info.get('name', ''),
                'type': human_info.get('type', 'default'),
                'status': human_info.get('status', 'unknown'),
                'capabilities': human_info.get('capabilities', []),
                'emotion': human_info.get('emotion', 'neutral'),
                'emotion_intensity': human_info.get('emotion_intensity', 1.0)
            })
            
        await session.send_message({
            "type": "digital_humans_list",
            "data": {
                "humans": humans_list,
                "total": len(humans_list)
            }
        })
        
    def get_digital_human_stats(self) -> Dict[str, Any]:
        """获取数字人统计信息"""
        online_count = len([h for h in self.digital_humans.values() if h.get('status') == 'online'])
        
        return {
            "total_digital_humans": len(self.digital_humans),
            "online_digital_humans": online_count,
            "active_sessions": len(self.session_humans),
            "human_types": list(set(h.get('type', 'default') for h in self.digital_humans.values()))
        }
        
    async def send_to_digital_human(self, human_id: str, message_type: str, content: Any):
        """向指定数字人发送消息"""
        if human_id not in self.digital_humans:
            logger.warning(f'数字人不存在: {human_id}')
            return False
            
        human_info = self.digital_humans[human_id]
        target_session_id = human_info['session_id']
        
        return await self.broadcast_to_session(target_session_id, message_type, content)
        
    async def broadcast_to_digital_humans(self, message_type: str, content: Any, 
                                        human_filter: Optional[callable] = None):
        """向数字人广播消息"""
        sent_count = 0
        
        for human_id, human_info in self.digital_humans.items():
            if human_filter and not human_filter(human_info):
                continue
                
            target_session_id = human_info['session_id']
            success = await self.broadcast_to_session(target_session_id, message_type, content)
            if success:
                sent_count += 1
                
        return sent_count


# 创建数字人服务实例
digital_human_service = DigitalHumanWebSocketService()


def get_digital_human_service() -> DigitalHumanWebSocketService:
    """获取数字人服务实例"""
    return digital_human_service