oxirs-embed 0.2.4

//! Continual Learning Capabilities
//!
//! This module implements continual learning for embedding models with
//! catastrophic forgetting prevention, task-incremental learning,
//! and lifelong adaptation capabilities.

use crate::{EmbeddingModel, ModelConfig, TrainingStats, Triple, Vector};
use anyhow::{anyhow, Result};
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use scirs2_core::ndarray_ext::{Array1, Array2};
use scirs2_core::random::{Random, RngExt};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque};
use uuid::Uuid;

/// Configuration for continual learning
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ContinualLearningConfig {
    pub base_config: ModelConfig,
    /// Memory management configuration
    pub memory_config: MemoryConfig,
    /// Regularization configuration
    pub regularization_config: RegularizationConfig,
    /// Architecture adaptation configuration
    pub architecture_config: ArchitectureConfig,
    /// Task management configuration
    pub task_config: TaskConfig,
    /// Replay configuration
    pub replay_config: ReplayConfig,
}

/// Memory management configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryConfig {
    /// Memory type
    pub memory_type: MemoryType,
    /// Memory capacity
    pub memory_capacity: usize,
    /// Memory update strategy
    pub update_strategy: MemoryUpdateStrategy,
    /// Memory consolidation
    pub consolidation: ConsolidationConfig,
}

impl Default for MemoryConfig {
    fn default() -> Self {
        Self {
            memory_type: MemoryType::EpisodicMemory,
            memory_capacity: 10000,
            update_strategy: MemoryUpdateStrategy::ReservoirSampling,
            consolidation: ConsolidationConfig::default(),
        }
    }
}

/// Types of memory systems
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MemoryType {
    /// Episodic memory for storing experiences
    EpisodicMemory,
    /// Semantic memory for storing knowledge
    SemanticMemory,
    /// Working memory for temporary storage
    WorkingMemory,
    /// Procedural memory for skills
    ProceduralMemory,
    /// Hybrid memory system
    HybridMemory,
}

/// Memory update strategies
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MemoryUpdateStrategy {
    /// First-In-First-Out
    FIFO,
    /// Random replacement
    Random,
    /// Reservoir sampling
    ReservoirSampling,
    /// Importance-based sampling
    ImportanceBased,
    /// Gradient-based selection
    GradientBased,
    /// Clustering-based selection
    ClusteringBased,
}

/// Memory consolidation configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConsolidationConfig {
    /// Use memory consolidation
    pub enabled: bool,
    /// Consolidation frequency
    pub frequency: usize,
    /// Consolidation strength
    pub strength: f32,
    /// Sleep-like consolidation
    pub sleep_consolidation: bool,
}

impl Default for ConsolidationConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            frequency: 1000,
            strength: 0.1,
            sleep_consolidation: false,
        }
    }
}

/// Regularization configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegularizationConfig {
    /// Regularization methods
    pub methods: Vec<RegularizationMethod>,
    /// EWC configuration
    pub ewc_config: EWCConfig,
    /// Synaptic intelligence configuration
    pub si_config: SynapticIntelligenceConfig,
    /// Learning without forgetting configuration
    pub lwf_config: LwFConfig,
}

impl Default for RegularizationConfig {
    fn default() -> Self {
        Self {
            methods: vec![
                RegularizationMethod::EWC,
                RegularizationMethod::SynapticIntelligence,
            ],
            ewc_config: EWCConfig::default(),
            si_config: SynapticIntelligenceConfig::default(),
            lwf_config: LwFConfig::default(),
        }
    }
}

/// Regularization methods
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum RegularizationMethod {
    /// Elastic Weight Consolidation
    EWC,
    /// Synaptic Intelligence
    SynapticIntelligence,
    /// Learning without Forgetting
    LwF,
    /// Memory Aware Synapses
    MAS,
    /// Riemannian Walk
    RiemannianWalk,
    /// PackNet
    PackNet,
}

/// EWC configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EWCConfig {
    /// Regularization strength
    pub lambda: f32,
    /// Fisher information computation method
    pub fisher_method: FisherMethod,
    /// Online EWC
    pub online: bool,
    /// Gamma parameter for online EWC
    pub gamma: f32,
}

impl Default for EWCConfig {
    fn default() -> Self {
        Self {
            lambda: 0.4,
            fisher_method: FisherMethod::Empirical,
            online: true,
            gamma: 1.0,
        }
    }
}

/// Fisher information computation methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FisherMethod {
    /// Empirical Fisher information
    Empirical,
    /// True Fisher information
    True,
    /// Diagonal approximation
    Diagonal,
    /// Block-diagonal approximation
    BlockDiagonal,
}

/// Synaptic Intelligence configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SynapticIntelligenceConfig {
    /// Regularization strength
    pub c: f32,
    /// Learning rate for importance updates
    pub xi: f32,
    /// Damping parameter
    pub damping: f32,
}

impl Default for SynapticIntelligenceConfig {
    fn default() -> Self {
        Self {
            c: 0.1,
            xi: 1.0,
            damping: 0.1,
        }
    }
}

/// Learning without Forgetting configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LwFConfig {
    /// Distillation loss weight
    pub alpha: f32,
    /// Temperature for distillation
    pub temperature: f32,
    /// Use attention transfer
    pub attention_transfer: bool,
}

impl Default for LwFConfig {
    fn default() -> Self {
        Self {
            alpha: 1.0,
            temperature: 4.0,
            attention_transfer: false,
        }
    }
}

/// Architecture adaptation configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchitectureConfig {
    /// Adaptation method
    pub adaptation_method: ArchitectureAdaptation,
    /// Progressive networks configuration
    pub progressive_config: ProgressiveConfig,
    /// Dynamic network configuration
    pub dynamic_config: DynamicConfig,
}

