package com.example.cmake_project_test

import android.util.Log
import type.SensorData

/**
 * 信号处理使用示例
 * 展示如何在现有流式数据读取代码结构中使用信号处理功能
 */
class SignalProcessingExample(private val dataManager: DataManager) {
    
    companion object {
        private const val TAG = "SignalProcessingExample"
    }
    
    /**
     * 示例1：实时信号质量监控
     * 在流式数据处理过程中实时监控信号质量
     */
    fun demonstrateRealTimeQualityMonitoring() {
        Log.d(TAG, "=== 开始实时信号质量监控演示 ===")
        
        val packets = dataManager.getPacketBuffer()
        if (packets.isEmpty()) {
            Log.w(TAG, "没有数据包可供监控")
            return
        }
        
        // 监控前10个数据包的质量
        val packetsToMonitor = packets.take(10)
        var totalQuality = 0.0f
        var validPackets = 0
        
        for ((index, packet) in packetsToMonitor.withIndex()) {
            val quality = dataManager.calculateSignalQuality(packet)
            if (quality > 0) {
                totalQuality += quality
                validPackets++
                Log.d(TAG, "数据包 $index (${packet.dataType}): 质量 = $quality")
            }
        }
        
        if (validPackets > 0) {
            val averageQuality = totalQuality / validPackets
            Log.d(TAG, "平均信号质量: $averageQuality")
            
            // 根据质量决定是否需要调整滤波器参数
            if (averageQuality < 0.5f) {
                Log.w(TAG, "信号质量较低，建议检查传感器连接或调整滤波器参数")
            } else if (averageQuality > 0.8f) {
                Log.i(TAG, "信号质量良好")
            }
        }
    }
    
    /**
     * 示例2：按设备类型应用不同的信号处理策略
     */
    fun demonstrateDeviceSpecificProcessing() {
        Log.d(TAG, "=== 开始设备特定信号处理演示 ===")
        
        val packets = dataManager.getPacketBuffer()
        if (packets.isEmpty()) {
            Log.w(TAG, "没有数据包可供处理")
            return
        }
        
        // 按设备类型分组
        val packetsByType = packets.groupBy { it.dataType }
        
        for ((dataType, typePackets) in packetsByType) {
            Log.d(TAG, "处理 ${dataType.name} 类型数据，共 ${typePackets.size} 个数据包")
            
            when (dataType) {
                SensorData.DataType.EEG -> {
                    Log.d(TAG, "应用EEG专用滤波器：带通滤波(1-40Hz) + 幅度归一化")
                }
                SensorData.DataType.ECG_2LEAD, SensorData.DataType.ECG_12LEAD -> {
                    Log.d(TAG, "应用ECG专用滤波器：高通(0.5Hz) + 低通(40Hz) + 陷波(50Hz)")
                }
                SensorData.DataType.PPG -> {
                    Log.d(TAG, "应用PPG专用滤波器：低通(8Hz) + 运动伪影去除")
                }
                else -> {
                    Log.d(TAG, "数据类型 ${dataType.name} 暂不支持专用处理")
                }
            }
        }
    }
    
    /**
     * 示例3：批量信号处理
     * 对大量数据进行批量信号处理
     */
    fun demonstrateBatchProcessing() {
        Log.d(TAG, "=== 开始批量信号处理演示 ===")
        
        val packets = dataManager.getPacketBuffer()
        if (packets.isEmpty()) {
            Log.w(TAG, "没有数据包可供批量处理")
            return
        }
        
        Log.d(TAG, "开始批量处理 ${packets.size} 个数据包...")
        
        // 记录处理开始时间
        val startTime = System.currentTimeMillis()
        
        // 应用信号处理
        val processedPackets = dataManager.applySignalProcessing(packets)
        
        // 记录处理结束时间
        val endTime = System.currentTimeMillis()
        val processingTime = endTime - startTime
        
        Log.d(TAG, "批量处理完成！")
        Log.d(TAG, "处理时间: ${processingTime}ms")
        Log.d(TAG, "处理数据包: ${processedPackets.size} 个")
        Log.d(TAG, "平均处理速度: ${packets.size * 1000.0 / processingTime} 包/秒")
        
        // 显示处理后的信号质量统计
        if (processedPackets.isNotEmpty()) {
            val qualityScores = mutableListOf<Float>()
            for (packet in processedPackets.take(20)) { // 只检查前20个包
                val quality = dataManager.calculateSignalQuality(packet)
                if (quality > 0) {
                    qualityScores.add(quality)
                }
            }
            
            if (qualityScores.isNotEmpty()) {
                val avgQuality = qualityScores.average()
                val maxQuality = qualityScores.maxOrNull() ?: 0f
                val minQuality = qualityScores.minOrNull() ?: 0f
                
                Log.d(TAG, "处理后信号质量统计:")
                Log.d(TAG, "  平均质量: ${String.format("%.3f", avgQuality)}")
                Log.d(TAG, "  最高质量: ${String.format("%.3f", maxQuality)}")
                Log.d(TAG, "  最低质量: ${String.format("%.3f", minQuality)}")
            }
        }
    }
    
    /**
     * 示例4：自适应滤波器参数调整
     * 根据信号质量自动调整滤波器参数
     */
    fun demonstrateAdaptiveFilterAdjustment() {
        Log.d(TAG, "=== 开始自适应滤波器参数调整演示 ===")
        
        val packets = dataManager.getPacketBuffer()
        if (packets.isEmpty()) {
            Log.w(TAG, "没有数据包可供自适应处理")
            return
        }
        
        // 获取第一个数据包进行质量评估
        val firstPacket = packets.first()
        val initialQuality = dataManager.calculateSignalQuality(firstPacket)
        
        Log.d(TAG, "初始信号质量: $initialQuality")
        
        if (initialQuality < 0.3f) {
            Log.w(TAG, "信号质量过低，建议检查硬件连接")
        } else if (initialQuality < 0.6f) {
            Log.i(TAG, "信号质量一般，可以尝试调整滤波器参数")
            
            // 这里可以添加自适应参数调整逻辑
            // 例如：根据噪声水平调整截止频率
            when (firstPacket.dataType) {
                SensorData.DataType.EEG -> {
                    Log.d(TAG, "建议调整EEG滤波器：降低高通截止频率到0.5Hz，提高低通截止频率到50Hz")
                }
                SensorData.DataType.ECG_2LEAD, SensorData.DataType.ECG_12LEAD -> {
                    Log.d(TAG, "建议调整ECG滤波器：提高高通截止频率到1Hz，降低低通截止频率到30Hz")
                }
                SensorData.DataType.PPG -> {
                    Log.d(TAG, "建议调整PPG滤波器：降低低通截止频率到6Hz")
                }
                else -> {
                    Log.d(TAG, "该数据类型暂不支持自适应调整")
                }
            }
        } else {
            Log.i(TAG, "信号质量良好，当前滤波器参数合适")
        }
    }
    
    /**
     * 运行所有演示
     */
    fun runAllDemonstrations() {
        Log.d(TAG, "开始运行所有信号处理演示...")
        
        try {
            demonstrateRealTimeQualityMonitoring()
            demonstrateDeviceSpecificProcessing()
            demonstrateBatchProcessing()
            demonstrateAdaptiveFilterAdjustment()
            
            Log.d(TAG, "所有演示完成！")
        } catch (e: Exception) {
            Log.e(TAG, "演示过程中发生错误", e)
        }
    }
}
