package com.example.cmake_project_test

import android.util.Log
import kotlin.math.PI
import kotlin.math.sin

/**
 * 信号处理使用示例类
 * 展示如何使用JNI信号处理功能
 */
class SignalProcessorExample {
    
    private val signalProcessor = SignalProcessorJNI()
    private val sampleRate = 1000.0 // 1kHz采样率
    
    init {
        // 初始化信号处理器
        if (!signalProcessor.createProcessor()) {
            Log.e("SignalProcessorExample", "Failed to create signal processor")
        }
    }
    
    /**
     * 生成测试信号：正弦波 + 噪声
     */
    fun generateTestSignal(frequency: Double, duration: Double, noiseLevel: Double = 0.1): FloatArray {
        val numSamples = (sampleRate * duration).toInt()
        val signal = FloatArray(numSamples)
        
        for (i in 0 until numSamples) {
            val time = i / sampleRate
            val sineWave = sin(2 * PI * frequency * time).toFloat()
            val noise = (Math.random() * 2 - 1).toFloat() * noiseLevel
            signal[i] = (sineWave + noise).toFloat()
        }
        
        return signal
    }
    
    /**
     * 演示带通滤波
     */
    fun demonstrateBandpassFilter() {
        Log.d("SignalProcessorExample", "=== 带通滤波演示 ===")
        
        // 生成包含多个频率的测试信号
        val signal = generateTestSignal(50.0, 1.0, 0.2) // 50Hz + 噪声
        
        // 应用带通滤波 (40-60Hz)
        val filteredSignal = signalProcessor.bandpassFilter(signal, sampleRate, 40.0, 60.0)
        
        if (filteredSignal != null) {
            Log.d("SignalProcessorExample", "滤波成功！原始信号长度: ${signal.size}, 滤波后长度: ${filteredSignal.size}")
            
            // 计算信号质量
            val originalQuality = signalProcessor.calculateSignalQuality(signal)
            val filteredQuality = signalProcessor.calculateSignalQuality(filteredSignal)
            
            Log.d("SignalProcessorExample", "原始信号质量: $originalQuality")
            Log.d("SignalProcessorExample", "滤波后信号质量: $filteredQuality")
        } else {
            Log.e("SignalProcessorExample", "带通滤波失败")
        }
    }
    
    /**
     * 演示低通滤波
     */
    fun demonstrateLowpassFilter() {
        Log.d("SignalProcessorExample", "=== 低通滤波演示 ===")
        
        // 生成高频信号
        val signal = generateTestSignal(200.0, 1.0, 0.1)
        
        // 应用低通滤波 (100Hz截止)
        val filteredSignal = signalProcessor.lowpassFilter(signal, sampleRate, 100.0)
        
        if (filteredSignal != null) {
            Log.d("SignalProcessorExample", "低通滤波成功！")
            
            // 计算信号质量
            val originalQuality = signalProcessor.calculateSignalQuality(signal)
            val filteredQuality = signalProcessor.calculateSignalQuality(filteredSignal)
            
            Log.d("SignalProcessorExample", "原始信号质量: $originalQuality")
            Log.d("SignalProcessorExample", "滤波后信号质量: $filteredQuality")
        } else {
            Log.e("SignalProcessorExample", "低通滤波失败")
        }
    }
    
    /**
     * 演示高通滤波
     */
    fun demonstrateHighpassFilter() {
        Log.d("SignalProcessorExample", "=== 高通滤波演示 ===")
        
        // 生成包含低频和高频的信号
        val signal = generateTestSignal(10.0, 1.0, 0.1) // 10Hz低频信号
        
        // 应用高通滤波 (50Hz截止)
        val filteredSignal = signalProcessor.highpassFilter(signal, sampleRate, 50.0)
        
        if (filteredSignal != null) {
            Log.d("SignalProcessorExample", "高通滤波成功！")
            
            // 计算信号质量
            val originalQuality = signalProcessor.calculateSignalQuality(signal)
            val filteredQuality = signalProcessor.calculateSignalQuality(filteredSignal)
            
            Log.d("SignalProcessorExample", "原始信号质量: $originalQuality")
            Log.d("SignalProcessorExample", "滤波后信号质量: $filteredQuality")
        } else {
            Log.e("SignalProcessorExample", "高通滤波失败")
        }
    }
    
    /**
     * 演示陷波滤波（去除工频干扰）
     */
    fun demonstrateNotchFilter() {
        Log.d("SignalProcessorExample", "=== 陷波滤波演示 ===")
        
        // 生成包含工频干扰的信号
        val signal = generateTestSignal(50.0, 1.0, 0.3) // 50Hz工频 + 噪声
        
        // 应用陷波滤波 (50Hz陷波)
        val filteredSignal = signalProcessor.notchFilter(signal, sampleRate, 50.0, 30.0)
        
        if (filteredSignal != null) {
            Log.d("SignalProcessorExample", "陷波滤波成功！")
            
            // 计算信号质量
            val originalQuality = signalProcessor.calculateSignalQuality(signal)
            val filteredQuality = signalProcessor.calculateSignalQuality(filteredSignal)
            
            Log.d("SignalProcessorExample", "原始信号质量: $originalQuality")
            Log.d("SignalProcessorExample", "滤波后信号质量: $filteredQuality")
        } else {
            Log.e("SignalProcessorExample", "陷波滤波失败")
        }
    }
    