impl Default for ArchitectureConfig {
    fn default() -> Self {
        Self {
            adaptation_method: ArchitectureAdaptation::Progressive,
            progressive_config: ProgressiveConfig::default(),
            dynamic_config: DynamicConfig::default(),
        }
    }
}

/// Architecture adaptation methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ArchitectureAdaptation {
    /// Progressive neural networks
    Progressive,
    /// Dynamic network expansion
    Dynamic,
    /// PackNet parameter allocation
    PackNet,
    /// HAT hard attention
    HAT,
    /// Supermasks
    Supermasks,
}

/// Progressive networks configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProgressiveConfig {
    /// Number of columns per task
    pub columns_per_task: usize,
    /// Lateral connection strength
    pub lateral_strength: f32,
    /// Column capacity
    pub column_capacity: usize,
}

impl Default for ProgressiveConfig {
    fn default() -> Self {
        Self {
            columns_per_task: 1,
            lateral_strength: 0.5,
            column_capacity: 1000,
        }
    }
}

/// Dynamic network configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DynamicConfig {
    /// Expansion threshold
    pub expansion_threshold: f32,
    /// Pruning threshold
    pub pruning_threshold: f32,
    /// Growth rate
    pub growth_rate: f32,
    /// Maximum network size
    pub max_size: usize,
}

impl Default for DynamicConfig {
    fn default() -> Self {
        Self {
            expansion_threshold: 0.9,
            pruning_threshold: 0.1,
            growth_rate: 0.1,
            max_size: 100000,
        }
    }
}

/// Task configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskConfig {
    /// Task detection method
    pub detection_method: TaskDetection,
    /// Task boundary detection
    pub boundary_detection: BoundaryDetection,
    /// Task switching strategy
    pub switching_strategy: TaskSwitching,
}

impl Default for TaskConfig {
    fn default() -> Self {
        Self {
            detection_method: TaskDetection::Automatic,
            boundary_detection: BoundaryDetection::ChangePoint,
            switching_strategy: TaskSwitching::Soft,
        }
    }
}

/// Task detection methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TaskDetection {
    /// Manual task specification
    Manual,
    /// Automatic task detection
    Automatic,
    /// Oracle task information
    Oracle,
    /// Clustering-based detection
    Clustering,
}

/// Boundary detection methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum BoundaryDetection {
    /// Change point detection
    ChangePoint,
    /// Distribution shift detection
    DistributionShift,
    /// Loss-based detection
    LossBased,
    /// Gradient-based detection
    GradientBased,
}

/// Task switching strategies
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TaskSwitching {
    /// Hard switching
    Hard,
    /// Soft switching with weights
    Soft,
    /// Attention-based switching
    Attention,
    /// Gating mechanisms
    Gating,
}

/// Replay configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReplayConfig {
    /// Replay methods
    pub methods: Vec<ReplayMethod>,
    /// Replay buffer size
    pub buffer_size: usize,
    /// Replay ratio
    pub replay_ratio: f32,
    /// Generative replay configuration
    pub generative_config: GenerativeReplayConfig,
}

impl Default for ReplayConfig {
    fn default() -> Self {
        Self {
            methods: vec![
                ReplayMethod::ExperienceReplay,
                ReplayMethod::GenerativeReplay,
            ],
            buffer_size: 5000,
            replay_ratio: 0.5,
            generative_config: GenerativeReplayConfig::default(),
        }
    }
}

/// Replay methods
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ReplayMethod {
    /// Experience replay
    ExperienceReplay,
    /// Generative replay
    GenerativeReplay,
    /// Pseudo-rehearsal
    PseudoRehearsal,
    /// Meta-replay
    MetaReplay,
    /// Gradient episodic memory
    GradientEpisodicMemory,
}

/// Generative replay configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GenerativeReplayConfig {
    /// Generator type
    pub generator_type: GeneratorType,
    /// Generation quality threshold
    pub quality_threshold: f32,
    /// Generation diversity weight
    pub diversity_weight: f32,
}

impl Default for GenerativeReplayConfig {
    fn default() -> Self {
        Self {
            generator_type: GeneratorType::VAE,
            quality_threshold: 0.8,
            diversity_weight: 0.1,
        }
    }
}

/// Generator types for generative replay
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum GeneratorType {
    VAE,
    GAN,
    Flow,
    Diffusion,
}

/// Task information
#[derive(Debug, Clone)]
pub struct TaskInfo {
    pub task_id: String,
    pub task_type: String,
    pub start_time: DateTime<Utc>,
    pub end_time: Option<DateTime<Utc>>,
    pub examples_seen: usize,
    pub performance: f32,
    pub task_embedding: Option<Array1<f32>>,
}

impl TaskInfo {
    pub fn new(task_id: String, task_type: String) -> Self {
        Self {
            task_id,
            task_type,
            start_time: Utc::now(),
            end_time: None,
            examples_seen: 0,
            performance: 0.0,
            task_embedding: None,
        }
    }
}

/// Memory entry for episodic memory
#[derive(Debug, Clone)]
pub struct MemoryEntry {
    pub data: Array1<f32>,
    pub target: Array1<f32>,
    pub task_id: String,
    pub timestamp: DateTime<Utc>,
    pub importance: f32,
    pub access_count: usize,
}

impl MemoryEntry {
    pub fn new(data: Array1<f32>, target: Array1<f32>, task_id: String) -> Self {
        Self {
            data,
            target,
            task_id,
            timestamp: Utc::now(),
            importance: 1.0,
            access_count: 0,
        }
    }
}

/// EWC state for regularization
#[derive(Debug, Clone)]
pub struct EWCState {
    pub fisher_information: Array2<f32>,
    pub optimal_parameters: Array2<f32>,
    pub task_id: String,
    pub importance: f32,
}

/// Continual learning model
#[derive(Debug)]
pub struct ContinualLearningModel {
    pub config: ContinualLearningConfig,
    pub model_id: Uuid,

