// 🌌 [BioPhys 6.0] Karl Friston 자유 에너지 원리 및 예측 부호화 엔진 (src/free_energy_engine.rs)
// 역전파(Backpropagation) 없이 변분 자유 에너지(Variational Free Energy)를 국소적으로 최소화하여 오차 스파이크만을 전파하는 신경망 엔진

use std::time::Instant;

/// 🔬 자유 에너지 엔진 설정 파라미터 (Config)
#[derive(Clone, Debug)]
pub struct FreeEnergyConfig {
    pub num_layers: usize,
    pub hidden_dim: usize,
    pub prediction_precision: f32, // 감각 정밀도 (Precision Weight, 기본: 1.25)
    pub learning_rate: f32,        // 국소 적응률 (기본: 0.05)
    pub complexity_penalty: f32,   // 복잡도 페널티 (KL Divergence 계수, 기본: 0.01)
}

impl Default for FreeEnergyConfig {
    fn default() -> Self {
        Self {
            num_layers: 4,
            hidden_dim: 256,
            prediction_precision: 1.25,
            learning_rate: 0.05,
            complexity_penalty: 0.01,
        }
    }
}

/// 🧠 예측 부호화 계층 (Predictive Coding Layer)
#[derive(Clone, Debug)]
pub struct PredictiveCodingLayer {
    pub layer_id: usize,
    pub representation_mu: Vec<f32>, // 내부 상태 표상 (Internal States)
    pub prediction_error: Vec<f32>,  // 예측 오차 스파이크 (Epsilon = Input - Mu)
    pub generative_weights: Vec<f32>, // 하향식 예측 생성 가중치
}

impl PredictiveCodingLayer {
    pub fn new(layer_id: usize, dim: usize) -> Self {
        Self {
            layer_id,
            representation_mu: vec![0.0f32; dim],
            prediction_error: vec![0.0f32; dim],
            generative_weights: (0..dim).map(|i| (i as f32 * 0.1).cos() * 0.5).collect(),
        }
    }
}

/// 🏛️ 자유 에너지 능동적 추론 엔진 (Main Engine Struct)
pub struct FreeEnergyEngine {
    pub config: FreeEnergyConfig,
    pub layers: Vec<PredictiveCodingLayer>,
    pub current_free_energy: f32,
    pub total_surprises_resolved: usize,
}

impl FreeEnergyEngine {
    pub fn new(config: FreeEnergyConfig) -> Self {
        let layers = (0..config.num_layers)
            .map(|i| PredictiveCodingLayer::new(i, config.hidden_dim))
            .collect();
        Self {
            config,
            layers,
            current_free_energy: 0.0,
            total_surprises_resolved: 0,
        }
    }

    /// [자유 에너지 최소화 추론]: 입력 신호에 대해 상향식 오차와 하향식 예측을 반복 정렬
    pub fn infer_and_minimize(&mut self, sensory_input: &[f32]) -> (f32, u128) {
        let t_start = Instant::now();
        let dim = self.config.hidden_dim.min(sensory_input.len());
        let mut total_accuracy_error = 0.0f32;
        let mut total_complexity_cost = 0.0f32;

        // 1. 최하위 감각 계층 (Layer 0) 오차 계산
        for i in 0..dim {
            let pred = self.layers[0].representation_mu[i] * self.layers[0].generative_weights[i];
            let error = sensory_input[i] - pred;
            self.layers[0].prediction_error[i] = error;
            total_accuracy_error += self.config.prediction_precision * error * error;

            // 국소적 상태 갱신: dMu = eta * (Precision * Error - Complexity)
            let d_mu = self.config.learning_rate * (self.config.prediction_precision * error - self.config.complexity_penalty * self.layers[0].representation_mu[i]);
            self.layers[0].representation_mu[i] += d_mu;
            total_complexity_cost += self.config.complexity_penalty * self.layers[0].representation_mu[i].powi(2);
        }

        // 2. 계층적 상위 계층 전파 (Hierarchical Predictive Propagation)
        for l in 1..self.config.num_layers {
            let prev_mu = self.layers[l - 1].representation_mu.clone();
            for i in 0..dim {
                let top_pred = self.layers[l].representation_mu[i] * self.layers[l].generative_weights[i];
                let error = prev_mu[i] - top_pred;
                self.layers[l].prediction_error[i] = error;
                total_accuracy_error += self.config.prediction_precision * error * error;

                let d_mu = self.config.learning_rate * (self.config.prediction_precision * error - self.config.complexity_penalty * self.layers[l].representation_mu[i]);
                self.layers[l].representation_mu[i] += d_mu;
                total_complexity_cost += self.config.complexity_penalty * self.layers[l].representation_mu[i].powi(2);
            }
        }

        // 3. 변분 자유 에너지 F = Accuracy Error + Complexity Cost
        self.current_free_energy = total_accuracy_error + total_complexity_cost;
        self.total_surprises_resolved += 1;
        let latency_us = t_start.elapsed().as_micros();

        (self.current_free_energy, latency_us)
    }

    /// [최상위 예측 표상 벡터 반환]
    pub fn get_top_representation(&self) -> &[f32] {
        &self.layers[self.config.num_layers - 1].representation_mu
    }

    /// [자유 에너지 상태 요약]
    pub fn telemetry_summary(&self) -> String {
        format!(
            "🧠 [자유 에너지 FEP]: 계층 {}개 | 현재 자유 에너지 F = {:.4} | 해결된 놀람(Surprise) 회수: {}회",
            self.config.num_layers, self.current_free_energy, self.total_surprises_resolved
        )
    }
}