"""
PERCLOS (Percentage of Eyelid Closure) 标准实现
基于 NHTSA 验证的 psychophysiological signal (1990s research)
EU ADDW 标准采用 80% 闭眼阈值
"""

import numpy as np
from typing import Tuple

class PERCLOSCalculator:
    """
    PERCLOS 计算 - 欧盟 ADDW 标准实现
    
    定义：
    PERCLOS = 闭眼时间百分比 (眼睑开度 < 80% 判定为闭眼)
    
    EU ADDW 标准：
    - 计算窗口：60 秒滑动窗口
    - 闭眼判定：眼睑开度 < 80% 持续 > 500ms
    - 二级警告：PERCLOS > 阈值 (OEM 声明, 通常 15-30%)
    
    参考文件：
    - NHTSA DOT HS 808 504 (PERCLOS 原始研究)
    - ECE R152 ADDW Technical Requirements
    """
    
    def __init__(self, 
                 closure_threshold: float = 0.8,  # 80% 闭眼
                 min_closure_duration: float = 0.5,  # 500ms 最小持续
                 window_sec: float = 60.0,  # 60秒窗口
                 fps: int = 30):
        self.closure_threshold = closure_threshold
        self.min_closure_duration = min_closure_duration
        self.window_sec = window_sec
        self.fps = fps
        self.window_frames = int(window_sec * fps)
        
    def calculate(self, eye_openness: np.ndarray) -> dict:
        """
        计算 PERCLOS 值
        
        Args:
            eye_openness: 眼睑开度序列 (0-1), shape=(N,)
                         1.0=完全睁眼, 0.0=完全闭眼
            
        Returns:
            dict: {
                'perclos': float,          # 0-100%
                'closure_events': list,    # 闭眼事件列表
                'alert_level': str,        # NONE/WARN/SERIOUS
                'max_closure_duration': float,  # 最长单次闭眼秒数
            }
        """
        n = len(eye_openness)
        
        # 闭眼帧标记
        is_closed = eye_openness < self.closure_threshold
        
        # 闭眼事件提取（持续 > min_closure_duration 的事件）
        closure_events = []
        in_closure = False
        start = 0
        
        for i, closed in enumerate(is_closed):
            if closed and not in_closure:
                in_closure = True
                start = i
            elif not closed and in_closure:
                duration = (i - start) / self.fps
                if duration >= self.min_closure_duration:
                    closure_events.append({
                        'start_frame': start,
                        'end_frame': i,
                        'duration_sec': duration,
                    })
                in_closure = False
        
        # 处理最后一个事件
        if in_closure:
            duration = (n - start) / self.fps
            if duration >= self.min_closure_duration:
                closure_events.append({
                    'start_frame': start,
                    'end_frame': n,
                    'duration_sec': duration,
                })
        
        # 计算 PERCLOS（在滑动窗口内）
        if n < self.window_frames:
            # 数据不足，计算全局 PERCLOS
            total_closure = sum(e['duration_sec'] for e in closure_events)
            perclos = (total_closure / (n / self.fps)) * 100 if n > 0 else 0
        else:
            # 60秒滑动窗口
            window_perclos = []
            for i in range(n - self.window_frames):
                window = is_closed[i:i + self.window_frames]
                window_perclos.append(np.sum(window) / self.window_frames * 100)
            perclos = np.max(window_perclos) if window_perclos else 0
        
        # 最大单次闭眼时长
        max_dur = max([e['duration_sec'] for e in closure_events], default=0)
        
        # 警告等级
        if perclos > 30:
            alert = 'SERIOUS'
        elif perclos > 15:
            alert = 'WARN'
        else:
            alert = 'NONE'
        
        return {
            'perclos': round(perclos, 2),
            'closure_events': closure_events,
            'alert_level': alert,
            'max_closure_duration': round(max_dur, 2),
        }


# 测试
if __name__ == "__main__":
    calc = PERCLOSCalculator(fps=30)
    
    # 模拟60秒数据
    t = np.arange(1800) / 30.0  # 60秒
    # 正常驾驶 + 疲劳闭眼
    normal = np.random.normal(0.9, 0.05, 1200)  # 40秒正常
    sleepy = np.concatenate([
        np.random.normal(0.85, 0.08, 180),  # 6秒微闭
        np.full(90, 0.3),  # 3秒闭眼
        np.random.normal(0.85, 0.08, 90),  # 3秒恢复
        np.full(120, 0.2),  # 4秒长闭眼
        np.random.normal(0.85, 0.08, 120),  # 4秒恢复
    ])
    
    eye_data = np.clip(np.concatenate([normal, sleepy]), 0, 1)
    result = calc.calculate(eye_data)
    
    print(f"PERCLOS: {result['perclos']:.2f}%")
    print(f"Alert Level: {result['alert_level']}")
    print(f"Closure Events: {len(result['closure_events'])}")
    print(f"Max Closure: {result['max_closure_duration']:.2f}s")
    for e in result['closure_events']:
        print(f"  - {e['duration_sec']:.2f}s @ frame {e['start_frame']}")