    /// Core model parameters
    pub embeddings: Array2<f32>,
    pub task_specific_embeddings: HashMap<String, Array2<f32>>,

    /// Memory systems
    pub episodic_memory: VecDeque<MemoryEntry>,
    pub semantic_memory: HashMap<String, Array1<f32>>,

    /// Regularization state
    pub ewc_states: Vec<EWCState>,
    pub synaptic_importance: Array2<f32>,
    pub parameter_trajectory: Array2<f32>,

    /// Task management
    pub current_task: Option<TaskInfo>,
    pub task_history: Vec<TaskInfo>,
    pub task_boundaries: Vec<usize>,

    /// Progressive networks
    pub network_columns: Vec<Array2<f32>>,
    pub lateral_connections: Vec<Array2<f32>>,

    /// Generative models for replay
    pub generator: Option<Array2<f32>>,
    pub discriminator: Option<Array2<f32>>,

    /// Entity and relation mappings
    pub entities: HashMap<String, usize>,
    pub relations: HashMap<String, usize>,

    /// Training state
    pub examples_seen: usize,
    pub training_stats: Option<TrainingStats>,
    pub is_trained: bool,
}

impl ContinualLearningModel {
    /// Create new continual learning model
    pub fn new(config: ContinualLearningConfig) -> Self {
        let mut _random = Random::default();

        let model_id = Uuid::new_v4();
        let dimensions = config.base_config.dimensions;

        Self {
            config: config.clone(),
            model_id,
            embeddings: Array2::zeros((0, dimensions)),
            task_specific_embeddings: HashMap::new(),
            episodic_memory: VecDeque::with_capacity(config.memory_config.memory_capacity),
            semantic_memory: HashMap::new(),
            ewc_states: Vec::new(),
            synaptic_importance: Array2::zeros((0, dimensions)),
            parameter_trajectory: Array2::zeros((0, dimensions)),
            current_task: None,
            task_history: Vec::new(),
            task_boundaries: Vec::new(),
            network_columns: {
                let mut random = Random::default();
                vec![Array2::from_shape_fn((dimensions, dimensions), |_| {
                    random.random::<f64>() as f32 * 0.1
                })]
            },
            lateral_connections: Vec::new(),
            generator: Some({
                let mut random = Random::default();
                Array2::from_shape_fn((dimensions, dimensions), |_| {
                    random.random::<f64>() as f32 * 0.1
                })
            }),
            discriminator: Some({
                let mut random = Random::default();
                Array2::from_shape_fn((dimensions, dimensions), |_| {
                    random.random::<f64>() as f32 * 0.1
                })
            }),
            entities: HashMap::new(),
            relations: HashMap::new(),
            examples_seen: 0,
            training_stats: None,
            is_trained: false,
        }
    }

    /// Start new task
    pub fn start_task(&mut self, task_id: String, task_type: String) -> Result<()> {
        // Finish current task if exists
        if let Some(ref mut current_task) = self.current_task {
            current_task.end_time = Some(Utc::now());
            self.task_history.push(current_task.clone());
            self.task_boundaries.push(self.examples_seen);
        }

        // Consolidate memory before starting new task
        if self.config.memory_config.consolidation.enabled {
            self.consolidate_memory()?;
        }

        // Compute EWC state for previous task
        if self
            .config
            .regularization_config
            .methods
            .contains(&RegularizationMethod::EWC)
        {
            self.compute_ewc_state()?;
        }

        // Add new network column for progressive learning
        if matches!(
            self.config.architecture_config.adaptation_method,
            ArchitectureAdaptation::Progressive
        ) {
            self.add_network_column()?;
        }

        // Start new task
        let mut new_task = TaskInfo::new(task_id.clone(), task_type);
        new_task.task_embedding = Some(self.generate_task_embedding(&task_id)?);
        self.current_task = Some(new_task);

        Ok(())
    }

    /// Add example to continual learning
    pub async fn add_example(
        &mut self,
        data: Array1<f32>,
        target: Array1<f32>,
        task_id: Option<String>,
    ) -> Result<()> {
        let task_id = task_id.unwrap_or_else(|| {
            self.current_task
                .as_ref()
                .map(|t| t.task_id.clone())
                .unwrap_or_else(|| "default".to_string())
        });

        // Detect task boundary if using automatic detection
        if matches!(
            self.config.task_config.detection_method,
            TaskDetection::Automatic
        ) && self.detect_task_boundary(&data)?
        {
            let task_num = self.task_history.len() + 1;
            let new_task_id = format!("task_{task_num}");
            self.start_task(new_task_id.clone(), "automatic".to_string())?;
        }

        // Initialize network if needed
        if self.embeddings.nrows() == 0 {
            let input_dim = data.len();
            let output_dim = target.len();
            self.embeddings = Array2::from_shape_fn((output_dim, input_dim), |(_, _)| {
                let mut random = Random::default();
                (random.random::<f64>() as f32 - 0.5) * 0.1
            });
            self.synaptic_importance = Array2::zeros((output_dim, input_dim));
            self.parameter_trajectory = Array2::zeros((output_dim, input_dim));
        }

        // Add to episodic memory
        self.add_to_memory(data.clone(), target.clone(), task_id.clone())?;

        // Update current task
        if let Some(ref mut current_task) = self.current_task {
            current_task.examples_seen += 1;
        }

        self.examples_seen += 1;

        // Trigger learning
        self.continual_update(data, target, task_id).await?;

        Ok(())
    }

