import numpy as np
from typing import List, Tuple

class InstrumentGazeAnalyzer:
    """
    仪表注视时长分析器
    
    评估飞行员对各仪表的注视分配效率
    """
    
    def __init__(self, fps: int = 60):
        self.fps = fps
        
        # 标准仪表定义
        self.instruments = {
            'ASI': '空速表',
            'ATTI': '姿态指示器',
            'ALT': '高度表',
            'VSI': '升降速度表',
            'HSI': '航向指示器',
            'ECAM': '发动机/告警显示',
            'PFD': '主飞行显示',
            'ND': '导航显示'
        }
    
    def analyze_gaze_distribution(
        self,
        gaze_data: List[Tuple[float, str, float]],
        total_time_sec: float
    ) -> dict:
        """
        分析仪表注视分布
        
        Args:
            gaze_data: [(timestamp, instrument_id, duration_sec), ...]
            total_time_sec: 总飞行时间（秒）
            
        Returns:
            analysis: 注视分析结果
        """
        # 统计各仪表注视时间
        instrument_times = {inst: 0.0 for inst in self.instruments}
        
        for ts, inst, dur in gaze_data:
            if inst in instrument_times:
                instrument_times[inst] += dur
        
        total_gaze = sum(instrument_times.values())
        
        # 计算注视比例
        ratios = {k: v/total_gaze for k, v in instrument_times.items() if total_gaze > 0}
        
        # 评估经验水平
        avg_fixation = np.mean([dur for _, _, dur in gaze_data])
        
        if avg_fixation > 0.5:  # >500ms
            level = 'NOVICE'
        elif avg_fixation < 0.2:  # <200ms
            level = 'EXPERT'
        else:
            level = 'INTERMEDIATE'
        
        # 关键仪表覆盖
        critical = ['ATTI', 'ASI', 'ALT', 'HSI']
        critical_coverage = sum(ratios.get(c, 0) for c in critical)
        
        return {
            'level': level,
            'avg_fixation_sec': avg_fixation,
            'instrument_ratios': ratios,
            'critical_coverage': critical_coverage,
            'total_gaze_sec': total_gaze,
            'outside_gaze_ratio': 1.0 - total_gaze / total_time_sec if total_time_sec > 0 else 0,
            'overload_flag': any(r > 0.35 for r in ratios.values())
        }

