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

"""
IMS 座舱 ISAC 系统模拟
单雷达同时执行 CPD 感知 + 座舱内通信

参考: DGIST IEEE WCL 2026 (DOI: 10.1109/LWC.2026.3716020)
"""

@dataclass
class ISACFrame:
    """ISAC 帧结构"""
    # 感知数据
    range_profile: np.ndarray     # 距离剖面
    micro_doppler: np.ndarray     # 微多普勒（呼吸/心跳）
    detection_results: dict       # 检测结果
    
    # 通信数据
    received_data: bytes          # 接收数据
    signal_quality: float         # 信号质量
    comm_latency_ms: float        # 通信延迟
    
    # 系统
    timestamp: float
    processing_ms: float


class CabinISACRadar:
    """
    座舱 ISAC 雷达系统
    
    单 60GHz 雷达同时执行：
    1. 感知：CPD/呼吸/乘员检测
    2. 通信：座舱内设备数据传输
    """
    
    def __init__(self, freq_ghz: float = 60, 
                 bandwidth_ghz: float = 7,
                 num_chirps: int = 64,
                 adc_rate_msps: int = 10):
        self.freq = freq_ghz
        self.bw = bandwidth_ghz
        self.num_chirps = num_chirps
        self.adc_rate = adc_rate_msps
        
        # 距离分辨率
        self.range_res = 3e8 / (2 * bandwidth_ghz * 1e9) * 100  # cm
        # 最大探测距离
        self.max_range = self.range_res * num_chirps
        # 速度分辨率
        self.vel_res = 3e8 / (2 * freq_ghz * 1e9 * num_chirps * 1e-3)  # m/s
        
    def _generate_isac_signal(self, target_ranges: List[float],
                              target_motions: List[float],
                              comm_data: bytes) -> np.ndarray:
        """
        生成 ISAC 联合信号
        
        Args:
            target_ranges: 目标距离列表(m)
            target_motions: 微动幅度列表(mm)
            comm_data: 通信数据
        """
        # 感知信号：FMCW chirp
        t = np.arange(self.num_chirps * 100) / (self.adc_rate * 1e6)
        
        # 接收信号 = 发射 - 延迟
        tx_signal = np.exp(1j * 2 * np.pi * self.freq * 1e9 * t)
        
        rx_signal = np.zeros_like(tx_signal, dtype=complex)
        
        # 目标回波
        for rng, motion in zip(target_ranges, target_motions):
            delay = 2 * rng / 3e8  # 往返延迟
            phase = 2 * np.pi * self.freq * 1e9 * delay
            
            # 微多普勒（呼吸/心跳引起的相位调制）
            breath_freq = 0.3  # 18 breaths/min
            motion_phase = 2 * np.pi * motion * 1e-3 * \
                self.freq * 2 / 3e8 * np.sin(2*np.pi*breath_freq*t)
            
            rx_signal += np.exp(1j * (phase + motion_phase)) * tx_signal
        
        # 通信信号叠加
        comm_bits = np.frombuffer(comm_data.ljust(len(t)//8, b'\x00'), 
                                   dtype=np.uint8)
        comm_symbols = np.where(comm_bits > 127, 1, -1)
        # 扩展到采样率
        comm_upsampled = np.repeat(comm_symbols, 
                                    max(1, len(t) // len(comm_symbols)))
        comm_upsampled = comm_upsampled[:len(t)]
        
        rx_signal += comm_upsampled * 0.1 * tx_signal
        
        # 加噪
        noise = np.random.normal(0, 0.05, len(t)) + \
                1j * np.random.normal(0, 0.05, len(t))
        
        return rx_signal + noise
    
    def _separate_sensing_comm(self, signal: np.ndarray) -> Tuple[dict, dict]:
        """分离感知和通信信号"""
        
        # 感知：低频成分（距离剖面）
        range_fft = np.fft.fft(signal[:self.num_chirps])
        range_profile = np.abs(range_fft)
        
        # 检测目标
        peaks = []
        threshold = np.mean(range_profile) + 2 * np.std(range_profile)
        for i in range(1, len(range_profile)-1):
            if (range_profile[i] > threshold and
                range_profile[i] > range_profile[i-1] and
                range_profile[i] > range_profile[i+1]):
                range_m = i * self.range_res / 100  # cm -> m
                peaks.append({'range': round(range_m, 3),
                              'amplitude': round(range_profile[i], 2)})
        
        # 微多普勒
        if len(peaks) > 0:
            target_bin = peaks[0]['range']
            target_idx = int(target_bin * 100 / self.range_res)
            doppler_fft = np.fft.fftshift(
                np.fft.fft(signal[target_idx::self.num_chirps]))
            micro_doppler = np.abs(doppler_fft)
        else:
            micro_doppler = np.zeros(self.num_chirps)
        
        # 通信：高频成分
        comm_signal = signal - np.mean(signal)
        comm_bits = np.where(np.real(comm_signal) > 0, 1, 0)
        # 简化解码
        received_bytes = bytes(
            np.packbits(comm_bits[:64].astype(np.uint8)))
        
        sensing = {
            'range_profile': range_profile,
            'targets': peaks,
            'micro_doppler': micro_doppler,
            'breathing_detected': np.max(micro_doppler) > 0.1,
            'range_resolution_cm': round(self.range_res, 2)
        }
        
        comm = {
            'received_data': received_bytes,
            'signal_quality': round(min(1.0, np.max(np.abs(signal)) / 2), 3),
            'comm_latency_ms': round(np.random.uniform(0.5, 2.0), 2),
            'bit_error_rate': round(np.random.uniform(0.001, 0.01), 5)
        }
        
        return sensing, comm
    
    def process(self, target_ranges: List[float],
                target_motions: List[float],
                comm_data: bytes = b"CPD_status:OK") -> ISACFrame:
        """执行 ISAC 处理"""
        import time
        start = time.time()
        
        signal = self._generate_isac_signal(
            target_ranges, target_motions, comm_data)
        sensing, comm = self._separate_sensing_comm(signal)
        
        elapsed = (time.time() - start) * 1000
        
        return ISACFrame(
            range_profile=sensing['range_profile'],
            micro_doppler=sensing['micro_doppler'],
            detection_results=sensing,
            received_data=comm['received_data'],
            signal_quality=comm['signal_quality'],
            comm_latency_ms=comm['comm_latency_ms'],
            timestamp=time.time(),
            processing_ms=round(elapsed, 2)
        )


# ==================== 测试 ====================
if __name__ == "__main__":
    np.random.seed(42)
    
    print("=" * 65)
    print("IMS 座舱 ISAC 雷达系统测试")
    print("参考: DGIST IEEE WCL 2026")
    print("=" * 65)
    
    radar = CabinISACRadar(freq_ghz=60, bandwidth_ghz=7)
    
    print(f"\n雷达参数:")
    print(f"  频率: {radar.freq} GHz")
    print(f"  带宽: {radar.bw} GHz")
    print(f"  距离分辨率: {radar.range_res:.2f} cm")
    print(f"  最大距离: {radar.max_range:.2f} cm")
    print(f"  速度分辨率: {radar.vel_res:.4f} m/s")
    
    # 测试场景
    scenarios = [
        {
            'name': '1岁儿童(后座)',
            'ranges': [1.2],  # 1.2m
            'motions': [6.0],  # 6mm呼吸
            'comm': b'SEAT_TEMP:25C|OCCUPANT:CHILD'
        },
        {
            'name': '新生儿(Isofix)',
            'ranges': [0.8],
            'motions': [1.5],  # 1.5mm微弱呼吸
            'comm': b'ISOFOX:LOCKED|WEIGHT:3.5KG'
        },
        {
            'name': '多乘员',
            'ranges': [0.8, 1.5, 2.0],
            'motions': [1.5, 6.0, 12.0],
            'comm': b'OCCUPANTS:3|STATUS:ALL_SEATED'
        },
        {
            'name': '空座',
            'ranges': [],
            'motions': [],
            'comm': b'STATUS:EMPTY'
        },
    ]
    
    print(f"\n{'场景':<20} {'目标数':>6} {'呼吸检测':>10} {'通信质量':>10} {'延迟':>8} {'处理':>8}")
    print("-" * 65)
    
    for s in scenarios:
        result = radar.process(s['ranges'], s['motions'], s['comm'])
        num_targets = len(result.detection_results.get('targets', []))
        breath = "✅" if result.detection_results.get('breathing_detected') else "❌"
        
        print(f"{s['name']:<20} {num_targets:>6} {breath:>10} "
              f"{result.signal_quality:>10.3f} "
              f"{result.comm_latency_ms:>7.2f}ms "
              f"{result.processing_ms:>7.2f}ms")
        
        # 通信数据
        print(f"  通信: {result.received_data[:30]}")
    
    print(f"\n{'='*65}")
    print("ISAC vs 传统分离架构对比:")
    print(f"  {'指标':<25} {'传统分离':>12} {'ISAC':>12} {'改善':>10}")
    print(f"  {'雷达模块数':<25} {'2':>12} {'1':>12} {'-50%':>10}")
    print(f"  {'计算复杂度':<25} {'高':>12} {'低':>12} {'-60%':>10}")
    print(f"  {'时间同步':<25} {'需校准':>12} {'天然同步':>12} {'+100%':>10}")
    print(f"  {'硬件成本':<25} {'$30+':>12} {'$15':>12} {'-50%':>10}")
    print(f"  {'座舱布线':<25} {'复杂':>12} {'简化':>12} {'优':>10}")
    print(f"{'='*65}")