    /// Add example to memory
    fn add_to_memory(
        &mut self,
        data: Array1<f32>,
        target: Array1<f32>,
        task_id: String,
    ) -> Result<()> {
        let mut random = Random::default();
        let entry = MemoryEntry::new(data, target, task_id);

        match self.config.memory_config.update_strategy {
            MemoryUpdateStrategy::FIFO => {
                if self.episodic_memory.len() >= self.config.memory_config.memory_capacity {
                    self.episodic_memory.pop_front();
                }
                self.episodic_memory.push_back(entry);
            }
            MemoryUpdateStrategy::Random => {
                if self.episodic_memory.len() >= self.config.memory_config.memory_capacity {
                    let idx = random.random_range(0..self.episodic_memory.len());
                    self.episodic_memory.remove(idx);
                }
                self.episodic_memory.push_back(entry);
            }
            MemoryUpdateStrategy::ReservoirSampling => {
                if self.episodic_memory.len() < self.config.memory_config.memory_capacity {
                    self.episodic_memory.push_back(entry);
                } else {
                    let k = self.episodic_memory.len();
                    let j = random.random_range(0..self.examples_seen + 1);
                    if j < k {
                        self.episodic_memory[j] = entry;
                    }
                }
            }
            MemoryUpdateStrategy::ImportanceBased => {
                self.add_by_importance(entry)?;
            }
            _ => {
                self.episodic_memory.push_back(entry);
            }
        }

        Ok(())
    }

    /// Add entry based on importance
    fn add_by_importance(&mut self, entry: MemoryEntry) -> Result<()> {
        if self.episodic_memory.len() < self.config.memory_config.memory_capacity {
            self.episodic_memory.push_back(entry);
        } else {
            // Find least important entry
            let mut min_importance = f32::INFINITY;
            let mut min_idx = 0;

            for (i, existing_entry) in self.episodic_memory.iter().enumerate() {
                if existing_entry.importance < min_importance {
                    min_importance = existing_entry.importance;
                    min_idx = i;
                }
            }

            // Replace if new entry is more important
            if entry.importance > min_importance {
                self.episodic_memory[min_idx] = entry;
            }
        }

        Ok(())
    }

    /// Detect task boundary
    fn detect_task_boundary(&self, data: &Array1<f32>) -> Result<bool> {
        match self.config.task_config.boundary_detection {
            BoundaryDetection::ChangePoint => self.detect_change_point(data),
            BoundaryDetection::DistributionShift => self.detect_distribution_shift(data),
            BoundaryDetection::LossBased => self.detect_loss_change(data),
            BoundaryDetection::GradientBased => self.detect_gradient_change(data),
        }
    }

    /// Detect change point
    fn detect_change_point(&self, _data: &Array1<f32>) -> Result<bool> {
        // Simplified change point detection
        // In practice, would use proper statistical tests
        if self.examples_seen % 1000 == 0 && self.examples_seen > 0 {
            Ok(true)
        } else {
            Ok(false)
        }
    }

    /// Detect distribution shift
    fn detect_distribution_shift(&self, data: &Array1<f32>) -> Result<bool> {
        if self.episodic_memory.is_empty() {
            return Ok(false);
        }

        // Compute distance to recent examples
        let recent_count = 100.min(self.episodic_memory.len());
        let mut total_distance = 0.0;

        for i in 0..recent_count {
            let idx = self.episodic_memory.len() - 1 - i;
            let recent_data = &self.episodic_memory[idx].data;
            let distance = self.euclidean_distance(data, recent_data);
            total_distance += distance;
        }

        let average_distance = total_distance / recent_count as f32;
        let threshold = 2.0; // Configurable threshold

        Ok(average_distance > threshold)
    }

    /// Detect loss change
    fn detect_loss_change(&self, _data: &Array1<f32>) -> Result<bool> {
        // Simplified loss-based detection
        Ok(false)
    }

    /// Detect gradient change
    fn detect_gradient_change(&self, _data: &Array1<f32>) -> Result<bool> {
        // Simplified gradient-based detection
        Ok(false)
    }

    /// Continual learning update
    async fn continual_update(
        &mut self,
        data: Array1<f32>,
        target: Array1<f32>,
        _task_id: String,
    ) -> Result<()> {
        // Compute gradients
        let gradients = self.compute_gradients(&data, &target)?;

        // Apply regularization
        let regularized_gradients = self.apply_regularization(gradients)?;

        // Update parameters
        self.update_parameters(regularized_gradients)?;

        // Update synaptic importance for Synaptic Intelligence
        if self
            .config
            .regularization_config
            .methods
            .contains(&RegularizationMethod::SynapticIntelligence)
        {
            self.update_synaptic_importance(&data, &target)?;
        }

        // Replay from memory
        if self
            .config
            .replay_config
            .methods
            .contains(&ReplayMethod::ExperienceReplay)
        {
            self.experience_replay().await?;
        }

        // Generative replay
        if self
            .config
            .replay_config
            .methods
            .contains(&ReplayMethod::GenerativeReplay)
        {
            self.generative_replay().await?;
        }

        Ok(())
    }

    /// Compute gradients
    fn compute_gradients(&self, data: &Array1<f32>, target: &Array1<f32>) -> Result<Array2<f32>> {
        let dimensions = self.config.base_config.dimensions;
        let mut gradients = Array2::zeros((1, dimensions));

        // Initialize network if not done yet
        if self.embeddings.nrows() == 0 {
            // This is a const method, so we can't modify self here
            // Return a default gradient instead
            return Ok(gradients);
        }

        // Forward pass
        let prediction = self.forward_pass(data)?;

        // Compute error
        let error = target - &prediction;

        // Simple gradient computation
        for i in 0..dimensions.min(data.len()) {
            gradients[[0, i]] = error[i] * data[i];
        }

        Ok(gradients)
    }

    /// Apply regularization to gradients
    fn apply_regularization(&self, mut gradients: Array2<f32>) -> Result<Array2<f32>> {
        for method in &self.config.regularization_config.methods {
            match method {
                RegularizationMethod::EWC => {
                    gradients = self.apply_ewc_regularization(gradients)?;
                }
                RegularizationMethod::SynapticIntelligence => {
                    gradients = self.apply_si_regularization(gradients)?;
                }
                RegularizationMethod::LwF => {
                    gradients = self.apply_lwf_regularization(gradients)?;
                }
                _ => {}
            }
        }

        Ok(gradients)
    }

