import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report
from typing import Dict, List

class CognitiveDeclineDetector:
    """
    车载传感器认知衰退检测器
    
    论文1: Multimedia Tools Appl., 2024 - 传感器数据分析
    论文2: arXiv:2507.05463 - 大视觉模型+场景识别
    
    核心指标: 驾驶行为数字指纹
    """
    
    # 认知衰退的驾驶行为指标
    COGNITIVE_INDICATORS = {
        # 驾驶操作类
        'speed_variability': '速度变异性（认知负荷下不稳定）',
        'lane_departures': '车道偏离频率（注意力下降）',
        'braking_patterns': '制动模式异常（判断力下降）',
        'steering_corrections': '方向盘纠偏频率（运动控制衰退）',
        'intersection_stops': '交叉口停车行为（过度谨慎/犹豫）',
        
        # 导航类
        'route_errors': '路线错误次数（空间记忆衰退）',
        'navigation_hesitation': '导航犹豫时间（决策能力下降）',
        'wrong_turns': '错误转弯频率（方向感丧失）',
        
        # 视觉行为类
        'gaze_distribution': '注视分布熵（视觉搜索策略退化）',
        'mirror_check_freq': '后视镜检查频率（情境意识下降）',
        'fixation_duration': '注视时长变化（处理速度变慢）',
        'saccade_patterns': '眼跳模式异常（执行功能衰退）',
        
        # 场景交互类
        'hazard_response_time': '危险响应时间（反应速度）',
        'traffic_sign_recognition': '交通标志识别延迟',
        'following_distance': '跟车距离变化（判断力）',
    }
    
    def __init__(self):
        self.model = RandomForestClassifier(
            n_estimators=200,
            max_depth=15,
            min_samples_leaf=5,
            random_state=42
        )
        self.feature_columns = list(self.COGNITIVE_INDICATORS.keys())
        
    def extract_driving_features(self, driving_session: pd.DataFrame) -> Dict[str, float]:
        """
        从驾驶会话数据中提取认知指标
        
        Args:
            driving_session: 包含以下列的DataFrame:
                - timestamp, speed, lat, lon, heading
                - lane_position, steering_angle, brake_pressure
                - gaze_x, gaze_y, gaze_z
                - scenario_type (intersection/highway/residential)
                
        Returns:
            features: 认知指标字典
        """
        features = {}
        
        # 1. 速度变异性
        features['speed_variability'] = np.std(driving_session['speed'])
        
        # 2. 车道偏离频率（次/公里）
        lane_departs = np.sum(np.abs(driving_session['lane_position']) > 0.3)
        distance_km = self._calculate_distance(driving_session) / 1000
        features['lane_departures'] = lane_departs / max(distance_km, 0.1)
        
        # 3. 制动模式
        brake_events = driving_session[driving_session['brake_pressure'] > 0.1]
        features['braking_patterns'] = np.std(brake_events['brake_pressure']) if len(brake_events) > 0 else 0
        
        # 4. 方向盘纠偏频率
        steering_changes = np.sum(np.abs(np.diff(driving_session['steering_angle'])) > 5)
        features['steering_corrections'] = steering_changes / max(distance_km, 0.1)
        
        # 5. 交叉口停车行为
        intersection_data = driving_session[driving_session['scenario_type'] == 'intersection']
        if len(intersection_data) > 0:
            stops = intersection_data[intersection_data['speed'] < 1.0]
            features['intersection_stops'] = len(stops)
        else:
            features['intersection_stops'] = 0
        
        # 6. 注视分布熵
        gaze = driving_session[['gaze_x', 'gaze_y']].dropna()
        if len(gaze) > 10:
            hist, _ = np.histogram2d(gaze['gaze_x'], gaze['gaze_y'], bins=10)
            hist = hist / hist.sum()
            features['gaze_distribution'] = -np.sum(hist * np.log(hist + 1e-10))
        else:
            features['gaze_distribution'] = 0
        
        # 7. 后视镜检查频率
        mirror_checks = np.sum(
            (driving_session['gaze_x'] > 0.7) &  # 右侧
            (driving_session['gaze_y'] < -0.2)    # 下方
        )
        features['mirror_check_freq'] = mirror_checks / max(distance_km, 0.1)
        
        # 8. 注视时长变化
        fixation_durations = self._calculate_fixations(gaze)
        features['fixation_duration'] = np.mean(fixation_durations) if fixation_durations else 0
        
        return features
    
    def classify_cognitive_status(self, features: Dict[str, float]) -> dict:
        """
        分类认知状态
        
        Returns:
            {
                'status': 'normal' | 'MCI_suspected' | 'dementia_risk',
                'confidence': float,
                'key_indicators': [...],
                'recommendation': str
            }
        """
        feature_vector = np.array([features.get(f, 0) for f in self.feature_columns])
        prediction = self.model.predict(feature_vector.reshape(1, -1))[0]
        proba = self.model.predict_proba(feature_vector.reshape(1, -1))[0]
        
        # 识别关键异常指标
        key_indicators = []
        for name, value in features.items():
            threshold = self._get_abnormal_threshold(name)
            if value > threshold:
                key_indicators.append(f"{name}={value:.2f} (阈值={threshold})")
        
        status_map = {0: 'normal', 1: 'MCI_suspected', 2: 'dementia_risk'}
        status = status_map.get(prediction, 'unknown')
        
        recommendations = {
            'normal': '继续定期检查',
            'MCI_suspected': '建议进行MoCA评估',
            'dementia_risk': '建议立即神经科就诊'
        }
        
        return {
            'status': status,
            'confidence': float(np.max(proba)),
            'key_indicators': key_indicators,
            'recommendation': recommendations.get(status, '未知')
        }
    
    def _calculate_distance(self, df: pd.DataFrame) -> float:
        """计算行驶距离（米）"""
        lat = np.radians(df['lat'].values)
        lon = np.radians(df['lon'].values)
        dlat = np.diff(lat)
        dlon = np.diff(lon)
        a = np.sin(dlat/2)**2 + np.cos(lat[:-1]) * np.cos(lat[1:]) * np.sin(dlon/2)**2
        return np.sum(6371000 * 2 * np.arctan2(np.sqrt(a), np.sqrt(1-a)))
    
    def _calculate_fixations(self, gaze: pd.DataFrame) -> List[float]:
        """计算注视持续时间"""
        if len(gaze) < 2:
            return []
        velocities = np.sqrt(np.diff(gaze['gaze_x'])**2 + np.diff(gaze['gaze_y'])**2)
        fixation_mask = velocities < 0.05
        durations = []
        current = 0
        for m in fixation_mask:
            if m:
                current += 1
            else:
                if current > 0:
                    durations.append(current * 0.033)  # ~30fps
                current = 0
        return durations
    
    def _get_abnormal_threshold(self, indicator: str) -> float:
        """获取指标异常阈值"""
        thresholds = {
            'speed_variability': 5.0,
            'lane_departures': 2.0,
            'braking_patterns': 0.3,
            'steering_corrections': 10.0,
            'intersection_stops': 5,
            'gaze_distribution': 3.0,
            'mirror_check_freq': 3.0,
        }
        return thresholds.get(indicator, float('inf'))


