#![deny(warnings)]
#![allow(dead_code)]
// [TSM.ID].[11031972] -- All Rights Reserved. Proprietary & Confidential.
use anyhow::Result;
use tracing::info;

/// THE DOPPLER MATRIX (Phase 36)
/// Pengkodean Biner menjadi Gelombang Suara Ultrasonik (18kHz - 22kHz)
pub struct DopplerModulator {
    pub base_freq: f32, // Frekuensi dasar (Misal: 18000 Hz)
    pub shift_freq: f32, // Jarak frekuensi (Misal: 400 Hz)
}

impl DopplerModulator {
    pub fn new() -> Self {
        Self {
            base_freq: 18000.0, // Ultrasonik senyap
            shift_freq: 400.0,
        }
    }

    /// Menerima teks rahasia dan mengubahnya menjadi serangkaian nada ultrasonik
    /// (Direpresentasikan sebagai urutan frekuensi yang harus dipancarkan oleh Speaker)
    pub fn encode_to_ultrasound(&self, payload: &str) -> Result<Vec<f32>> {
        let mut frequencies = Vec::new();
        info!("SONAR ENCODER: Memulai terjemahan {} karakter ke spektrum ultrasonik...", payload.len());

        for byte in payload.bytes() {
            for i in 0..8 {
                let bit = (byte >> (7 - i)) & 1;
                // Jika bit 0 -> 18000 Hz, Jika bit 1 -> 18400 Hz
                let freq = if bit == 0 { self.base_freq } else { self.base_freq + self.shift_freq };
                frequencies.push(freq);
            }
        }
        
        Ok(frequencies)
    }
}

pub struct DopplerDemodulator;

impl DopplerDemodulator {
    /// Menerima gelombang suara (Simulasi array frekuensi hasil FFT dari Mikrofon)
    /// dan menerjemahkannya kembali menjadi huruf/teks.
    pub fn decode_from_mic(base_freq: f32, shift_freq: f32, captured_freqs: &[f32]) -> Result<String> {
        info!("SONAR DECODER: Menganalisa {} gelombang ultrasonik...", captured_freqs.len());
        let mut bits = Vec::new();
        
        let threshold = base_freq + (shift_freq / 2.0); // 18200 Hz
        for &freq in captured_freqs {
            if freq < threshold {
                bits.push(0u8);
            } else {
                bits.push(1u8);
            }
        }

        let mut bytes = Vec::new();
        for chunk in bits.chunks_exact(8) {
            let mut byte = 0u8;
            for (i, &b) in chunk.iter().enumerate() {
                byte |= b << (7 - i);
            }
            bytes.push(byte);
        }

        let decoded = String::from_utf8(bytes).unwrap_or_else(|_| "[DATA KORUP]".to_string());
        Ok(decoded)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_sonar_air_gapped_communication() {
        let modem = DopplerModulator::new();
        let rahasia_militer = "XCU-PROTOCOL-OMEGA-SUPREME";
        
        // HP VVIP A mengubah pesan ke gelombang ultrasonik
        let gelombang_suara = modem.encode_to_ultrasound(rahasia_militer).unwrap();
        
        // Gelombang suara merambat di udara (Air-Gapped) dan masuk ke Mikrofon HP B
        let teks_yang_diterima = DopplerDemodulator::decode_from_mic(modem.base_freq, modem.shift_freq, &gelombang_suara).unwrap();
        
        assert_eq!(rahasia_militer, teks_yang_diterima);
        println!("DOPPLER MATRIX BERHASIL: Suara Ultrasonik menerbangkan pesan rahasia tanpa koneksi internet sedikitpun!");
    }
}