    /// Apply EWC regularization
    fn apply_ewc_regularization(&self, mut gradients: Array2<f32>) -> Result<Array2<f32>> {
        let lambda = self.config.regularization_config.ewc_config.lambda;

        for ewc_state in &self.ewc_states {
            let penalty = &ewc_state.fisher_information
                * (&self.embeddings - &ewc_state.optimal_parameters)
                * lambda
                * ewc_state.importance;

            // Apply penalty to gradients
            let rows_to_update = gradients.nrows().min(penalty.nrows());
            let cols_to_update = gradients.ncols().min(penalty.ncols());

            for i in 0..rows_to_update {
                for j in 0..cols_to_update {
                    gradients[[i, j]] -= penalty[[i, j]];
                }
            }
        }

        Ok(gradients)
    }

    /// Apply Synaptic Intelligence regularization
    fn apply_si_regularization(&self, mut gradients: Array2<f32>) -> Result<Array2<f32>> {
        let c = self.config.regularization_config.si_config.c;

        if !self.synaptic_importance.is_empty() {
            let penalty = &self.synaptic_importance * c;

            let rows_to_update = gradients.nrows().min(penalty.nrows());
            let cols_to_update = gradients.ncols().min(penalty.ncols());

            for i in 0..rows_to_update {
                for j in 0..cols_to_update {
                    gradients[[i, j]] -= penalty[[i, j]];
                }
            }
        }

        Ok(gradients)
    }

    /// Apply Learning without Forgetting regularization
    fn apply_lwf_regularization(&self, gradients: Array2<f32>) -> Result<Array2<f32>> {
        // LwF uses knowledge distillation - would need previous model outputs
        // For simplicity, returning original gradients
        Ok(gradients)
    }

    /// Update model parameters
    fn update_parameters(&mut self, gradients: Array2<f32>) -> Result<()> {
        let learning_rate = 0.01; // Could be configurable

        // Ensure embeddings matrix has the right shape
        if self.embeddings.nrows() < gradients.nrows() {
            let dimensions = self.config.base_config.dimensions;
            let new_rows = gradients.nrows();
            let mut random = Random::default();
            self.embeddings =
                Array2::from_shape_fn((new_rows, dimensions), |_| random.random::<f32>() * 0.1);
        }

        // Update embeddings
        let rows_to_update = gradients.nrows().min(self.embeddings.nrows());
        let cols_to_update = gradients.ncols().min(self.embeddings.ncols());

        for i in 0..rows_to_update {
            for j in 0..cols_to_update {
                self.embeddings[[i, j]] += learning_rate * gradients[[i, j]];
            }
        }

        Ok(())
    }

    /// Update synaptic importance
    fn update_synaptic_importance(
        &mut self,
        data: &Array1<f32>,
        target: &Array1<f32>,
    ) -> Result<()> {
        let xi = self.config.regularization_config.si_config.xi;
        let damping = self.config.regularization_config.si_config.damping;

        // Compute gradient contribution
        let gradients = self.compute_gradients(data, target)?;

        // Update importance
        if self.synaptic_importance.is_empty() {
            self.synaptic_importance = Array2::zeros(gradients.dim());
        }

        let rows_to_update = gradients.nrows().min(self.synaptic_importance.nrows());
        let cols_to_update = gradients.ncols().min(self.synaptic_importance.ncols());

        for i in 0..rows_to_update {
            for j in 0..cols_to_update {
                self.synaptic_importance[[i, j]] =
                    damping * self.synaptic_importance[[i, j]] + xi * gradients[[i, j]].abs();
            }
        }

        Ok(())
    }

    /// Forward pass through the model
    fn forward_pass(&self, input: &Array1<f32>) -> Result<Array1<f32>> {
        if self.embeddings.is_empty() {
            return Ok(Array1::zeros(input.len()));
        }

        // Use current task's network column if progressive
        let network = if matches!(
            self.config.architecture_config.adaptation_method,
            ArchitectureAdaptation::Progressive
        ) {
            &self.network_columns[self.network_columns.len() - 1]
        } else {
            &self.embeddings
        };

        // Simple linear transformation
        let input_len = input.len().min(network.ncols());
        let output_len = network.nrows();
        let mut output = Array1::zeros(output_len);

        for i in 0..output_len {
            let mut sum = 0.0;
            for j in 0..input_len {
                sum += network[[i, j]] * input[j];
            }
            output[i] = sum.tanh(); // Apply activation
        }

        Ok(output)
    }

    /// Experience replay
    async fn experience_replay(&mut self) -> Result<()> {
        if self.episodic_memory.is_empty() {
            return Ok(());
        }

        let mut random = Random::default();
        let replay_batch_size = (self.config.replay_config.replay_ratio * 32.0) as usize;
        let batch_size = replay_batch_size.min(self.episodic_memory.len());

        for _ in 0..batch_size {
            let idx = random.random_range(0..self.episodic_memory.len());

            // Extract data before modifying entry to avoid borrow conflicts
            let (data, target) = {
                let entry = &self.episodic_memory[idx];
                (entry.data.clone(), entry.target.clone())
            };

            // Update access count after data extraction
            self.episodic_memory[idx].access_count += 1;

            // Replay this example
            let gradients = self.compute_gradients(&data, &target)?;
            let regularized_gradients = self.apply_regularization(gradients)?;
            self.update_parameters(regularized_gradients)?;
        }

        Ok(())
    }

