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

/// THE LEVIATHAN MATRIX (Phase 48)
/// Chaotic Oscillator VHF/UHF Obfuscation
/// Merubah transmisi HT/Radio menjadi noise kosmik yang tidak terdeteksi Radar/SDR.
pub struct ChaosModem;

impl ChaosModem {
    /// Menghasilkan 1 iterasi kurva Lorenz Attractor (Persamaan Chaos)
    /// X, Y, Z adalah koordinat keadaan sistem di ruang 3D.
    /// Ini menghasilkan "Noise Murni" yang 100% deterministik jika kunci (x,y,z awal) diketahui.
    fn lorenz_step(x: &mut f64, y: &mut f64, z: &mut f64) {
        // Parameter standar Lorenz
        let sigma = 10.0;
        let rho = 28.0;
        let beta = 8.0 / 3.0;
        let dt = 0.01; // Delta Time (Step waktu mikroskopis)

        let dx = sigma * (*y - *x) * dt;
        let dy = (*x * (rho - *z) - *y) * dt;
        let dz = (*x * *y - beta * *z) * dt;

        *x += dx;
        *y += dy;
        *z += dz;
    }

    /// ENCODER (Chaos Masking)
    /// Menelan byte sandi negara (AES-256) dan membungkusnya ke dalam gelombang Chaos.
    /// Hasilnya adalah PCM Audio 16-bit yang disuntikkan ke lubang Mic HT Baofeng/Motorola.
    pub fn chaos_shift_keying_encode(secret_bytes: &[u8], initial_x: f64, initial_y: f64, initial_z: f64) -> Vec<i16> {
        let mut audio_squelch = Vec::new();
        
        let mut x = initial_x;
        let mut y = initial_y;
        let mut z = initial_z;

        // Kami merepresentasikan 1 BIT informasi dengan menyuntikkannya ke variabel 'x' 
        // dalam putaran Chaos selama beberapa siklus.
        let samples_per_bit = 50; 

        for &byte in secret_bytes {
            for bit_pos in 0..8 {
                let bit_val = (byte >> bit_pos) & 1;
                
                // Modulasi (Chaos Shift Keying)
                // Jika bit = 1, kita berikan sedikit dorongan positif ke sistem.
                // Jika bit = 0, kita berikan dorongan negatif.
                let modulation_signal = if bit_val == 1 { 0.5 } else { -0.5 };

                for _ in 0..samples_per_bit {
                    Self::lorenz_step(&mut x, &mut y, &mut z);
                    
                    // Sinyal keluaran adalah (Nilai Chaos + Sinyal Rahasia)
                    let analog_output = x + modulation_signal;
                    
                    // Skalakan ke level Audio Mic In HT (sekitar -32768 hingga 32767)
                    let pcm_audio = (analog_output * 500.0) as i16;
                    audio_squelch.push(pcm_audio);
                }
            }
        }
        
        info!("LEVIATHAN: Menyuntikkan {} Bytes ke dalam {} sampel Noise Kosmik (Squelch).", secret_bytes.len(), audio_squelch.len());
        audio_squelch
    }

    /// DECODER (Chaos Synchronization)
    /// Mendengarkan audio dari lubang Earphone HT penerima.
    /// Mesin ini menggunakan persamaan Lorenz yang sama untuk mensinkronkan dirinya dengan noise tersebut.
    /// Setelah tersinkronisasi, selisih antara [Sinyal Masuk - Sinyal Chaos Internal] adalah Pesan Rahasia!
    pub fn chaos_synchronization_decode(received_audio: &[i16], initial_x: f64, initial_y: f64, initial_z: f64) -> Result<Vec<u8>> {
        let mut decoded_bytes = Vec::new();
        
        let mut x = initial_x;
        let mut y = initial_y;
        let mut z = initial_z;
        let samples_per_bit = 50;

        if received_audio.len() % (8 * samples_per_bit) != 0 {
            return Err(anyhow!("Gelombang chaos tidak lengkap."));
        }

        let total_bytes = received_audio.len() / (8 * samples_per_bit);
        let mut sample_index = 0;

        for _ in 0..total_bytes {
            let mut current_byte = 0u8;

            for bit_pos in 0..8 {
                let mut accumulated_signal = 0.0;

                for _ in 0..samples_per_bit {
                    // Mesin Penerima menjalankan Chaos-nya sendiri
                    Self::lorenz_step(&mut x, &mut y, &mut z);
                    
                    let incoming_signal = received_audio[sample_index] as f64 / 500.0;
                    sample_index += 1;
                    
                    // Rahasia terkuak: Sinyal Masuk dikurangi Sinyal Chaos Murni
                    let extracted_modulation = incoming_signal - x;
                    accumulated_signal += extracted_modulation;
                }

                // Jika akumulasi lebih dari 0, bit aslinya adalah 1
                if accumulated_signal > 0.0 {
                    current_byte |= 1 << bit_pos;
                }
            }
            decoded_bytes.push(current_byte);
        }

        info!("LEVIATHAN: Berhasil memulihkan {} Bytes dari kemresek HT.", decoded_bytes.len());
        Ok(decoded_bytes)
    }
}

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

    #[test]
    fn test_sdr_annihilation() {
        // Kunci Inisialisasi Lorenz (Initial State Kuantum)
        // Jika musuh tidak tahu X, Y, Z awal yang tepat ini hingga 10 desimal,
        // dekripsi adalah kemustahilan matematis absolut.
        let key_x = 0.1;
        let key_y = 0.0;
        let key_z = 0.0;
        
        let target_koordinat = b"SERANG_KOORDINAT_B4_KIRIM_UDARA";
        
        // 1. EKSEKUSI PEMBUNGA (CHAOS MASKING)
        let sinyal_squelch = ChaosModem::chaos_shift_keying_encode(target_koordinat, key_x, key_y, key_z);
        
        // BUKTI KEBUTAAN SCANNER SDR (Software Defined Radio):
        // Jika sinyal_squelch ini dipancarkan via HT, Radar musuh hanya melihat spektrum datar 
        // yang sama sekali tidak berpola (seperti suara "Tsss..." saat TV mati).
        assert!(!sinyal_squelch.is_empty());
        
        // 2. Simulasi gelombang ini merambat lewat udara (VHF 144 MHz), diterima HT lain.
        
        // 3. EKSEKUSI PEMULIHAN (CHAOS SYNCHRONIZATION)
        let pesan_diekstrak = ChaosModem::chaos_synchronization_decode(&sinyal_squelch, key_x, key_y, key_z).unwrap();
        
        // BUKTI MUTLAK:
        // Pesan rahasia kembali utuh 100% dari dalam kemresek Lorenz Attractor.
        assert_eq!(pesan_diekstrak, target_koordinat);
        
        let string_pesan = std::str::from_utf8(&pesan_diekstrak).unwrap();
        println!("SDR ANNIHILATION BERHASIL: Pesan '{}' diekstrak dari spektrum Chaos (Squelch)!", string_pesan);
    }
}
