// 🌌 [BioPhys 6.0 살아있는 유기적 생태계 진화 엔진] (src/ecosystem_evolution.rs)
// 1. 의도적 비트 플립 돌연변이 (Mutation Injector)
// 2. 서브루틴 무의식 누수 믹서 (Subconscious Bleed Mixer)
// 3. 열성 유전자 1-Bit 포자 압축 및 비상 발아기 (Spore Archiver & Germinator)

use std::collections::HashMap;
use std::time::Instant;

/// 🧬 [1. 의도적 비트 플립 돌연변이 인젝터]
pub struct MutationInjector {
    pub mutation_rate: f32, // 돌연변이 발생 확률 (기본 0.001 = 0.1%)
    pub total_mutations_applied: usize,
    pub beneficial_mutations: usize,
}

impl MutationInjector {
    pub fn new(mutation_rate: f32) -> Self {
        MutationInjector {
            mutation_rate,
            total_mutations_applied: 0,
            beneficial_mutations: 0,
        }
    }

    /// 2-Bit 패킹된 가중치 배열에 실제 우주 방사선(비트 플립)을 가하고 적합도(Fitness) 평가
    pub fn inject_cosmic_mutation(
        &mut self,
        packed_weights: &mut [u32],
        baseline_energy: f32,
        eval_fn: impl Fn(&[u32]) -> f32,
    ) -> bool {
        let len = packed_weights.len();
        if len == 0 { return false; }

        let mut mutated_indices = Vec::new();
        let mut old_values = Vec::new();

        // 1. 확률적 비트 플립 수행
        for i in 0..len {
            let pseudo_rand = ((i as u32 * 1103515245 + 12345) & 0x7FFFFFFF) as f32 / 2147483648.0;
            if pseudo_rand < self.mutation_rate {
                let bit_shift = (i % 16) * 2;
                let flip_mask = 0b11 << bit_shift;
                old_values.push((i, packed_weights[i]));
                packed_weights[i] ^= flip_mask; // 2-Bit 위상 전이
                mutated_indices.push(i);
                self.total_mutations_applied += 1;
            }
        }

        if mutated_indices.is_empty() { return false; }

        // 2. 적합도(Fitness) 평가: 새로운 계면 에너지가 카오스 최적점(0.50~0.55)에 더 가까워졌는지 검증
        let new_energy = eval_fn(packed_weights);
        let old_diff = (baseline_energy - 0.52).abs();
        let new_diff = (new_energy - 0.52).abs();

        if new_diff <= old_diff {
            // 유익한 돌연변이: 영구 보존(보존)
            self.beneficial_mutations += 1;
            true
        } else {
            // 해로운 돌연변이: 자연 도태 (원복 Rollback)
            for (idx, old_val) in old_values {
                packed_weights[idx] = old_val;
            }
            false
        }
    }
}

/// 🌊 [2. 서브루틴 무의식 누수 믹서 (Subconscious Bleed Mixer)]
pub struct SubconsciousMixer {
    pub residual_wave: Vec<f32>, // 이전 세션의 무의식적 잔여 진동 파형
    pub bleed_ratio: f32,        // 누수 비율 (기본 0.03 = 3%)
    pub session_count: usize,
}

impl SubconsciousMixer {
    pub fn new(dim: usize, bleed_ratio: f32) -> Self {
        SubconsciousMixer {
            residual_wave: vec![0.0; dim],
            bleed_ratio,
            session_count: 0,
        }
    }

    /// 이전 세션의 생각(잠재 상태)을 현재 연산에 3% 미세 결합하여 창의적 영감 유도
    pub fn blend_subconscious(&mut self, current_hidden: &mut [f32]) {
        self.session_count += 1;
        let len = current_hidden.len().min(self.residual_wave.len());

        for i in 0..len {
            // 무의식 누수: 현재 생각 + (이전 잔여 기억 * 3%)
            let inspiration = self.residual_wave[i] * self.bleed_ratio;
            current_hidden[i] += inspiration;

            // 현재 생각의 20%를 다음 세션의 무의식 잔여 파형으로 저장 (감쇠 저장)
            self.residual_wave[i] = (self.residual_wave[i] * 0.7) + (current_hidden[i] * 0.2);
        }
    }
}

/// 🍄 [3. 열성 유전자 1-Bit 포자 압축 및 비상 발아기]
pub struct SporeArchiver {
    pub spores: HashMap<String, Vec<u8>>, // 1-Bit 극단 압축된 씨앗 저장소
    pub total_archived: usize,
    pub total_germinated: usize,
}

impl SporeArchiver {
    pub fn new() -> Self {
        SporeArchiver {
            spores: HashMap::new(),
            total_archived: 0,
            total_germinated: 0,
        }
    }

    /// 비활성/열성 가중치 텐서를 1-Bit 포자(Spore) 형태로 압축 저장 (8배 추가 압축)
    pub fn archive_to_spore(&mut self, gene_name: &str, packed_2bit: &[u32]) {
        let mut spore_bytes = Vec::with_capacity(packed_2bit.len() / 2);
        
        for chunk in packed_2bit.chunks(8) {
            let mut byte: u8 = 0;
            for (bit_idx, &word) in chunk.iter().enumerate() {
                // 상위 흥분성 위상(0b11, 0b01)만 1로 추출하여 1-Bit로 극단 압축
                let is_active = (word & 0x55555555).count_ones() > 8;
                if is_active {
                    byte |= 1 << bit_idx;
                }
            }
            spore_bytes.push(byte);
        }

        self.spores.insert(gene_name.to_string(), spore_bytes);
        self.total_archived += 1;
    }

    /// 모드 붕괴(Mode Collapse) 또는 미지의 프롬프트 발생 시 1-Bit 포자를 2-Bit 가중치로 즉각 발아(Re-activate)
    pub fn germinate_spore(&mut self, gene_name: &str, output_len: usize) -> Option<Vec<u32>> {
        if let Some(spore_bytes) = self.spores.get(gene_name) {
            self.total_germinated += 1;
            let mut recovered_2bit = Vec::with_capacity(output_len);

            for &b in spore_bytes {
                for bit_idx in 0..8 {
                    if recovered_2bit.len() >= output_len { break; }
                    let bit = (b >> bit_idx) & 1;
                    let reconstructed_word = if bit == 1 { 0x55555555 } else { 0x00000000 };
                    recovered_2bit.push(reconstructed_word);
                }
            }

            while recovered_2bit.len() < output_len {
                recovered_2bit.push(0x00000000);
            }

            Some(recovered_2bit)
        } else {
            None
        }
    }
}