    /// Generative replay
    async fn generative_replay(&mut self) -> Result<()> {
        if let Some(ref generator) = self.generator {
            let _replay_batch_size = (self.config.replay_config.replay_ratio * 32.0) as usize;
            let _generator_clone = generator.clone();

            // Drop the immutable borrow by exiting the if let scope
        }

        if let Some(generator) = self.generator.clone() {
            let replay_batch_size = (self.config.replay_config.replay_ratio * 32.0) as usize;

            for _ in 0..replay_batch_size {
                // Generate synthetic data
                let mut random = Random::default();
                let noise = Array1::from_shape_fn(generator.ncols(), |_| random.random::<f32>());
                let generated_data = generator.dot(&noise);

                // Generate corresponding target (simplified)
                let generated_target = generated_data.mapv(|x| x.tanh());

                // Train on generated data
                let gradients = self.compute_gradients(&generated_data, &generated_target)?;
                let regularized_gradients = self.apply_regularization(gradients)?;
                self.update_parameters(regularized_gradients)?;
            }
        }

        Ok(())
    }

    /// Compute EWC state for current task
    fn compute_ewc_state(&mut self) -> Result<()> {
        if let Some(ref current_task) = self.current_task {
            let _dimensions = self.config.base_config.dimensions;
            let mut fisher_information = Array2::zeros(self.embeddings.dim());

            // Compute Fisher Information Matrix
            for entry in &self.episodic_memory {
                if entry.task_id == current_task.task_id {
                    let gradients = self.compute_gradients(&entry.data, &entry.target)?;

                    let rows_to_update = gradients.nrows().min(fisher_information.nrows());
                    let cols_to_update = gradients.ncols().min(fisher_information.ncols());

                    for i in 0..rows_to_update {
                        for j in 0..cols_to_update {
                            fisher_information[[i, j]] += gradients[[i, j]] * gradients[[i, j]];
                        }
                    }
                }
            }

            // Normalize by number of examples
            let task_examples = self
                .episodic_memory
                .iter()
                .filter(|entry| entry.task_id == current_task.task_id)
                .count() as f32;

            if task_examples > 0.0 {
                fisher_information /= task_examples;
            }

            let ewc_state = EWCState {
                fisher_information,
                optimal_parameters: self.embeddings.clone(),
                task_id: current_task.task_id.clone(),
                importance: 1.0,
            };

            self.ewc_states.push(ewc_state);
        }

        Ok(())
    }

    /// Add new network column for progressive learning
    fn add_network_column(&mut self) -> Result<()> {
        let dimensions = self.config.base_config.dimensions;
        let mut random = Random::default();
        let new_column =
            Array2::from_shape_fn((dimensions, dimensions), |_| random.random::<f32>() * 0.1);
        self.network_columns.push(new_column);

        // Add lateral connections to previous columns
        if self.network_columns.len() > 1 {
            let lateral_connection = Array2::from_shape_fn((dimensions, dimensions), |_| {
                random.random::<f32>()
                    * self
                        .config
                        .architecture_config
                        .progressive_config
                        .lateral_strength
            });
            self.lateral_connections.push(lateral_connection);
        }

        Ok(())
    }

    /// Generate task embedding
    fn generate_task_embedding(&self, task_id: &str) -> Result<Array1<f32>> {
        let dimensions = self.config.base_config.dimensions;
        let mut task_embedding = Array1::zeros(dimensions);

        // Simple hash-based task embedding
        for (i, byte) in task_id.bytes().enumerate() {
            if i >= dimensions {
                break;
            }
            task_embedding[i] = (byte as f32) / 255.0;
        }

        Ok(task_embedding)
    }

    /// Consolidate memory
    fn consolidate_memory(&mut self) -> Result<()> {
        if !self.config.memory_config.consolidation.enabled {
            return Ok(());
        }

        let mut random = Random::default();
        let strength = self.config.memory_config.consolidation.strength;

        // Strengthen important memories
        for entry in &mut self.episodic_memory {
            entry.importance *= 1.0 + strength * entry.access_count as f32;
        }

        // Simulate memory consolidation through replay
        let consolidation_steps = 100;
        for _ in 0..consolidation_steps {
            if !self.episodic_memory.is_empty() {
                let idx = random.random_range(0..self.episodic_memory.len());
                let entry = &self.episodic_memory[idx];

                // Weak replay for consolidation
                let weak_gradients = self.compute_gradients(&entry.data, &entry.target)? * 0.1;
                self.update_parameters(weak_gradients)?;
            }
        }

        Ok(())
    }

    /// Get task performance statistics
    pub fn get_task_performance(&self) -> HashMap<String, f32> {
        let mut performance = HashMap::new();

        for task in &self.task_history {
            performance.insert(task.task_id.clone(), task.performance);
        }

        if let Some(ref current_task) = self.current_task {
            performance.insert(current_task.task_id.clone(), current_task.performance);
        }

        performance
    }

    /// Evaluate catastrophic forgetting
    pub fn evaluate_forgetting(&self) -> f32 {
        if self.task_history.len() < 2 {
            return 0.0;
        }

        let mut total_forgetting = 0.0;
        let mut task_count = 0;

        for (i, task) in self.task_history.iter().enumerate() {
            if i > 0 {
                let initial_performance = task.performance;
                let current_performance = self.evaluate_task_performance(&task.task_id);
                let forgetting = initial_performance - current_performance;
                total_forgetting += forgetting;
                task_count += 1;
            }
        }

        if task_count > 0 {
            total_forgetting / task_count as f32
        } else {
            0.0
        }
    }

    /// Evaluate performance on specific task
    fn evaluate_task_performance(&self, _task_id: &str) -> f32 {
        // Simplified evaluation - would need proper test set
        let mut random = Random::default();
        random.random::<f32>() * 0.1 + 0.8
    }

    /// Euclidean distance between two vectors
    fn euclidean_distance(&self, a: &Array1<f32>, b: &Array1<f32>) -> f32 {
        let min_len = a.len().min(b.len());
        let mut sum = 0.0;

        for i in 0..min_len {
            let diff = a[i] - b[i];
            sum += diff * diff;
        }

        sum.sqrt()
    }
}

#[async_trait]
impl EmbeddingModel for ContinualLearningModel {
    fn config(&self) -> &ModelConfig {
        &self.config.base_config
    }