"""
Advanced Driver Distraction Warning (ADDW) - 视线偏离检测
基于 EU GSR2 法规标准
"""

import numpy as np
from typing import Tuple
from dataclasses import dataclass

@dataclass
class GazeData:
    """视线数据"""
    yaw: float        # 水平偏转角（度），正值=向右
    pitch: float      # 俯仰角（度），正值=向上
    timestamp: float  # 秒
    confidence: float # 0-1

class ADDW_DistractionDetector:
    """
    EU ADDW 分心检测器
    
    法规要求（ECE R152）：
    - 视线偏离道路前方 > 3.5 秒 → 触发警告
    - 警告必须包含视觉 + 听觉
    - 数据必须车载处理，不得上传
    - 系统在车速 > 20 km/h 时激活
    
    视线"道路前方"定义：
    - 水平偏转 < ±15° 
    - 俯仰角 < ±10°
    """
    
    def __init__(self, 
                 yaw_threshold: float = 15.0,
                 pitch_threshold: float = 10.0,
                 distraction_duration: float = 3.5,
                 min_speed_kmh: float = 20.0):
        self.yaw_threshold = yaw_threshold
        self.pitch_threshold = pitch_threshold
        self.distraction_duration = distraction_duration
        self.min_speed = min_speed_kmh
        
    def check_road_facing(self, gaze: GazeData) -> bool:
        """判定视线是否朝向道路"""
        return (abs(gaze.yaw) < self.yaw_threshold and 
                abs(gaze.pitch) < self.pitch_threshold and
                gaze.confidence > 0.5)
    
    def detect_distraction(self, gaze_series: list, 
                           vehicle_speed: float) -> dict:
        """
        检测分心事件
        
        Args:
            gaze_series: GazeData 列表
            vehicle_speed: 当前车速 km/h
            
        Returns:
            dict: {
                'is_distracted': bool,
                'distraction_duration': float,
                'alert_level': str,  # NONE/LEVEL1/LEVEL2
                'gaze_direction': str,  # LEFT/RIGHT/UP/DOWN/ROAD
            }
        """
        if vehicle_speed < self.min_speed:
            return {
                'is_distracted': False,
                'distraction_duration': 0,
                'alert_level': 'NONE',
                'gaze_direction': 'ROAD',
            }
        
        distraction_start = None
        max_distraction = 0
        current_direction = 'ROAD'
        
        for i, gaze in enumerate(gaze_series):
            if not self.check_road_facing(gaze):
                # 视线偏离
                if distraction_start is None:
                    distraction_start = i
                    current_direction = self._classify_direction(gaze)
                
                duration = (i - distraction_start) * 0.033  # 30fps
                max_distraction = max(max_distraction, duration)
            else:
                # 视线恢复
                distraction_start = None
                current_direction = 'ROAD'
        
        # 警告等级
        if max_distraction > 3.5:
            alert = 'LEVEL2'  # 听觉+视觉警告
        elif max_distraction > 2.0:
            alert = 'LEVEL1'  # 视觉提示
        else:
            alert = 'NONE'
        
        return {
            'is_distracted': max_distraction > 3.5,
            'distraction_duration': round(max_distraction, 2),
            'alert_level': alert,
            'gaze_direction': current_direction,
        }
    
    def _classify_direction(self, gaze: GazeData) -> str:
        """分类视线方向"""
        if abs(gaze.yaw) >= abs(gaze.pitch):
            return 'RIGHT' if gaze.yaw > 0 else 'LEFT'
        else:
            return 'UP' if gaze.pitch > 0 else 'DOWN'


# 测试
if __name__ == "__main__":
    detector = ADDW_DistractionDetector()
    
    # 场景：驾驶员看了4秒手机
    gaze_data = []
    for i in range(300):  # 10秒 @ 30fps
        if 90 <= i < 210:  # 3-7秒看手机
            gaze = GazeData(yaw=35, pitch=-15, timestamp=i*0.033, confidence=0.85)
        else:
            gaze = GazeData(yaw=np.random.randn()*5, pitch=np.random.randn()*3, 
                           timestamp=i*0.033, confidence=0.92)
        gaze_data.append(gaze)
    
    result = detector.detect_distraction(gaze_data, vehicle_speed=80)
    print(f"分心检测: {result['is_distracted']}")
    print(f"持续时间: {result['distraction_duration']:.2f}s")
    print(f"警告等级: {result['alert_level']}")
    print(f"视线方向: {result['gaze_direction']}")