class CockpitEyeTrackingSuite:
    """
    航空座舱眼动追踪完整指标套件
    
    7大指标计算与综合评估
    """
    
    def __init__(self, fps: int = 60):
        self.fps = fps
        self.gaze_analyzer = InstrumentGazeAnalyzer(fps)
    
    def compute_all_metrics(
        self,
        gaze_x: np.ndarray,
        gaze_y: np.ndarray,
        timestamps: np.ndarray,
        instrument_labels: np.ndarray,
        pupil_diameter: np.ndarray,
        blink_events: np.ndarray
    ) -> dict:
        """
        计算全部7个指标
        
        Args:
            gaze_x, gaze_y: 注视点坐标序列
            timestamps: 时间戳序列
            instrument_labels: 各帧注视的仪表标签
            pupil_diameter: 瞳孔直径序列
            blink_events: 眨眼事件序列
            
        Returns:
            metrics: 7大指标结果
        """
        # 指标1: 仪表注视时长
        m1 = self._metric_instrument_time(gaze_x, gaze_y, instrument_labels, timestamps)
        
        # 指标2: 眼动距离
        m2 = self._metric_eye_movement_distance(gaze_x, gaze_y)
        
        # 指标3: 视觉搜索模式
        m3 = self._metric_visual_search_pattern(gaze_x, gaze_y, instrument_labels)
        
        # 指标4: 瞳孔直径变化
        m4 = self._metric_pupil_changes(pupil_diameter, timestamps)
        
        # 指标5: 眨眼模式
        m5 = self._metric_blink_patterns(blink_events, timestamps)
        
        # 指标6: 注意力分配
        m6 = self._metric_attention_distribution(instrument_labels)
        
        # 指标7: 扫视频率
        m7 = self._metric_scan_speed(gaze_x, gaze_y, timestamps)
        
        return {
            'instrument_time': m1,
            'eye_movement_distance': m2,
            'visual_search_pattern': m3,
            'pupil_changes': m4,
            'blink_patterns': m5,
            'attention_distribution': m6,
            'scan_speed': m7
        }
    
    def _metric_eye_movement_distance(self, x: np.ndarray, y: np.ndarray) -> dict:
        """指标2: 眼动距离"""
        distances = np.sqrt(np.diff(x)**2 + np.diff(y)**2)
        total_distance = np.sum(distances)
        avg_distance = np.mean(distances)
        
        # 短距离 = 高效（熟悉座舱）
        efficiency = 1.0 - min(avg_distance / 0.3, 1.0)
        
        return {
            'total_distance': total_distance,
            'avg_distance_per_saccade': avg_distance,
            'efficiency_score': efficiency,
            'interpretation': '高效' if efficiency > 0.7 else '需改进'
        }
    
    def _metric_visual_search_pattern(self, x, y, labels) -> dict:
        """指标3: 视觉搜索模式"""
        # 四种标准模式
        patterns = {
            'speed': 0,        # 速度-姿态交替
            'vertical': 0,     # 高度-姿态交替
            'lateral': 0,      # 航向-姿态交替
            'general': 0       # 通用扫描
        }
        
        transitions = {}
        for i in range(1, len(labels)):
            pair = (labels[i-1], labels[i])
            transitions[pair] = transitions.get(pair, 0) + 1
        
        # ATTI-ASI 交替 = 速度模式
        patterns['speed'] = transitions.get(('ATTI', 'ASI'), 0) + transitions.get(('ASI', 'ATTI'), 0)
        patterns['vertical'] = transitions.get(('ATTI', 'ALT'), 0) + transitions.get(('ALT', 'ATTI'), 0)
        patterns['lateral'] = transitions.get(('ATTI', 'HSI'), 0) + transitions.get(('HSI', 'ATTI'), 0)
        
        dominant = max(patterns, key=patterns.get)
        
        return {
            'patterns': patterns,
            'dominant_pattern': dominant,
            'structure_score': max(patterns.values()) / max(sum(patterns.values()), 1),
            'is_structured': max(patterns.values()) > 10
        }
    
    def _metric_pupil_changes(self, pupil: np.ndarray, ts: np.ndarray) -> dict:
        """指标4: 瞳孔直径变化"""
        # 去除光照影响（线性回归）
        from scipy.signal import detrend
        pupil_detrended = detrend(pupil)
        
        # 认知负荷指数
        load = np.std(pupil_detrended) / (np.mean(pupil) + 1e-8)
        
        return {
            'mean_diameter': np.mean(pupil),
            'std_diameter': np.std(pupil),
            'cognitive_load_index': load,
            'high_load_flag': load > 0.15,
            'max_dilation': np.max(pupil) - np.min(pupil)
        }
    
    def _metric_blink_patterns(self, blinks: np.ndarray, ts: np.ndarray) -> dict:
        """指标5: 眨眼模式"""
        total_sec = (ts[-1] - ts[0]) if len(ts) > 1 else 1
        blink_rate = np.sum(blinks) / (total_sec / 60)  # 次/分
        
        return {
            'blink_rate_per_min': blink_rate,
            'total_blinks': int(np.sum(blinks)),
            'fatigue_flag': blink_rate > 25,
            'strain_flag': blink_rate < 10
        }
    
    def _metric_attention_distribution(self, labels: np.ndarray) -> dict:
        """指标6: 注意力分配"""
        unique, counts = np.unique(labels, return_counts=True)
        dist = dict(zip(unique, counts / len(labels)))
        
        # 香农熵
        entropy = -sum(p * np.log2(p + 1e-10) for p in dist.values())
        max_entropy = np.log2(len(unique)) if len(unique) > 0 else 1
        
        return {
            'distribution': dist,
            'entropy': entropy,
            'normalized_entropy': entropy / max_entropy if max_entropy > 0 else 0,
            'tunnel_vision_flag': entropy / max_entropy < 0.5 if max_entropy > 0 else False
        }
    
    def _metric_scan_speed(self, x: np.ndarray, y: np.ndarray, ts: np.ndarray) -> dict:
        """指标7: 扫视频率"""
        velocities = np.sqrt(np.diff(x)**2 + np.diff(y)**2) / np.diff(ts + 1e-10)
        return {
            'avg_scan_speed': np.mean(velocities),
            'max_scan_speed': np.max(velocities),
            'consistency': 1.0 - np.std(velocities) / (np.mean(velocities) + 1e-8)
        }


# ============ 测试 ============

if __name__ == "__main__":
    np.random.seed(42)
    suite = CockpitEyeTrackingSuite(fps=60)
    
    # 模拟数据（60秒飞行）
    n = 3600  # 60秒 @ 60fps
    ts = np.linspace(0, 60, n)
    
    # 模拟注视点（在标准仪表位置间跳转）
    instrument_positions = {
        'ASI': (0.3, 0.4), 'ATTI': (0.5, 0.4),
        'ALT': (0.7, 0.4), 'HSI': (0.5, 0.2),
        'ECAM': (0.5, 0.7), 'PFD': (0.3, 0.5)
    }
    
    labels = np.random.choice(list(instrument_positions.keys()), n)
    gaze_x = np.array([instrument_positions[l][0] + np.random.normal(0, 0.02) for l in labels])
    gaze_y = np.array([instrument_positions[l][1] + np.random.normal(0, 0.02) for l in labels])
    pupil = 4.0 + 0.5 * np.sin(2 * np.pi * 0.1 * ts) + np.random.normal(0, 0.1, n)
    blinks = (np.random.rand(n) < 0.003).astype(float)
    
    metrics = suite.compute_all_metrics(gaze_x, gaze_y, ts, labels, pupil, blinks)
    
    print("=== 航空座舱眼动追踪 7大指标 ===\n")
    for name, result in metrics.items():
        print(f"指标: {name}")
        for k, v in result.items():
            if isinstance(v, (int, float, bool, str)):
                print(f"  {k}: {v}")
        print()