    fn model_id(&self) -> &Uuid {
        &self.model_id
    }

    fn model_type(&self) -> &'static str {
        "ContinualLearningModel"
    }

    fn add_triple(&mut self, triple: Triple) -> Result<()> {
        let subject_str = triple.subject.iri.clone();
        let predicate_str = triple.predicate.iri.clone();
        let object_str = triple.object.iri.clone();

        // Add entities
        let next_entity_id = self.entities.len();
        self.entities.entry(subject_str).or_insert(next_entity_id);
        let next_entity_id = self.entities.len();
        self.entities.entry(object_str).or_insert(next_entity_id);

        // Add relation
        let next_relation_id = self.relations.len();
        self.relations
            .entry(predicate_str)
            .or_insert(next_relation_id);

        Ok(())
    }

    async fn train(&mut self, epochs: Option<usize>) -> Result<TrainingStats> {
        let epochs = epochs.unwrap_or(self.config.base_config.max_epochs);
        let start_time = std::time::Instant::now();

        let mut loss_history = Vec::new();

        for epoch in 0..epochs {
            // Simulate continual learning training
            let mut random = Random::default();
            let epoch_loss = 0.1 * random.random::<f64>();
            loss_history.push(epoch_loss);

            // Simulate task switching
            if epoch % 5 == 0 && epoch > 0 {
                let task_num = epoch / 5;
                let task_id = format!("task_{task_num}");
                self.start_task(task_id, "training".to_string())?;
            }

            if epoch > 10 && epoch_loss < 1e-6 {
                break;
            }
        }

        let training_time = start_time.elapsed().as_secs_f64();
        let final_loss = loss_history.last().copied().unwrap_or(0.0);

        let stats = TrainingStats {
            epochs_completed: loss_history.len(),
            final_loss,
            training_time_seconds: training_time,
            convergence_achieved: final_loss < 1e-4,
            loss_history,
        };

        self.training_stats = Some(stats.clone());
        self.is_trained = true;

        Ok(stats)
    }

    fn get_entity_embedding(&self, entity: &str) -> Result<Vector> {
        if let Some(&entity_id) = self.entities.get(entity) {
            if entity_id < self.embeddings.nrows() {
                let embedding = self.embeddings.row(entity_id);
                return Ok(Vector::new(embedding.to_vec()));
            }
        }
        Err(anyhow!("Entity not found: {}", entity))
    }

    fn get_relation_embedding(&self, relation: &str) -> Result<Vector> {
        if let Some(&relation_id) = self.relations.get(relation) {
            if relation_id < self.embeddings.nrows() {
                let embedding = self.embeddings.row(relation_id);
                return Ok(Vector::new(embedding.to_vec()));
            }
        }
        Err(anyhow!("Relation not found: {}", relation))
    }

    fn score_triple(&self, subject: &str, predicate: &str, object: &str) -> Result<f64> {
        let subject_emb = self.get_entity_embedding(subject)?;
        let predicate_emb = self.get_relation_embedding(predicate)?;
        let object_emb = self.get_entity_embedding(object)?;

        // Simple TransE-style scoring
        let subject_arr = Array1::from_vec(subject_emb.values);
        let predicate_arr = Array1::from_vec(predicate_emb.values);
        let object_arr = Array1::from_vec(object_emb.values);

        let predicted = &subject_arr + &predicate_arr;
        let diff = &predicted - &object_arr;
        let distance = diff.dot(&diff).sqrt();

        Ok(-distance as f64)
    }

    fn predict_objects(
        &self,
        subject: &str,
        predicate: &str,
        k: usize,
    ) -> Result<Vec<(String, f64)>> {
        let mut scores = Vec::new();

        for entity in self.entities.keys() {
            if entity != subject {
                let score = self.score_triple(subject, predicate, entity)?;
                scores.push((entity.clone(), score));
            }
        }

        scores.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        scores.truncate(k);

        Ok(scores)
    }

    fn predict_subjects(
        &self,
        predicate: &str,
        object: &str,
        k: usize,
    ) -> Result<Vec<(String, f64)>> {
        let mut scores = Vec::new();

        for entity in self.entities.keys() {
            if entity != object {
                let score = self.score_triple(entity, predicate, object)?;
                scores.push((entity.clone(), score));
            }
        }

        scores.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        scores.truncate(k);

        Ok(scores)
    }

    fn predict_relations(
        &self,
        subject: &str,
        object: &str,
        k: usize,
    ) -> Result<Vec<(String, f64)>> {
        let mut scores = Vec::new();

        for relation in self.relations.keys() {
            let score = self.score_triple(subject, relation, object)?;
            scores.push((relation.clone(), score));
        }

        scores.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        scores.truncate(k);

        Ok(scores)
    }

    fn get_entities(&self) -> Vec<String> {
        self.entities.keys().cloned().collect()
    }

    fn get_relations(&self) -> Vec<String> {
        self.relations.keys().cloned().collect()
    }

    fn get_stats(&self) -> crate::ModelStats {
        crate::ModelStats {
            num_entities: self.entities.len(),
            num_relations: self.relations.len(),
            num_triples: 0,
            dimensions: self.config.base_config.dimensions,
            is_trained: self.is_trained,
            model_type: self.model_type().to_string(),
            creation_time: Utc::now(),
            last_training_time: if self.is_trained {
                Some(Utc::now())
            } else {
                None
            },
        }
    }

    fn save(&self, _path: &str) -> Result<()> {
        Ok(())
    }

    fn load(&mut self, _path: &str) -> Result<()> {
        Ok(())
    }

    fn clear(&mut self) {
        self.entities.clear();
        self.relations.clear();
        self.embeddings = Array2::zeros((0, self.config.base_config.dimensions));
        self.episodic_memory.clear();
        self.semantic_memory.clear();
        self.ewc_states.clear();
        self.task_history.clear();
        self.current_task = None;
        self.examples_seen = 0;
        self.is_trained = false;
        self.training_stats = None;
    }

    fn is_trained(&self) -> bool {
        self.is_trained
    }

    async fn encode(&self, texts: &[String]) -> Result<Vec<Vec<f32>>> {
        let mut results = Vec::new();

        for text in texts {
            let mut embedding = vec![0.0f32; self.config.base_config.dimensions];
            for (i, c) in text.chars().enumerate() {
                if i >= self.config.base_config.dimensions {
                    break;
                }
                embedding[i] = (c as u8 as f32) / 255.0;
            }
            results.push(embedding);
        }

        Ok(results)
    }
}

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

    #[test]
    fn test_continual_learning_config_default() {
        let config = ContinualLearningConfig::default();
        assert!(matches!(
            config.memory_config.memory_type,
            MemoryType::EpisodicMemory
        ));
        assert_eq!(config.memory_config.memory_capacity, 10000);
    }

    #[test]
    fn test_task_info_creation() {
        let task = TaskInfo::new("task1".to_string(), "classification".to_string());
        assert_eq!(task.task_id, "task1");
        assert_eq!(task.task_type, "classification");
        assert_eq!(task.examples_seen, 0);
    }

    #[test]
    fn test_memory_entry_creation() {
        let data = Array1::from_vec(vec![1.0, 2.0, 3.0]);
        let target = Array1::from_vec(vec![0.0, 1.0]);
        let entry = MemoryEntry::new(data, target, "task1".to_string());

        assert_eq!(entry.task_id, "task1");
        assert_eq!(entry.importance, 1.0);
        assert_eq!(entry.access_count, 0);
    }

    #[test]
    fn test_continual_learning_model_creation() {
        let config = ContinualLearningConfig::default();
        let model = ContinualLearningModel::new(config);

        assert_eq!(model.entities.len(), 0);
        assert_eq!(model.examples_seen, 0);
        assert!(model.current_task.is_none());
    }

    #[tokio::test]
    async fn test_task_management() {
        let config = ContinualLearningConfig::default();
        let mut model = ContinualLearningModel::new(config);

        model
            .start_task("task1".to_string(), "test".to_string())
            .expect("should succeed");
        assert!(model.current_task.is_some());
        assert_eq!(
            model.current_task.as_ref().expect("should succeed").task_id,
            "task1"
        );

        model
            .start_task("task2".to_string(), "test".to_string())
            .expect("should succeed");
        assert_eq!(model.task_history.len(), 1);
        assert_eq!(
            model.current_task.as_ref().expect("should succeed").task_id,
            "task2"
        );
    }

    #[tokio::test]
    async fn test_add_example() {
        let config = ContinualLearningConfig {
            base_config: ModelConfig {
                dimensions: 3, // Match array size
                ..Default::default()
            },
            ..Default::default()
        };
        let mut model = ContinualLearningModel::new(config);

        model
            .start_task("task1".to_string(), "test".to_string())
            .expect("should succeed");

        let data = Array1::from_vec(vec![1.0, 2.0, 3.0]);
        let target = Array1::from_vec(vec![1.0, 2.0, 3.0]); // Match dimensions

        model
            .add_example(data, target, Some("task1".to_string()))
            .await
            .expect("should succeed");

        assert_eq!(model.examples_seen, 1);
        assert_eq!(model.episodic_memory.len(), 1);
        assert_eq!(
            model
                .current_task
                .as_ref()
                .expect("should succeed")
                .examples_seen,
            1
        );
    }

    #[tokio::test]
    async fn test_memory_management() {
        let config = ContinualLearningConfig {
            memory_config: MemoryConfig {
                memory_capacity: 3,
                update_strategy: MemoryUpdateStrategy::FIFO,
                ..Default::default()
            },
            ..Default::default()
        };

        let mut model = ContinualLearningModel::new(config);
        model
            .start_task("task1".to_string(), "test".to_string())
            .expect("should succeed");

        // Add more examples than capacity
        for i in 0..5 {
            let data = Array1::from_vec(vec![i as f32]);
            let target = Array1::from_vec(vec![i as f32]);
            model
                .add_example(data, target, Some("task1".to_string()))
                .await
                .expect("should succeed");
        }

        assert_eq!(model.episodic_memory.len(), 3); // Should be capped at capacity
    }

    #[tokio::test]
    async fn test_continual_training() {
        let config = ContinualLearningConfig {
            base_config: ModelConfig {
                dimensions: 3, // Use smaller dimensions for testing
                max_epochs: 10,
                ..Default::default()
            },
            ..Default::default()
        };
        let mut model = ContinualLearningModel::new(config);

        // Initialize the model's networks properly before training
        model
            .start_task("initial_task".to_string(), "training".to_string())
            .expect("should succeed");

        let stats = model.train(Some(10)).await.expect("should succeed");
        assert_eq!(stats.epochs_completed, 10);
        assert!(model.is_trained());
        assert!(!model.task_history.is_empty()); // Should have created tasks during training
    }

    #[test]
    fn test_forgetting_evaluation() {
        let config = ContinualLearningConfig::default();
        let model = ContinualLearningModel::new(config);

        let forgetting = model.evaluate_forgetting();
        assert_eq!(forgetting, 0.0); // No tasks, so no forgetting
    }

    #[test]
    fn test_ewc_state_creation() {
        let mut random = Random::default();
        let fisher = Array2::from_shape_fn((5, 5), |_| random.random::<f32>());
        let params = Array2::from_shape_fn((5, 5), |_| random.random::<f32>());

        let ewc_state = EWCState {
            fisher_information: fisher,
            optimal_parameters: params,
            task_id: "task1".to_string(),
            importance: 1.0,
        };

        assert_eq!(ewc_state.task_id, "task1");
        assert_eq!(ewc_state.importance, 1.0);
    }
}