import time
import random
import numpy as np
from typing import List, Dict
from dataclasses import dataclass

@dataclass
class PVTTrial:
    """单次 PVT 试验记录"""
    trial_id: int
    stimulus_onset: float  # 刺激出现时间戳 (秒)
    response_time: float   # 被试按键时间戳
    rt: float              # 反应时 = response - stimulus (ms)
    is_lapse: bool         # 漏报 (RT > 500ms)
    is_false_start: bool   # 误报 (RT < 100ms)

class PVTAnalyzer:
    """
    NeuroUX 风格 PVT 测试分析器
    
    基于 Dinges & Powell (1985) 范式
    简化版 3 分钟测试适配移动设备
    """
    
    def __init__(self, duration_sec: int = 180):
        self.duration_sec = duration_sec
        self.trials: List[PVTTrial] = []
        self.lapse_threshold = 500   # ms
        self.false_start_threshold = 100  # ms
    
    def add_trial(self, rt: float, onset: float = 0) -> None:
        """添加一次试验"""
        trial = PVTTrial(
            trial_id=len(self.trials),
            stimulus_onset=onset,
            response_time=onset + rt / 1000,
            rt=rt,
            is_lapse=rt > self.lapse_threshold,
            is_false_start=rt < self.false_start_threshold,
        )
        self.trials.append(trial)
    
    def analyze(self) -> Dict:
        """分析 PVT 测试结果"""
        valid = [t for t in self.trials if not t.is_false_start]
        rts = [t.rt for t in valid]
        lapses = [t for t in valid if t.is_lapse]
        
        if not rts:
            return {'error': 'no valid trials'}
        
        rts_arr = np.array(rts)
        
        return {
            'total_trials': len(self.trials),
            'valid_trials': len(valid),
            'lapse_count': len(lapses),
            'lapse_rate': len(lapses) / len(valid) * 100,
            'mean_rt': float(np.mean(rts_arr)),
            'median_rt': float(np.median(rts_arr)),
            'fastest_10pct': float(np.percentile(rts_arr, 10)),
            'slowest_10pct': float(np.percentile(rts_arr, 90)),
            'std_rt': float(np.std(rts_arr)),
            'false_start_count': sum(1 for t in self.trials if t.is_false_start),
            'alert_index': self._compute_alert_index(rts_arr, len(lapses)),
        }
    
    def _compute_alert_index(self, rts: np.ndarray, lapse_count: int) -> float:
        """计算警觉指数 (0-100, 100=最警觉)"""
        median_rt = float(np.median(rts))
        lapse_rate = lapse_count / len(rts) * 100
        std_rt = float(np.std(rts))
        
        rt_score = max(0, 100 - (median_rt - 250) / 2)
        lapse_score = max(0, 100 - lapse_rate * 20)
        var_score = max(0, 100 - (std_rt - 30) / 0.5)
        
        return max(0, min(100, rt_score * 0.4 + lapse_score * 0.4 + var_score * 0.2))


# 测试
if __name__ == "__main__":
    np.random.seed(42)
    
    print("=== 模拟清醒状态 ===")
    pvt = PVTAnalyzer()
    for _ in range(45):
        rt = max(100, np.random.normal(260, 30))
        pvt.add_trial(rt)
    
    r = pvt.analyze()
    print(f"中位RT: {r['median_rt']:.1f}ms, 漏报: {r['lapse_count']}, 警觉指数: {r['alert_index']:.1f}")
    
    print("\n=== 模拟疲劳状态 ===")
    pvt2 = PVTAnalyzer()
    for _ in range(45):
        if random.random() < 0.15:
            rt = random.uniform(500, 800)
        else:
            rt = max(100, np.random.normal(350, 60))
        pvt2.add_trial(rt)
    
    r2 = pvt2.analyze()
    print(f"中位RT: {r2['median_rt']:.1f}ms, 漏报: {r2['lapse_count']}, 警觉指数: {r2['alert_index']:.1f}")

class PersonalizedBaseline:
    """
    NeuroUX 个性化疲劳基线管理
    
    基于 PVT 历史数据建立个人基线
    """
    
    def __init__(self, min_samples: int = 5):
        self.min_samples = min_samples
        self.history: List[Dict] = []
        self.baseline = None
        self.is_ready = False
    
    def add_test_result(self, pvt_result: Dict) -> None:
        """添加测试结果"""
        self.history.append({
            'timestamp': time.time(),
            'median_rt': pvt_result['median_rt'],
            'lapse_count': pvt_result['lapse_count'],
            'alert_index': pvt_result['alert_index'],
            'std_rt': pvt_result['std_rt'],
        })
        if len(self.history) >= self.min_samples and not self.is_ready:
            self._compute_baseline()
    
    def _compute_baseline(self) -> None:
        recent = self.history[-20:]
        alerts = [h['alert_index'] for h in recent]
        rts = [h['median_rt'] for h in recent]
        
        self.baseline = {
            'alert_mean': float(np.mean(alerts)),
            'alert_std': float(np.std(alerts)) + 1e-6,
            'rt_mean': float(np.mean(rts)),
            'rt_std': float(np.std(rts)) + 1e-6,
            'samples': len(recent),
        }
        self.is_ready = True
    
    def evaluate(self, pvt_result: Dict) -> Dict:
        """评估当前测试相对基线的偏离"""
        if not self.is_ready:
            return {'fit_for_duty': True, 'recommendation': '基线建立中'}
        
        z_alert = (pvt_result['alert_index'] - self.baseline['alert_mean']) / \
                   self.baseline['alert_std']
        z_rt = (pvt_result['median_rt'] - self.baseline['rt_mean']) / \
                self.baseline['rt_std']
        
        deviation = (z_alert + z_rt) / 2
        
        if deviation < -2.0:
            return {'fit_for_duty': False, 'deviation': float(deviation),
                    'recommendation': '严重偏离基线，建议休息'}
        elif deviation < -1.0:
            return {'fit_for_duty': True, 'deviation': float(deviation),
                    'recommendation': '轻度偏离，建议关注'}
        else:
            return {'fit_for_duty': True, 'deviation': float(deviation),
                    'recommendation': '状态正常'}