"""
L2→L3 自动驾驶接管就绪度评估系统

基于Tobii三维模型: Availability + Capability + Intent
"""

import time
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class DriverState:
    """驾驶员状态三维模型"""
    # Availability
    eyes_on_road: bool = False
    hands_on_wheel: bool = False
    body_upright: bool = False
    # Capability
    alertness_score: float = 0.0  # 0-1
    cognitive_load: float = 0.0  # 0-1
    fatigue_level: float = 0.0   # 0-1
    # Intent
    response_to_tor: bool = False  # 对接管请求的响应
    steering_input: float = 0.0   # 转向输入
    pedal_input: float = 0.0      # 踏板输入
    
    # Context
    driving_scene: str = ""  # highway/urban/parking/merge
    adas_status: str = ""   # active/disengaged/warning
    
    def availability_score(self) -> float:
        """可用性评分"""
        score = 0
        if self.eyes_on_road: score += 0.4
        if self.hands_on_wheel: score += 0.4
        if self.body_upright: score += 0.2
        return min(score, 1.0)
    
    def capability_score(self) -> float:
        """能力评分"""
        alert = self.alertness_score
        load_penalty = self.cognitive_load * 0.5
        fatigue_penalty = self.fatigue_level * 0.7
        return max(0, alert - load_penalty - fatigue_penalty)
    
    def intent_score(self) -> float:
        """意图评分"""
        if self.response_to_tor:
            score = 0.5
            if abs(self.steering_input) > 0.1: score += 0.3
            if self.pedal_input > 0.1: score += 0.2
            return min(score, 1.0)
        return 0.0
    
    def takeover_ready(self) -> bool:
        """是否准备好接管"""
        return (
            self.availability_score() > 0.7 and
            self.capability_score() > 0.5 and
            self.intent_score() > 0.3
        )


class TakeoverManager:
    """
    接管管理器
    
    管理L3→L2的接管流程
    """
    
    # 接管时间预算（秒）
    TOR_PHASES = {
        'initial_alert': 0.5,      # 初始提醒
        'escalation': 2.0,         # 升级警告
        'final_warning': 1.5,      # 最终警告
        'safe_stop': 5.0,          # 安全停靠
    }
    TOTAL_BUDGET = sum(TOR_PHASES.values())  # 9秒
    
    def __init__(self):
        self.driver = DriverState()
        self.phase = 'normal'  # normal/alert/escalation/final/safe_stop
        self.phase_start = None
        
    def request_takeover(self):
        """发起接管请求（L3→L2）"""
        self.phase = 'initial_alert'
        self.phase_start = time.time()
        # 发起视觉+听觉+触觉提醒
        return {
            'action': 'alert',
            'visual': 'HUD takeover icon + flash',
            'audio': 'escalating chime',
            'haptic': 'steering wheel vibration',
        }
    
    def evaluate_takeover(self, driver_state: DriverState):
        """评估接管就绪度"""
        self.driver = driver_state
        elapsed = time.time() - self.phase_start if self.phase_start else 0
        
        if driver_state.takeover_ready():
            self.phase = 'handover_complete'
            return {'action': 'handover', 'status': 'driver_in_control'}
        
        # 按时间预算升级
        if elapsed > self.TOR_PHASES['initial_alert'] + self.TOR_PHASES['escalation']:
            if self.phase != 'final_warning':
                self.phase = 'final_warning'
                return {
                    'action': 'escalate',
                    'visual': 'red dashboard warning',
                    'audio': 'continuous alarm',
                    'haptic': 'strong vibration + seatbelt tug',
                }
        
        if elapsed > self.TOTAL_BUDGET:
            self.phase = 'safe_stop'
            return {
                'action': 'safe_stop',
                'vehicle': 'lane keep + decelerate to stop',
                'hazard_lights': True,
                'ecall': True,  # 紧急呼叫
            }
        
        return {'action': 'continue_alert', 'phase': self.phase}