    /**
     * 演示ECG信号质量评估
     */
    fun demonstrateECGSQI() {
        Log.d("SignalProcessorExample", "=== ECG信号质量评估演示 ===")
        
        // 生成模拟ECG信号
        val ecgSignal = generateTestSignal(1.0, 2.0, 0.05) // 1Hz心跳 + 低噪声
        
        // 计算ECG信号质量指数
        val sqi = signalProcessor.calculateECGSQI(ecgSignal, sampleRate)
        
        Log.d("SignalProcessorExample", "ECG信号质量指数: $sqi")
        
        if (sqi > 0.7f) {
            Log.d("SignalProcessorExample", "ECG信号质量良好")
        } else if (sqi > 0.4f) {
            Log.d("SignalProcessorExample", "ECG信号质量一般")
        } else {
            Log.d("SignalProcessorExample", "ECG信号质量较差")
        }
    }
    
    /**
     * 演示信号特征提取
     */
    fun demonstrateFeatureExtraction() {
        Log.d("SignalProcessorExample", "=== 信号特征提取演示 ===")
        
        // 生成测试信号
        val signal = generateTestSignal(100.0, 0.5, 0.15)
        
        // 提取特征
        val features = signalProcessor.extractFeatures(signal, sampleRate)
        
        if (features != null) {
            Log.d("SignalProcessorExample", "特征提取成功！特征数量: ${features.size}")
            
            // 显示前几个特征值
            for (i in 0 until minOf(5, features.size)) {
                Log.d("SignalProcessorExample", "特征 $i: ${features[i]}")
            }
        } else {
            Log.e("SignalProcessorExample", "特征提取失败")
        }
    }
    
    /**
     * 演示信号归一化
     */
    fun demonstrateNormalization() {
        Log.d("SignalProcessorExample", "=== 信号归一化演示 ===")
        
        // 生成幅度较大的信号
        val signal = generateTestSignal(75.0, 0.5, 0.2)
        
        // 找到最大绝对值
        val maxAbs = signal.maxOfOrNull { kotlin.math.abs(it) } ?: 0f
        Log.d("SignalProcessorExample", "归一化前最大绝对值: $maxAbs")
        
        // 归一化
        signalProcessor.normalizeAmplitude(signal)
        
        // 检查归一化结果
        val normalizedMaxAbs = signal.maxOfOrNull { kotlin.math.abs(it) } ?: 0f
        Log.d("SignalProcessorExample", "归一化后最大绝对值: $normalizedMaxAbs")
        
        if (kotlin.math.abs(normalizedMaxAbs - 1.0f) < 0.01f) {
            Log.d("SignalProcessorExample", "归一化成功！")
        } else {
            Log.e("SignalProcessorExample", "归一化失败")
        }
    }
    
    /**
     * 演示相关性计算
     */
    fun demonstrateCorrelation() {
        Log.d("SignalProcessorExample", "=== 相关性计算演示 ===")
        
        // 生成两个相关信号
        val signal1 = generateTestSignal(50.0, 1.0, 0.1)
        val signal2 = generateTestSignal(50.0, 1.0, 0.1) // 相同频率
        
        // 计算相关性
        val correlation = signalProcessor.calculateCorrelation(signal1, signal2)
        
        Log.d("SignalProcessorExample", "信号相关性: $correlation")
        
        if (correlation > 0.8f) {
            Log.d("SignalProcessorExample", "信号高度相关")
        } else if (correlation > 0.5f) {
            Log.d("SignalProcessorExample", "信号中等相关")
        } else {
            Log.d("SignalProcessorExample", "信号相关性较低")
        }
    }
    
    /**
     * 运行所有演示
     */
    fun runAllDemonstrations() {
        Log.d("SignalProcessorExample", "开始运行所有信号处理演示...")
        
        try {
            demonstrateBandpassFilter()
            demonstrateLowpassFilter()
            demonstrateHighpassFilter()
            demonstrateNotchFilter()
            demonstrateECGSQI()
            demonstrateFeatureExtraction()
            demonstrateNormalization()
            demonstrateCorrelation()
            
            Log.d("SignalProcessorExample", "所有演示完成！")
        } catch (e: Exception) {
            Log.e("SignalProcessorExample", "演示过程中发生错误", e)
        }
    }
    
    /**
     * 清理资源
     */
    fun cleanup() {
        signalProcessor.destroyProcessor()
        Log.d("SignalProcessorExample", "信号处理器已销毁")
    }
}
