"""
Smart Eye 多模态 AI 代理核心逻辑复现

关键设计：
1. 不是单一 AI 模型处理一切，而是多模态上下文减少 AI 计算量
2. 视线 + 外部传感器 = 理解驾驶员"指的是什么"
3. 模型不可知平台（支持不同基础模型）

对比传统 AI 代理：
- 传统：语音 → LLM → 响应（计算量大，缺乏上下文）
- Smart Eye：语音+视线+情绪+车辆 → 精简 LLM 输入 → 精准响应（计算量小，有上下文）
"""

from dataclasses import dataclass, field
from typing import Optional, List, Dict, Any
from enum import Enum
import numpy as np


class ModalityType(Enum):
    VOICE = "voice"
    GAZE = "gaze"
    EMOTION = "emotion"
    DRIVER_STATE = "driver_state"
    OCCUPANCY = "occupancy"
    VEHICLE = "vehicle"
    EXTERIOR = "exterior"
    IDENTITY = "identity"


@dataclass
class HumanContext:
    """人因上下文"""
    voice_text: str = ""
    voice_intent: str = ""
    driver_id: str = ""
    gaze_pitch: float = 0.0  # 俯仰角 (度)
    gaze_yaw: float = 0.0   # 左右角 (度)
    attention_level: float = 1.0  # 0-1
    emotion: str = "neutral"
    fatigue_level: float = 0.0  # 0-1
    distraction_level: float = 0.0  # 0-1
    cabin_occupancy: Dict[str, bool] = field(default_factory=dict)


@dataclass
class VehicleContext:
    """车辆上下文"""
    speed_kmh: float = 0.0
    adas_features: List[str] = field(default_factory=list)
    exterior_objects: List[Dict] = field(default_factory=list)
    road_type: str = "urban"
    traffic_density: float = 0.0


class MultimodalContextFusion:
    """
    多模态上下文融合引擎
    
    Smart Eye 的核心创新：
    不是让 AI 处理所有原始数据，
    而是将多模态上下文融合后精简为高密度信息，
    减少 AI 代理的计算需求
    """
    
    def __init__(self):
        self.context_history = []
        self.max_history = 10
    
    def fuse_context(self, human: HumanContext,
                     vehicle: VehicleContext) -> Dict[str, Any]:
        """
        融合人因和车辆上下文为精简信息
        
        返回给 AI 代理的高密度上下文摘要
        """
        # 1. 判断驾驶员意图
        intent = self._infer_intent(human, vehicle)
        
        # 2. 判断外部参考目标
        exterior_ref = self._infer_exterior_reference(
            human, vehicle
        )
        
        # 3. 判断情绪适配
        emotion_adapter = self._emotion_adapt(human)
        
        # 4. 安全状态评估
        safety_state = self._assess_safety(human, vehicle)
        
        # 5. 构建精简上下文
        context = {
            'intent': intent,
            'exterior_reference': exterior_ref,
            'emotion_mode': emotion_adapter,
            'safety_state': safety_state,
            'driver_attention': human.attention_level,
            'cabin_occupied': any(human.cabin_occupancy.values()),
            'vehicle_speed': vehicle.speed_kmh,
            'road_type': vehicle.road_type,
        }
        
        self.context_history.append(context)
        if len(self.context_history) > self.max_history:
            self.context_history.pop(0)
        
        return context
    
    def _infer_intent(self, human: HumanContext,
                      vehicle: VehicleContext) -> str:
        """
        从语音+视线+车辆状态推断驾驶员意图
        
        Smart Eye 演示中的关键场景：
        驾驶员看窗外 + 说"那个" → AI 理解指的是哪个建筑/地标
        """
        # 语音有明确意图
        if human.voice_intent:
            return human.voice_intent
        
        # 视线+语音组合推断
        if human.voice_text and abs(human.gaze_yaw) > 30:
            return f"exterior_reference:gaze_direction"
        
        # 情绪+状态推断
        if human.emotion == "stressed" and human.fatigue_level > 0.5:
            return "comfort_request"
        
        return "unknown"
    
    def _infer_exterior_reference(self, human: HumanContext,
                                  vehicle: VehicleContext) -> Optional[Dict]:
        """
        视线 + 外部传感器 = 理解驾驶员指的是什么
        
        这是 Smart Eye 演示的核心场景：
        驾驶员看向窗外某物体 + 说"那个" 
        → AI 通过视线方向 + 外部传感器数据 
        → 确定驾驶员指的是哪个外部目标
        """
        if abs(human.gaze_yaw) < 15 and abs(human.gaze_pitch) < 15:
            return None  # 看前方，不是外部参考
        
        # 视线方向转为方位角
        azimuth = human.gaze_yaw
        elevation = human.gaze_pitch
        
        # 在外部物体中找最匹配的
        best_match = None
        best_score = 0
        
        for obj in vehicle.exterior_objects:
            obj_az = obj.get('azimuth', 0)
            obj_el = obj.get('elevation', 0)
            
            # 计算角度匹配度
            angle_diff = np.sqrt(
                (azimuth - obj_az)**2 + (elevation - obj_el)**2
            )
            score = np.exp(-angle_diff / 30)  # 高斯衰减
            
            if score > best_score:
                best_score = score
                best_match = obj
        
        if best_match and best_score > 0.5:
            return {
                'object_type': best_match.get('type', 'unknown'),
                'confidence': best_score,
                'azimuth': best_match.get('azimuth'),
                'elevation': best_match.get('elevation'),
                'distance': best_match.get('distance')
            }
        
        return None
    
    def _emotion_adapt(self, human: HumanContext) -> str:
        """情绪适配模式"""
        if human.emotion == "angry":
            return "calm_mode"
        elif human.emotion == "stressed":
            return "comfort_mode"
        elif human.emotion == "happy":
            return "energetic_mode"
        return "neutral_mode"
    
    def _assess_safety(self, human: HumanContext,
                       vehicle: VehicleContext) -> str:
        """安全状态评估"""
        if human.fatigue_level > 0.7:
            return "fatigue_warning"
        if human.distraction_level > 0.7:
            return "distraction_warning"
        if vehicle.speed_kmh > 100 and human.attention_level < 0.5:
            return "high_speed_low_attention"
        return "normal"