# 模拟测试
if __name__ == "__main__":
    detector = CognitiveDeclineDetector()
    
    # 模拟正常老年驾驶员数据
    np.random.seed(42)
    n_points = 1800  # 60秒 @ 30fps
    
    normal_data = pd.DataFrame({
        'timestamp': np.arange(n_points) * 0.033,
        'speed': 50 + np.random.normal(0, 2, n_points),  # 速度稳定
        'lat': 26.3643 + np.cumsum(np.random.normal(0, 0.00001, n_points)),
        'lon': -80.1025 + np.cumsum(np.random.normal(0, 0.00001, n_points)),
        'heading': np.cumsum(np.random.normal(0, 0.5, n_points)),
        'lane_position': np.random.normal(0, 0.1, n_points),
        'steering_angle': np.random.normal(0, 2, n_points),
        'brake_pressure': np.random.choice([0, 0, 0, 0.1], n_points),
        'gaze_x': np.random.normal(0, 0.3, n_points),
        'gaze_y': np.random.normal(0, 0.2, n_points),
        'gaze_z': np.random.normal(1, 0.1, n_points),
        'scenario_type': np.random.choice(['highway', 'residential', 'intersection'], n_points),
    })
    
    features = detector.extract_driving_features(normal_data)
    print("=== 正常老年驾驶员特征 ===")
    for k, v in features.items():
        print(f"  {k}: {v:.3f}")
    
    # 模拟MCI驾驶员数据（更多变异性）
    mci_data = normal_data.copy()
    mci_data['speed'] = 50 + np.random.normal(0, 5, n_points)  # 速度不稳定
    mci_data['lane_position'] = np.random.normal(0, 0.25, n_points)  # 车道偏离多
    mci_data['steering_angle'] = np.random.normal(0, 4, n_points)  # 纠偏多
    
    mci_features = detector.extract_driving_features(mci_data)
    print("\n=== MCI驾驶员特征 ===")
    for k, v in mci_features.items():
        print(f"  {k}: {v:.3f}")
    
    print("\n=== 对比分析 ===")
    print("MCI vs 正常差异:")
    for k in features:
        diff = mci_features[k] - features[k]
        if abs(diff) > 0.01:
            print(f"  {k}: +{diff:.3f} ({'↑' if diff > 0 else '↓'}异常)")

class ScenarioBasedCognitiveAssessment:
    """
    基于场景的认知评估
    
    论文: arXiv:2507.05463
    方法: 大视觉模型识别驾驶场景 → 场景内行为评估 → 认知状态推断
    """
    
    SCENARIOS = {
        'intersection': {
            'normal': '减速观察后通过',
            'MCI': '过度停车或犹豫',
            'AD': '不必要停车/错误转弯',
            'key_metrics': ['stop_count', 'hesitation_time', 'turn_accuracy']
        },
        'highway': {
            'normal': '稳定车道保持',
            'MCI': '车道摇摆不定',
            'AD': '频繁偏离/无法保持',
            'key_metrics': ['lane_deviation', 'steering_jitter', 'speed_stability']
        },
        'parking': {
            'normal': '一次调整完成',
            'MCI': '多次调整',
            'AD': '困难/放弃/碰撞',
            'key_metrics': ['attempts', 'time_taken', 'corrections']
        }
    }
    
    def assess_scenario(self, scenario: str, behavior_data: dict) -> dict:
        """评估特定场景下的认知表现"""
        if scenario not in self.SCENARIOS:
            return {'error': f'unknown scenario: {scenario}'}
        
        config = self.SCENARIOS[scenario]
        risk_score = 0
        
        for metric in config['key_metrics']:
            value = behavior_data.get(metric, 0)
            # 简化：值越高越异常
            risk_score += min(value / 10, 1)
        
        risk_score = risk_score / len(config['key_metrics'])
        
        if risk_score < 0.3:
            status = 'normal'
        elif risk_score < 0.6:
            status = 'MCI_suspected'
        else:
            status = 'dementia_risk'
        
        return {
            'scenario': scenario,
            'risk_score': risk_score,
            'status': status,
            'expected_normal': config['normal'],
            'observed_deviation': risk_score
        }