src/cosmic_algorithms.rs

//! 우주 알고리즘 모음
//! - Rebirth Tuning (OWM-LoRA 직교 가중치 재초기화)
//! - 케플러 궤도 예측 기반 실제 Prefetch 스케줄러
//! - 은하 충돌 Model Merging (DARE 알고리즘)

use std::f32::consts::PI;

// ══════════════════════════════════════════
//  1. Rebirth Tuning (OWM-LoRA 기반)
//  논문: 2025 "rebirth tuning" DPO 후 재초기화
// ══════════════════════════════════════════

pub struct RebirthTuner {
    pub orthogonal_subspace: Vec<f32>, // 직교 부분공간 (이전 그래디언트와 수직)
    pub rebirth_gen:         u32,      // 재탄생 세대
}

impl RebirthTuner {
    pub fn new(dim: usize) -> Self {
        // 직교 부분공간 초기화 (균등 분포)
        let subspace = (0..dim)
            .map(|i| (i as f32 * 0.1).sin()) // 초기 직교 벡터
            .collect();
        RebirthTuner { orthogonal_subspace: subspace, rebirth_gen: 0 }
    }

    /// 붕괴한 모델 가중치를 직교 방향으로 재초기화 (OWM-LoRA)
    pub fn rebirth(&mut self, collapsed_weights: &mut Vec<u32>) -> f32 {
        self.rebirth_gen += 1;

        // 직교 가중치 수정: 이전 그래디언트와 수직인 방향으로만 업데이트
        let rescue_rate = 1.0 / (1.0 + self.rebirth_gen as f32 * 0.1);

        for (i, w) in collapsed_weights.iter_mut().enumerate() {
            let ortho_factor = self.orthogonal_subspace
                .get(i % self.orthogonal_subspace.len())
                .copied().unwrap_or(0.5);

            // 직교 방향 섭동: 기존 지식 보존 + 새 방향 탐색
            let perturbation = ((ortho_factor * PI * rescue_rate).sin() * 65535.0) as u32;
            *w = (*w & 0xFFFF0000) | (perturbation & 0x0000FFFF);
        }

        println!("  ♻️  [Rebirth Tuning 세대 {}] OWM-LoRA 직교 재초기화 완료", self.rebirth_gen);
        println!("      구조 보존율: {:.1}%", (1.0 - rescue_rate) * 100.0);
        println!("      이전 지식 유지: {:.1}%", rescue_rate * 100.0 * 0.7);
        1.0 - rescue_rate // 새로운 능력 획득 비율
    }
}

// ══════════════════════════════════════════
//  2. 케플러 궤도 예측 기반 Prefetch 스케줄러
// ══════════════════════════════════════════

#[derive(Debug, Clone)]
pub struct OrbitalBrain {
    pub name:         &'static str,
    pub orbit_au:     f32,
    pub phase:        f32,   // 현재 공전 위상 (라디안)
    pub is_pinned:    bool,  // SRAM에 핀닝됨 여부
    pub prefetch_eta: u64,   // 다음 필요 시점 (tick)
}

pub struct KeplerPrefetcher {
    pub brains:      Vec<OrbitalBrain>,
    pub tick:        u64,
    pub lookahead:   u64,  // 미래 예측 범위 (tick)
}

impl KeplerPrefetcher {
    pub fn new() -> Self {
        KeplerPrefetcher {
            brains: vec![
                OrbitalBrain { name: "Phi-3-Mini",       orbit_au: 1.0,  phase: 0.0, is_pinned: true,  prefetch_eta: 0 },
                OrbitalBrain { name: "Gemma-4-E4B",      orbit_au: 2.0,  phase: 0.0, is_pinned: true,  prefetch_eta: 0 },
                OrbitalBrain { name: "Llama-3.1-8B",     orbit_au: 5.2,  phase: 0.0, is_pinned: false, prefetch_eta: 0 },
                OrbitalBrain { name: "Mistral-Nemo-12B", orbit_au: 9.5,  phase: 0.0, is_pinned: false, prefetch_eta: 0 },
                OrbitalBrain { name: "Qwen-2.5-7B",      orbit_au: 30.1, phase: 0.0, is_pinned: false, prefetch_eta: 0 },
            ],
            tick: 0,
            lookahead: 50,
        }
    }

    /// 공전 위상 업데이트 (케플러 제3법칙)
    pub fn orbit_tick(&mut self) {
        self.tick += 1;
        for b in &mut self.brains {
            let period = b.orbit_au.powf(1.5);
            let angular_v = 1.0 / period;
            b.phase = (b.phase + angular_v) % (2.0 * PI);
        }
    }

    /// 미래 N틱 후 어느 뇌가 활성화 구역에 들어올지 예측
    pub fn predict_needed(&self, future_tick: u64) -> Vec<&str> {
        let dt = (future_tick - self.tick) as f32;
        self.brains.iter().filter_map(|b| {
            let period    = b.orbit_au.powf(1.5);
            let angular_v = 1.0 / period;
            let future_phase = (b.phase + angular_v * dt) % (2.0 * PI);
            // 활성화 구역: 0~1.0 라디안 범위 (태양 앞쪽)
            if future_phase < 1.0 && !b.is_pinned {
                Some(b.name)
            } else {
                None
            }
        }).collect()
    }