# ========== 测试用例 ==========

if __name__ == "__main__":
    fusion = MultimodalContextFusion()
    
    # 场景1：驾驶员看向窗外 + 说"那是什么建筑"
    human1 = HumanContext(
        voice_text="那是什么建筑",
        voice_intent="exterior_inquiry",
        gaze_yaw=35.0,  # 看向右侧窗外
        gaze_pitch=-5.0,  # 略向下
        attention_level=0.6,
        emotion="curious",
        fatigue_level=0.1,
        cabin_occupancy={"driver": True, "passenger": False}
    )
    vehicle1 = VehicleContext(
        speed_kmh=40,
        road_type="urban",
        exterior_objects=[
            {"type": "building", "azimuth": 40, 
             "elevation": -5, "distance": 50},
            {"type": "pedestrian", "azimuth": -20, 
             "elevation": 0, "distance": 10},
            {"type": "sign", "azimuth": 38, 
             "elevation": -8, "distance": 45},
        ]
    )
    context1 = fusion.fuse_context(human1, vehicle1)
    print("=== 场景1：看向窗外询问建筑 ===")
    for k, v in context1.items():
        print(f"  {k}: {v}")
    print()
    
    # 场景2：疲劳驾驶 + 情绪压力
    human2 = HumanContext(
        voice_text="",
        voice_intent="",
        gaze_yaw=0,
        gaze_pitch=0,
        attention_level=0.4,
        emotion="stressed",
        fatigue_level=0.75,
        distraction_level=0.2,
        cabin_occupancy={"driver": True, "passenger": False}
    )
    vehicle2 = VehicleContext(
        speed_kmh=110,
        road_type="highway",
        exterior_objects=[]
    )
    context2 = fusion.fuse_context(human2, vehicle2)
    print("=== 场景2：高速疲劳+压力 ===")
    for k, v in context2.items():
        print(f"  {k}: {v}")


# ========== 上下文压缩效果分析 ==========

    print("\n=== 上下文压缩效果 ===")
    # 原始数据量
    raw_data_points = (
        1 +  # voice_text
        1 +  # voice_intent
        2 +  # gaze (pitch, yaw)
        1 +  # attention
        1 +  # emotion
        1 +  # fatigue
        1 +  # distraction
        1 +  # occupancy
        1 +  # speed
        1 +  # road_type
        len(vehicle1.exterior_objects) * 4  # exterior objects
    )
    
    # 精简后上下文
    context_fields = len(context1)
    
    print(f"  原始数据点: {raw_data_points}")
    print(f"  精简上下文字段: {context_fields}")
    print(f"  压缩比: {raw_data_points/context_fields:.1f}x")
    print(f"  AI 计算节省: ~{(1-context_fields/raw_data_points)*100:.0f}%")