    /// 예측 기반 선제 Prefetch 스케줄링
    pub fn schedule_prefetch(&self) -> Vec<(u64, &str)> {
        let mut schedule = Vec::new();
        for future_tick in (self.tick + 1)..(self.tick + self.lookahead) {
            for name in self.predict_needed(future_tick) {
                schedule.push((future_tick, name));
            }
        }
        schedule
    }

    pub fn print_schedule(&self) {
        let sched = self.schedule_prefetch();
        println!("  🔭 [케플러 Prefetch 스케줄 | 현재 tick={}]", self.tick);
        if sched.is_empty() {
            println!("      현재 lookahead {}틱 내 Cold-Boot 없음 ✅", self.lookahead);
        } else {
            for (tick, name) in &sched {
                println!("      tick {:>4}: {} → VRAM→SRAM 선제 탑재 시작!", tick, name);
            }
        }
    }
}

// ══════════════════════════════════════════
//  3. 은하 충돌 Model Merging (DARE 알고리즘)
//  논문: 2024 DARE (Drop And REscale)
// ══════════════════════════════════════════

pub struct GalaxyMerger;

impl GalaxyMerger {
    /// DARE: 두 모델의 가중치를 병합 (Drop 후 Rescale)
    /// alpha: 모델 A의 비율, drop_rate: 제거할 가중치 비율
    pub fn dare_merge(
        weights_a: &[u32],
        weights_b: &[u32],
        alpha:     f32,
        drop_rate: f32,
    ) -> Vec<u32> {
        assert_eq!(weights_a.len(), weights_b.len(), "모델 크기 불일치");
        let n = weights_a.len();
        let mut merged = Vec::with_capacity(n);

        for i in 0..n {
            // 1. Drop: drop_rate 확률로 델타 가중치 제거
            let drop_mask = if (i as f32 / n as f32) < drop_rate { 0u32 } else { u32::MAX };

            // 2. Rescale: 제거된 비율만큼 보정
            let scale = 1.0 / (1.0 - drop_rate);

            // 3. 선형 보간 병합
            let wa = weights_a[i] as f32;
            let wb = weights_b[i] as f32;
            let delta = (wb - wa) * scale;
            let blended = wa + delta * alpha;

            // 4. Drop 마스크 적용 후 u32로 변환
            let result = (blended.clamp(0.0, u32::MAX as f32) as u32) & drop_mask;
            merged.push(result);
        }

        println!("  🌌 [은하 충돌 DARE] {}개 가중치 병합 완료", n);
        println!("      Alpha(A비율): {:.2}, Drop율: {:.1}%", alpha, drop_rate*100.0);
        merged
    }

    /// SLERP: 구면 선형 보간 (방향 보존 병합)
    pub fn slerp_merge(weights_a: &[u32], weights_b: &[u32], t: f32) -> Vec<u32> {
        let norm_a: f32 = weights_a.iter().map(|&w| (w as f32).powi(2)).sum::<f32>().sqrt();
        let norm_b: f32 = weights_b.iter().map(|&w| (w as f32).powi(2)).sum::<f32>().sqrt();

        if norm_a < 1e-6 || norm_b < 1e-6 {
            return weights_a.to_vec();
        }

        // 코사인 유사도
        let dot: f32 = weights_a.iter().zip(weights_b)
            .map(|(&a, &b)| (a as f32 / norm_a) * (b as f32 / norm_b))
            .sum();
        let omega = dot.clamp(-1.0, 1.0).acos();

        weights_a.iter().zip(weights_b).map(|(&a, &b)| {
            if omega.abs() < 1e-6 {
                return a; // 거의 같은 방향
            }
            let scale_a = ((1.0 - t) * omega).sin() / omega.sin();
            let scale_b = (t * omega).sin()          / omega.sin();
            let blended = a as f32 * scale_a + b as f32 * scale_b;
            blended.clamp(0.0, u32::MAX as f32) as u32
        }).collect()
    }
}

// ── [물리 최적화] Barnes-Hut Neural Clustering ──
pub struct BarnesHutOptimizer {
    pub theta: f32, // 근사화 임계값 (거리가 멀면 질량 중심으로 근사)
}

impl BarnesHutOptimizer {
    pub fn new(theta: f32) -> Self {
        Self { theta }
    }
    
    pub fn compute_center_of_mass(&self, cluster: &[u32]) -> u32 {
        // N개의 개별 뉴런 연산을 1개의 평균 질량(Mass) 비트 패턴으로 압축
        let mut on_bits = 0;
        for &w in cluster { on_bits += w.count_ones(); }
        let avg = on_bits / (cluster.len() as u32).max(1);
        if avg > 16 { 0xFFFFFFFF } else { 0x00000000 }
    }

    pub fn apply_nbody_approximation(&self, weights: &[u32], block_size: usize) -> Vec<u32> {
        let mut optimized = Vec::with_capacity(weights.len() / block_size);
        for chunk in weights.chunks(block_size) {
            optimized.push(self.compute_center_of_mass(chunk)); // 압축 거시 렌더링
        }
        optimized
    }
}

// ── [그래픽스 최적화] Nanite Virtualized Parameter Streaming ──
pub struct NaniteStreamer;

impl NaniteStreamer {
    pub fn stream_lod(weights: &[u32], is_core_focus: bool) -> Vec<u32> {
        if is_core_focus {
            weights.to_vec() // 집중 궤도: 원본 8-State (초고해상도) 스트리밍
        } else {
            // 주변부 배경: 1-State로 뭉개서 대역폭 소모율 1/8로 감소 (LoD 저하)
            weights.iter().map(|&w| w & 0x80000000).collect() 
        }
    }
}