oxirs_embed/

real_time_optimization.rs

//! Real-time optimization system for knowledge graph embeddings
//!
//! This module provides dynamic optimization capabilities that adapt in real-time
//! to improve embedding quality, training efficiency, and inference performance.
//! Features include adaptive learning rates, dynamic architecture optimization,
//! online learning, and intelligent resource management.

use crate::EmbeddingModel;
use anyhow::Result;
use scirs2_core::random::{Random, RngExt};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tokio::time::sleep;
use tracing::info;

/// Real-time optimization engine that continuously improves model performance
pub struct RealTimeOptimizer {
    /// Configuration for optimization
    config: OptimizationConfig,
    /// Performance monitoring system
    performance_monitor: PerformanceMonitor,
    /// Adaptive learning rate scheduler
    learning_rate_scheduler: AdaptiveLearningRateScheduler,
    /// Dynamic architecture optimizer
    architecture_optimizer: DynamicArchitectureOptimizer,
    /// Online learning manager
    online_learning_manager: OnlineLearningManager,
    /// Resource allocation optimizer
    resource_optimizer: ResourceOptimizer,
    /// Optimization history
    optimization_history: OptimizationHistory,
}

/// Configuration for real-time optimization
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationConfig {
    /// Enable adaptive learning rate optimization
    pub enable_adaptive_lr: bool,
    /// Enable dynamic architecture optimization
    pub enable_architecture_opt: bool,
    /// Enable online learning
    pub enable_online_learning: bool,
    /// Enable resource optimization
    pub enable_resource_opt: bool,
    /// Optimization frequency (in seconds)
    pub optimization_frequency: u64,
    /// Performance window size for moving averages
    pub performance_window_size: usize,
    /// Minimum improvement threshold to apply changes
    pub improvement_threshold: f32,
    /// Maximum learning rate adjustment factor
    pub max_lr_adjustment: f32,
    /// Architecture mutation probability
    pub architecture_mutation_prob: f32,
    /// Online learning batch size
    pub online_batch_size: usize,
    /// Resource optimization sensitivity
    pub resource_sensitivity: f32,
}

impl Default for OptimizationConfig {
    fn default() -> Self {
        Self {
            enable_adaptive_lr: true,
            enable_architecture_opt: true,
            enable_online_learning: true,
            enable_resource_opt: true,
            optimization_frequency: 30, // 30 seconds
            performance_window_size: 100,
            improvement_threshold: 0.001,
            max_lr_adjustment: 2.0,
            architecture_mutation_prob: 0.1,
            online_batch_size: 32,
            resource_sensitivity: 0.5,
        }
    }
}

/// Performance monitoring system
pub struct PerformanceMonitor {
    /// Performance metrics history
    metrics_history: Arc<Mutex<VecDeque<PerformanceMetrics>>>,
    /// Current performance baseline
    current_baseline: Arc<Mutex<PerformanceMetrics>>,
    /// Performance tracking window
    window_size: usize,
}

/// Performance metrics tracked by the system
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceMetrics {
    /// Timestamp of measurement
    pub timestamp: chrono::DateTime<chrono::Utc>,
    /// Training loss
    pub training_loss: f32,
    /// Validation accuracy
    pub validation_accuracy: f32,
    /// Inference latency (milliseconds)
    pub inference_latency: f32,
    /// Memory usage (MB)
    pub memory_usage: f32,
    /// GPU utilization (percentage)
    pub gpu_utilization: f32,
    /// Throughput (samples per second)
    pub throughput: f32,
    /// Learning rate
    pub learning_rate: f32,
    /// Model complexity score
    pub model_complexity: f32,
}

impl Default for PerformanceMetrics {
    fn default() -> Self {
        Self {
            timestamp: chrono::Utc::now(),
            training_loss: 1.0,
            validation_accuracy: 0.5,
            inference_latency: 100.0,
            memory_usage: 1024.0,
            gpu_utilization: 50.0,
            throughput: 100.0,
            learning_rate: 0.001,
            model_complexity: 0.5,
        }
    }
}

/// Adaptive learning rate scheduler that adjusts based on performance
pub struct AdaptiveLearningRateScheduler {
    /// Current learning rate
    current_lr: f32,
    /// Base learning rate
    base_lr: f32,
    /// Learning rate adjustment history
    adjustment_history: VecDeque<LearningRateAdjustment>,
    /// Optimization strategy
    strategy: LearningRateStrategy,
}

#[derive(Debug, Clone)]
pub enum LearningRateStrategy {
    AdaptiveGradient,
    CyclicalLearningRate,
    WarmupCosineAnnealing,
    PerformanceBased,
    OneCycle,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LearningRateAdjustment {
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub old_lr: f32,
    pub new_lr: f32,
    pub reason: String,
    pub performance_before: f32,
    pub performance_after: Option<f32>,
}

impl AdaptiveLearningRateScheduler {
    pub fn new(base_lr: f32, strategy: LearningRateStrategy) -> Self {
        Self {
            current_lr: base_lr,
            base_lr,
            adjustment_history: VecDeque::new(),
            strategy,
        }
    }

    /// Adjust learning rate based on current performance
    pub fn adjust_learning_rate(
        &mut self,
        current_metrics: &PerformanceMetrics,
        recent_metrics: &[PerformanceMetrics],
    ) -> Result<f32> {
        let new_lr = match self.strategy {
            LearningRateStrategy::AdaptiveGradient => {
                self.adaptive_gradient_adjustment(current_metrics, recent_metrics)?
            }
            LearningRateStrategy::CyclicalLearningRate => {
                self.cyclical_lr_adjustment(current_metrics)?
            }
            LearningRateStrategy::WarmupCosineAnnealing => {
                self.warmup_cosine_adjustment(current_metrics)?
            }
            LearningRateStrategy::PerformanceBased => {
                self.performance_based_adjustment(current_metrics, recent_metrics)?
            }
            LearningRateStrategy::OneCycle => self.one_cycle_adjustment(current_metrics)?,
        };

        // Record adjustment
        self.record_adjustment(new_lr, "Adaptive adjustment".to_string(), current_metrics);

        self.current_lr = new_lr;
        Ok(new_lr)
    }

    fn adaptive_gradient_adjustment(
        &self,
        _current_metrics: &PerformanceMetrics,
        recent_metrics: &[PerformanceMetrics],
    ) -> Result<f32> {
        if recent_metrics.len() < 2 {
            return Ok(self.current_lr);
        }

        // Calculate gradient of loss over recent steps
        let loss_gradient = self.calculate_loss_gradient(recent_metrics);

        // Adjust learning rate based on gradient magnitude
        let adjustment_factor = if loss_gradient.abs() < 0.001 {
            1.1 // Increase LR if loss is plateauing
        } else if loss_gradient > 0.0 {
            0.9 // Decrease LR if loss is increasing
        } else {
            1.05 // Slightly increase LR if loss is decreasing
        };

        Ok(self.current_lr * adjustment_factor)
    }

    fn cyclical_lr_adjustment(&self, current_metrics: &PerformanceMetrics) -> Result<f32> {
        // Implement cyclical learning rate based on time
        let cycle_length = 1000; // steps
        let step = current_metrics.timestamp.timestamp() as f32;
        let cycle_position = (step % cycle_length as f32) / cycle_length as f32;

        let min_lr = self.base_lr * 0.1;
        let max_lr = self.base_lr * 10.0;

        let lr = min_lr
            + (max_lr - min_lr) * (1.0 + (cycle_position * 2.0 * std::f32::consts::PI).cos()) / 2.0;
        Ok(lr)
    }

    fn warmup_cosine_adjustment(&self, current_metrics: &PerformanceMetrics) -> Result<f32> {
        // Implement warmup followed by cosine annealing
        let warmup_steps = 1000.0;
        let total_steps = 10000.0;
        let step = current_metrics.timestamp.timestamp() as f32;

        if step < warmup_steps {
            // Linear warmup
            Ok(self.base_lr * step / warmup_steps)
        } else {
            // Cosine annealing
            let progress = (step - warmup_steps) / (total_steps - warmup_steps);
            let lr = self.base_lr * 0.5 * (1.0 + (progress * std::f32::consts::PI).cos());
            Ok(lr)
        }
    }

    fn performance_based_adjustment(
        &self,
        _current_metrics: &PerformanceMetrics,
        recent_metrics: &[PerformanceMetrics],
    ) -> Result<f32> {
        if recent_metrics.len() < 5 {
            return Ok(self.current_lr);
        }

        // Check if performance is improving
        let recent_losses: Vec<f32> = recent_metrics.iter().map(|m| m.training_loss).collect();

        let improving = self.is_performance_improving(&recent_losses);

        if improving {
            // Performance is improving, slightly increase LR
            Ok(self.current_lr * 1.02)
        } else {
            // Performance is stagnating, decrease LR
            Ok(self.current_lr * 0.95)
        }
    }

    fn one_cycle_adjustment(&self, current_metrics: &PerformanceMetrics) -> Result<f32> {
        // Implement one-cycle learning rate policy
        let cycle_length = 5000.0;
        let step = current_metrics.timestamp.timestamp() as f32;
        let cycle_position = step % cycle_length / cycle_length;

        let max_lr = self.base_lr * 10.0;

        if cycle_position < 0.3 {
            // Ascending phase
            let progress = cycle_position / 0.3;
            Ok(self.base_lr + (max_lr - self.base_lr) * progress)
        } else if cycle_position < 0.9 {
            // Descending phase
            let progress = (cycle_position - 0.3) / 0.6;
            Ok(max_lr - (max_lr - self.base_lr) * progress)
        } else {
            // Final annealing phase
            let progress = (cycle_position - 0.9) / 0.1;
            Ok(self.base_lr * (1.0 - 0.9 * progress))
        }
    }

    fn calculate_loss_gradient(&self, recent_metrics: &[PerformanceMetrics]) -> f32 {
        if recent_metrics.len() < 2 {
            return 0.0;
        }

        let recent_loss = recent_metrics[recent_metrics.len() - 1].training_loss;
        let previous_loss = recent_metrics[recent_metrics.len() - 2].training_loss;

        recent_loss - previous_loss
    }

    fn is_performance_improving(&self, recent_losses: &[f32]) -> bool {
        if recent_losses.len() < 3 {
            return false;
        }

        let recent_avg = recent_losses[recent_losses.len() - 3..].iter().sum::<f32>() / 3.0;
        let earlier_avg = recent_losses[0..3].iter().sum::<f32>() / 3.0;

        recent_avg < earlier_avg
    }

    fn record_adjustment(
        &mut self,
        new_lr: f32,
        reason: String,
        current_metrics: &PerformanceMetrics,
    ) {
        let adjustment = LearningRateAdjustment {
            timestamp: chrono::Utc::now(),
            old_lr: self.current_lr,
            new_lr,
            reason,
            performance_before: current_metrics.training_loss,
            performance_after: None,
        };

        self.adjustment_history.push_back(adjustment);

        // Keep only recent adjustments
        while self.adjustment_history.len() > 100 {
            self.adjustment_history.pop_front();
        }
    }
}

/// Dynamic architecture optimizer that adjusts model structure
pub struct DynamicArchitectureOptimizer {
    /// Current architecture configuration
    current_architecture: ArchitectureConfig,
    /// Architecture search history
    search_history: Vec<ArchitectureSearchResult>,
    /// Optimization strategy
    strategy: ArchitectureOptimizationStrategy,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchitectureConfig {
    /// Embedding dimensions
    pub embedding_dim: usize,
    /// Number of layers
    pub num_layers: usize,
    /// Hidden dimensions
    pub hidden_dims: Vec<usize>,
    /// Activation functions
    pub activations: Vec<String>,
    /// Dropout rates
    pub dropout_rates: Vec<f32>,
    /// Normalization types
    pub normalizations: Vec<String>,
}

#[derive(Debug, Clone)]
pub enum ArchitectureOptimizationStrategy {
    NeuralArchitectureSearch,
    GradientBasedSearch,
    EvolutionarySearch,
    HyperparameterOptimization,
    PruningAndGrowth,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchitectureSearchResult {
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub architecture: ArchitectureConfig,
    pub performance: f32,
    pub search_time: f32,
    pub validation_score: f32,
}

impl DynamicArchitectureOptimizer {
    pub fn new(
        initial_config: ArchitectureConfig,
        strategy: ArchitectureOptimizationStrategy,
    ) -> Self {
        Self {
            current_architecture: initial_config,
            search_history: Vec::new(),
            strategy,
        }
    }

    /// Optimize architecture based on current performance
    pub async fn optimize_architecture(
        &mut self,
        current_metrics: &PerformanceMetrics,
        model: &dyn EmbeddingModel,
    ) -> Result<ArchitectureConfig> {
        info!(
            "Starting architecture optimization with strategy: {:?}",
            self.strategy
        );

        let new_architecture = match self.strategy {
            ArchitectureOptimizationStrategy::NeuralArchitectureSearch => {
                self.neural_architecture_search(current_metrics, model)
                    .await?
            }
            ArchitectureOptimizationStrategy::GradientBasedSearch => {
                self.gradient_based_search(current_metrics, model).await?
            }
            ArchitectureOptimizationStrategy::EvolutionarySearch => {
                self.evolutionary_search(current_metrics, model).await?
            }
            ArchitectureOptimizationStrategy::HyperparameterOptimization => {
                self.hyperparameter_optimization(current_metrics, model)
                    .await?
            }
            ArchitectureOptimizationStrategy::PruningAndGrowth => {
                self.pruning_and_growth(current_metrics, model).await?
            }
        };

        // Evaluate new architecture
        let performance = self.evaluate_architecture(&new_architecture, model).await?;

        // Record search result
        self.record_search_result(new_architecture.clone(), performance);

        // Update current architecture if improvement is significant
        if performance > current_metrics.validation_accuracy + 0.01 {
            info!(
                "Architecture optimization successful: {:.3} -> {:.3}",
                current_metrics.validation_accuracy, performance
            );
            self.current_architecture = new_architecture.clone();
        }

        Ok(new_architecture)
    }

    async fn neural_architecture_search(
        &self,
        _current_metrics: &PerformanceMetrics,
        _model: &dyn EmbeddingModel,
    ) -> Result<ArchitectureConfig> {
        // Implement neural architecture search
        let mut new_config = self.current_architecture.clone();

        // Mutate embedding dimension
        let mut random = Random::default();
        if random.random::<f32>() < 0.3 {
            let adjustment = if random.random::<bool>() { 1.1 } else { 0.9 };
            new_config.embedding_dim =
                ((new_config.embedding_dim as f32 * adjustment) as usize).clamp(32, 1024);
        }

        // Mutate number of layers
        if random.random::<f32>() < 0.2 {
            new_config.num_layers = if random.random::<bool>() {
                (new_config.num_layers + 1).min(10)
            } else {
                (new_config.num_layers.saturating_sub(1)).max(1)
            };
        }

        // Mutate hidden dimensions
        for hidden_dim in &mut new_config.hidden_dims {
            if random.random::<f32>() < 0.2 {
                let adjustment = 0.8 + random.random::<f32>() * 0.4; // 0.8 to 1.2
                *hidden_dim = ((*hidden_dim as f32 * adjustment) as usize).clamp(16, 2048);
            }
        }

        Ok(new_config)
    }

    async fn gradient_based_search(
        &self,
        current_metrics: &PerformanceMetrics,
        _model: &dyn EmbeddingModel,
    ) -> Result<ArchitectureConfig> {
        // Implement gradient-based architecture search
        let mut new_config = self.current_architecture.clone();

        // Use gradient information to guide architecture changes
        // This is a simplified implementation
        if current_metrics.training_loss > 0.5 {
            // Increase model capacity
            new_config.embedding_dim = (new_config.embedding_dim as f32 * 1.1) as usize;
            new_config.num_layers = (new_config.num_layers + 1).min(8);
        } else if current_metrics.training_loss < 0.1 {
            // Reduce model complexity to prevent overfitting
            new_config.embedding_dim = (new_config.embedding_dim as f32 * 0.9) as usize;
            for dropout_rate in &mut new_config.dropout_rates {
                *dropout_rate = (*dropout_rate + 0.1).min(0.5);
            }
        }

        Ok(new_config)
    }

    async fn evolutionary_search(
        &self,
        _current_metrics: &PerformanceMetrics,
        model: &dyn EmbeddingModel,
    ) -> Result<ArchitectureConfig> {
        // Implement evolutionary architecture search
        let population = self.generate_architecture_population(5);

        // Evaluate population
        let mut fitness_scores = Vec::new();
        for config in &population {
            let fitness = self.evaluate_architecture(config, model).await?;
            fitness_scores.push(fitness);
        }

        // Select best configurations
        let mut indexed_scores: Vec<(usize, f32)> = fitness_scores
            .iter()
            .enumerate()
            .map(|(i, &s)| (i, s))
            .collect();
        indexed_scores.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));

        // Crossover and mutation
        let parent1 = &population[indexed_scores[0].0];
        let parent2 = &population[indexed_scores[1].0];
        let offspring = self.crossover_architectures(parent1, parent2);
        let mutated_offspring = self.mutate_architecture(offspring);

        Ok(mutated_offspring)
    }

    async fn hyperparameter_optimization(
        &self,
        _current_metrics: &PerformanceMetrics,
        _model: &dyn EmbeddingModel,
    ) -> Result<ArchitectureConfig> {
        // Implement hyperparameter optimization
        let mut new_config = self.current_architecture.clone();

        // Optimize dropout rates
        let mut random = Random::default();
        for dropout_rate in &mut new_config.dropout_rates {
            *dropout_rate = random.random::<f32>() * 0.5; // 0.0 to 0.5
        }

        // Optimize layer dimensions using Bayesian optimization principles
        for hidden_dim in &mut new_config.hidden_dims {
            let log_dim = (*hidden_dim as f32).ln();
            let noise = (random.random::<f32>() - 0.5) * 0.2;
            let new_log_dim = log_dim + noise;
            *hidden_dim = new_log_dim.exp() as usize;
        }

        Ok(new_config)
    }

    async fn pruning_and_growth(
        &self,
        current_metrics: &PerformanceMetrics,
        _model: &dyn EmbeddingModel,
    ) -> Result<ArchitectureConfig> {
        // Implement pruning and growth strategy
        let mut new_config = self.current_architecture.clone();

        // Prune if model is too complex
        if current_metrics.model_complexity > 0.8 {
            new_config.embedding_dim = (new_config.embedding_dim as f32 * 0.9) as usize;

            // Remove smallest hidden layers
            new_config.hidden_dims.sort();
            if new_config.hidden_dims.len() > 2 {
                new_config.hidden_dims.remove(0);
                new_config.num_layers = new_config.num_layers.saturating_sub(1);
            }
        }

        // Grow if model is underperforming
        if current_metrics.validation_accuracy < 0.6 {
            new_config.embedding_dim = (new_config.embedding_dim as f32 * 1.1) as usize;

            // Add new hidden layer
            if new_config.num_layers < 6 {
                let new_hidden_dim = new_config.embedding_dim / 2;
                new_config.hidden_dims.push(new_hidden_dim);
                new_config.num_layers += 1;
            }
        }

        Ok(new_config)
    }

    fn generate_architecture_population(&self, size: usize) -> Vec<ArchitectureConfig> {
        let mut population = Vec::new();

        for _ in 0..size {
            let mut config = self.current_architecture.clone();

            // Random mutations
            let mut random = Random::default();
            config.embedding_dim =
                (64..=512).step_by(32).collect::<Vec<_>>()[random.random_range(0..15)];
            config.num_layers = (1..=6).collect::<Vec<_>>()[random.random_range(0..6)];

            // Generate random hidden dimensions
            config.hidden_dims = (0..config.num_layers)
                .map(|_| (32..=1024).step_by(32).collect::<Vec<_>>()[random.random_range(0..31)])
                .collect();

            population.push(config);
        }

        population
    }

    fn crossover_architectures(
        &self,
        parent1: &ArchitectureConfig,
        parent2: &ArchitectureConfig,
    ) -> ArchitectureConfig {
        let mut random = Random::default();
        ArchitectureConfig {
            embedding_dim: if random.random::<bool>() {
                parent1.embedding_dim
            } else {
                parent2.embedding_dim
            },
            num_layers: if random.random::<bool>() {
                parent1.num_layers
            } else {
                parent2.num_layers
            },
            hidden_dims: parent1
                .hidden_dims
                .iter()
                .zip(parent2.hidden_dims.iter())
                .map(|(d1, d2)| if random.random::<bool>() { *d1 } else { *d2 })
                .collect(),
            activations: if random.random::<bool>() {
                parent1.activations.clone()
            } else {
                parent2.activations.clone()
            },
            dropout_rates: parent1
                .dropout_rates
                .iter()
                .zip(parent2.dropout_rates.iter())
                .map(|(r1, r2)| if random.random::<bool>() { *r1 } else { *r2 })
                .collect(),
            normalizations: if random.random::<bool>() {
                parent1.normalizations.clone()
            } else {
                parent2.normalizations.clone()
            },
        }
    }

    fn mutate_architecture(&self, mut config: ArchitectureConfig) -> ArchitectureConfig {
        let mut random = Random::default();
        // Mutate embedding dimension
        if random.random::<f32>() < 0.3 {
            config.embedding_dim =
                (config.embedding_dim as f32 * (0.8 + random.random::<f32>() * 0.4)) as usize;
        }

        // Mutate hidden dimensions
        for hidden_dim in &mut config.hidden_dims {
            if random.random::<f32>() < 0.2 {
                *hidden_dim = (*hidden_dim as f32 * (0.8 + random.random::<f32>() * 0.4)) as usize;
            }
        }

        // Mutate dropout rates
        for dropout_rate in &mut config.dropout_rates {
            if random.random::<f32>() < 0.2 {
                *dropout_rate =
                    (*dropout_rate + (random.random::<f32>() - 0.5) * 0.1).clamp(0.0, 0.5);
            }
        }

        config
    }

    async fn evaluate_architecture(
        &self,
        config: &ArchitectureConfig,
        _model: &dyn EmbeddingModel,
    ) -> Result<f32> {
        // Evaluate architecture performance
        // This would involve training a model with the given architecture
        // For now, return a simplified score based on architecture properties

        let complexity_penalty =
            (config.embedding_dim as f32 / 512.0 + config.num_layers as f32 / 6.0) * 0.1;
        let mut random = Random::default();
        let base_score = 0.7 + random.random::<f32>() * 0.2;

        Ok((base_score - complexity_penalty).clamp(0.0, 1.0))
    }

    fn record_search_result(&mut self, architecture: ArchitectureConfig, performance: f32) {
        let result = ArchitectureSearchResult {
            timestamp: chrono::Utc::now(),
            architecture,
            performance,
            search_time: 10.0, // Simplified
            validation_score: performance,
        };

        self.search_history.push(result);

        // Keep only recent results
        if self.search_history.len() > 50 {
            self.search_history.remove(0);
        }
    }
}

/// Online learning manager for continuous model updates
pub struct OnlineLearningManager {
    /// Configuration for online learning
    config: OnlineLearningConfig,
    /// Incoming data buffer
    data_buffer: VecDeque<OnlineDataPoint>,
    /// Model update scheduler
    update_scheduler: UpdateScheduler,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OnlineLearningConfig {
    /// Buffer size for incoming data
    pub buffer_size: usize,
    /// Update frequency (number of samples)
    pub update_frequency: usize,
    /// Learning rate decay for online updates
    pub online_lr_decay: f32,
    /// Catastrophic forgetting prevention
    pub enable_ewc: bool,
    /// Experience replay buffer size
    pub replay_buffer_size: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OnlineDataPoint {
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub entity1: String,
    pub entity2: String,
    pub relation: String,
    pub score: f32,
    pub source: String,
}

#[derive(Debug, Clone)]
pub enum UpdateScheduler {
    Fixed(usize),        // Update every N samples
    Adaptive(f32),       // Update based on performance degradation
    Timebased(Duration), // Update every X minutes
    TriggerBased,        // Update when triggered by external events
}

/// Average cosine-distance threshold above which an incremental update's
/// effect on touched entity embeddings is flagged as model drift.
const DRIFT_COSINE_DISTANCE_THRESHOLD: f32 = 0.15;

impl OnlineLearningManager {
    pub fn new(config: OnlineLearningConfig) -> Self {
        Self {
            config,
            data_buffer: VecDeque::new(),
            update_scheduler: UpdateScheduler::Fixed(100),
        }
    }

    /// Add new data point for online learning
    pub async fn add_data_point(&mut self, data_point: OnlineDataPoint) -> Result<()> {
        self.data_buffer.push_back(data_point);

        // Maintain buffer size
        while self.data_buffer.len() > self.config.buffer_size {
            self.data_buffer.pop_front();
        }

        // Check if update is needed
        if self.should_update() {
            self.trigger_update().await?;
        }

        Ok(())
    }

    /// Perform online model update
    pub async fn perform_online_update<M: EmbeddingModel>(
        &mut self,
        model: &mut M,
    ) -> Result<OnlineUpdateResult> {
        info!(
            "Performing online model update with {} data points",
            self.data_buffer.len()
        );

        let start_time = Instant::now();

        // Prepare training batch
        let batch_data: Vec<_> = self
            .data_buffer
            .iter()
            .take(self.config.update_frequency)
            .cloned()
            .collect();

        // Update model with new data
        let update_stats = self.update_model_incremental(model, &batch_data).await?;

        let update_time = start_time.elapsed();

        // Clear processed data from buffer
        for _ in 0..batch_data.len().min(self.data_buffer.len()) {
            self.data_buffer.pop_front();
        }

        Ok(OnlineUpdateResult {
            timestamp: chrono::Utc::now(),
            samples_processed: batch_data.len(),
            update_time: update_time.as_secs_f32(),
            performance_improvement: update_stats.performance_improvement,
            memory_usage: update_stats.memory_usage,
            model_drift_detected: update_stats.drift_detected,
        })
    }

    fn should_update(&self) -> bool {
        match self.update_scheduler {
            UpdateScheduler::Fixed(n) => self.data_buffer.len() >= n,
            UpdateScheduler::Adaptive(_threshold) => {
                // Check if performance has degraded beyond threshold
                // Simplified: update if buffer is half full
                self.data_buffer.len() >= self.config.buffer_size / 2
            }
            UpdateScheduler::Timebased(_duration) => {
                // Check if enough time has passed since last update
                // Simplified: always true for demo
                true
            }
            UpdateScheduler::TriggerBased => {
                // Update only when explicitly triggered
                false
            }
        }
    }

    async fn trigger_update(&mut self) -> Result<()> {
        info!("Triggering online learning update");
        // This would trigger the actual model update process
        Ok(())
    }

    /// Score how well the model currently predicts the observed feedback in
    /// `batch`, as `1 - mean_absolute_error` between the model's own
    /// `score_triple` output and the feedback's recorded `score`, clamped to
    /// `[0, 1]`. Data points the model cannot score (e.g. unknown entities)
    /// are skipped rather than counted as zero error.
    fn evaluate_batch_performance<M: EmbeddingModel>(model: &M, batch: &[OnlineDataPoint]) -> f32 {
        let mut total_error = 0.0f32;
        let mut scored = 0usize;
        for point in batch {
            if let Ok(predicted) =
                model.score_triple(&point.entity1, &point.relation, &point.entity2)
            {
                total_error += (predicted as f32 - point.score).abs();
                scored += 1;
            }
        }
        if scored == 0 {
            return 0.0;
        }
        (1.0 - (total_error / scored as f32)).clamp(0.0, 1.0)
    }

    /// Snapshot the entity embeddings touched by `batch`, keyed by entity IRI,
    /// for later drift comparison. Entities the model does not yet know about
    /// are skipped.
    fn snapshot_embeddings<M: EmbeddingModel>(
        model: &M,
        batch: &[OnlineDataPoint],
    ) -> HashMap<String, Vec<f32>> {
        let mut snapshot = HashMap::new();
        for point in batch {
            for entity in [&point.entity1, &point.entity2] {
                if snapshot.contains_key(entity) {
                    continue;
                }
                if let Ok(embedding) = model.get_entity_embedding(entity) {
                    snapshot.insert(entity.clone(), embedding.values);
                }
            }
        }
        snapshot
    }

    /// Detect model drift by comparing entity embeddings before and after the
    /// incremental update: if the average cosine distance for entities present
    /// in both snapshots exceeds [`DRIFT_COSINE_DISTANCE_THRESHOLD`], the
    /// update moved the representation more than expected for a small
    /// incremental batch, which we flag as drift.
    fn detect_embedding_drift(
        before: &HashMap<String, Vec<f32>>,
        after: &HashMap<String, Vec<f32>>,
    ) -> bool {
        let mut total_distance = 0.0f32;
        let mut compared = 0usize;

        for (entity, before_vec) in before {
            let Some(after_vec) = after.get(entity) else {
                continue;
            };
            if before_vec.len() != after_vec.len() || before_vec.is_empty() {
                continue;
            }
            let dot: f32 = before_vec
                .iter()
                .zip(after_vec.iter())
                .map(|(a, b)| a * b)
                .sum();
            let norm_before = before_vec.iter().map(|v| v * v).sum::<f32>().sqrt();
            let norm_after = after_vec.iter().map(|v| v * v).sum::<f32>().sqrt();
            if norm_before <= f32::EPSILON || norm_after <= f32::EPSILON {
                continue;
            }
            let cosine_similarity = (dot / (norm_before * norm_after)).clamp(-1.0, 1.0);
            total_distance += 1.0 - cosine_similarity;
            compared += 1;
        }

        if compared == 0 {
            return false;
        }
        (total_distance / compared as f32) > DRIFT_COSINE_DISTANCE_THRESHOLD
    }

    async fn update_model_incremental<M: EmbeddingModel>(
        &self,
        model: &mut M,
        batch_data: &[OnlineDataPoint],
    ) -> Result<IncrementalUpdateStats> {
        if batch_data.is_empty() {
            return Ok(IncrementalUpdateStats {
                performance_improvement: 0.0,
                memory_usage: 0.0,
                drift_detected: false,
            });
        }

        // Measure predictive performance before the update against the model's
        // current parameters.
        let performance_before = Self::evaluate_batch_performance(model, batch_data);
        let embeddings_before = Self::snapshot_embeddings(model, batch_data);

        // Feed the new observations into the model and retrain incrementally.
        for point in batch_data {
            let subject = crate::NamedNode::new(&point.entity1)?;
            let predicate = crate::NamedNode::new(&point.relation)?;
            let object = crate::NamedNode::new(&point.entity2)?;
            model.add_triple(crate::Triple::new(subject, predicate, object))?;
        }

        // A single incremental epoch over the freshly added batch, keeping the
        // update cheap enough to run on every scheduled trigger.
        model.train(Some(1)).await?;

        let performance_after = Self::evaluate_batch_performance(model, batch_data);
        let embeddings_after = Self::snapshot_embeddings(model, batch_data);
        let drift_detected = Self::detect_embedding_drift(&embeddings_before, &embeddings_after);

        // Estimate the model's resident embedding memory footprint (KB) from
        // its actual entity/relation counts and dimensionality.
        let stats = model.get_stats();
        let memory_usage = ((stats.num_entities + stats.num_relations)
            * stats.dimensions
            * std::mem::size_of::<f32>()) as f32
            / 1024.0;

        Ok(IncrementalUpdateStats {
            performance_improvement: performance_after - performance_before,
            memory_usage,
            drift_detected,
        })
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OnlineUpdateResult {
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub samples_processed: usize,
    pub update_time: f32,
    pub performance_improvement: f32,
    pub memory_usage: f32,
    pub model_drift_detected: bool,
}

#[derive(Debug, Clone)]
struct IncrementalUpdateStats {
    performance_improvement: f32,
    memory_usage: f32,
    drift_detected: bool,
}

/// Resource optimization system
pub struct ResourceOptimizer {
    /// Current resource allocation
    current_allocation: ResourceAllocation,
    /// Resource usage history
    usage_history: VecDeque<ResourceUsage>,
    /// Optimization strategy
    strategy: ResourceOptimizationStrategy,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceAllocation {
    /// CPU cores allocated
    pub cpu_cores: usize,
    /// Memory allocation (MB)
    pub memory_mb: usize,
    /// GPU memory allocation (MB)
    pub gpu_memory_mb: usize,
    /// Batch size for training/inference
    pub batch_size: usize,
    /// Number of worker threads
    pub num_workers: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResourceUsage {
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub cpu_utilization: f32,
    pub memory_usage: f32,
    pub gpu_utilization: f32,
    pub gpu_memory_usage: f32,
    pub throughput: f32,
    pub latency: f32,
}

#[derive(Debug, Clone)]
pub enum ResourceOptimizationStrategy {
    ThroughputMaximization,
    LatencyMinimization,
    MemoryEfficiency,
    EnergyEfficiency,
    CostOptimization,
}

impl ResourceOptimizer {
    pub fn new(
        initial_allocation: ResourceAllocation,
        strategy: ResourceOptimizationStrategy,
    ) -> Self {
        Self {
            current_allocation: initial_allocation,
            usage_history: VecDeque::new(),
            strategy,
        }
    }

    /// Optimize resource allocation based on current usage patterns
    pub async fn optimize_resources(
        &mut self,
        current_usage: &ResourceUsage,
        performance_metrics: &PerformanceMetrics,
    ) -> Result<ResourceAllocation> {
        self.usage_history.push_back(current_usage.clone());

        // Keep only recent history
        while self.usage_history.len() > 100 {
            self.usage_history.pop_front();
        }

        let new_allocation = match self.strategy {
            ResourceOptimizationStrategy::ThroughputMaximization => {
                self.optimize_for_throughput(current_usage, performance_metrics)
                    .await?
            }
            ResourceOptimizationStrategy::LatencyMinimization => {
                self.optimize_for_latency(current_usage, performance_metrics)
                    .await?
            }
            ResourceOptimizationStrategy::MemoryEfficiency => {
                self.optimize_for_memory(current_usage, performance_metrics)
                    .await?
            }
            ResourceOptimizationStrategy::EnergyEfficiency => {
                self.optimize_for_energy(current_usage, performance_metrics)
                    .await?
            }
            ResourceOptimizationStrategy::CostOptimization => {
                self.optimize_for_cost(current_usage, performance_metrics)
                    .await?
            }
        };

        self.current_allocation = new_allocation.clone();
        Ok(new_allocation)
    }

    async fn optimize_for_throughput(
        &self,
        current_usage: &ResourceUsage,
        _performance_metrics: &PerformanceMetrics,
    ) -> Result<ResourceAllocation> {
        let mut new_allocation = self.current_allocation.clone();

        // Increase batch size if GPU utilization is low
        if current_usage.gpu_utilization < 0.7 {
            new_allocation.batch_size = (new_allocation.batch_size as f32 * 1.2) as usize;
        }

        // Increase workers if CPU utilization is low
        if current_usage.cpu_utilization < 0.6 {
            new_allocation.num_workers = (new_allocation.num_workers + 1).min(16);
        }

        Ok(new_allocation)
    }

    async fn optimize_for_latency(
        &self,
        current_usage: &ResourceUsage,
        performance_metrics: &PerformanceMetrics,
    ) -> Result<ResourceAllocation> {
        let mut new_allocation = self.current_allocation.clone();

        // Reduce batch size for lower latency
        if performance_metrics.inference_latency > 100.0 {
            new_allocation.batch_size = (new_allocation.batch_size as f32 * 0.8) as usize;
        }

        // Increase memory allocation for caching
        if current_usage.memory_usage < 0.8 {
            new_allocation.memory_mb = (new_allocation.memory_mb as f32 * 1.1) as usize;
        }

        Ok(new_allocation)
    }

    async fn optimize_for_memory(
        &self,
        current_usage: &ResourceUsage,
        _performance_metrics: &PerformanceMetrics,
    ) -> Result<ResourceAllocation> {
        let mut new_allocation = self.current_allocation.clone();

        // Reduce batch size if memory usage is high
        if current_usage.memory_usage > 0.9 {
            new_allocation.batch_size = (new_allocation.batch_size as f32 * 0.8) as usize;
        }

        // Reduce GPU memory allocation if not fully utilized
        if current_usage.gpu_memory_usage < 0.7 {
            new_allocation.gpu_memory_mb = (new_allocation.gpu_memory_mb as f32 * 0.9) as usize;
        }

        Ok(new_allocation)
    }

    async fn optimize_for_energy(
        &self,
        current_usage: &ResourceUsage,
        _performance_metrics: &PerformanceMetrics,
    ) -> Result<ResourceAllocation> {
        let mut new_allocation = self.current_allocation.clone();

        // Reduce CPU cores if utilization is low
        if current_usage.cpu_utilization < 0.5 {
            new_allocation.cpu_cores = (new_allocation.cpu_cores.saturating_sub(1)).max(1);
        }

        // Optimize batch size for energy efficiency
        let optimal_batch_size = self.calculate_energy_optimal_batch_size(current_usage);
        new_allocation.batch_size = optimal_batch_size;

        Ok(new_allocation)
    }

    async fn optimize_for_cost(
        &self,
        current_usage: &ResourceUsage,
        performance_metrics: &PerformanceMetrics,
    ) -> Result<ResourceAllocation> {
        let mut new_allocation = self.current_allocation.clone();

        // Balance performance and resource usage for cost optimization
        let efficiency_ratio = performance_metrics.throughput / current_usage.gpu_utilization;

        if efficiency_ratio < 100.0 {
            // Poor efficiency, reduce resource allocation
            new_allocation.gpu_memory_mb = (new_allocation.gpu_memory_mb as f32 * 0.9) as usize;
            new_allocation.batch_size = (new_allocation.batch_size as f32 * 0.9) as usize;
        } else {
            // Good efficiency, can afford slight increase
            new_allocation.batch_size = (new_allocation.batch_size as f32 * 1.05) as usize;
        }

        Ok(new_allocation)
    }

    fn calculate_energy_optimal_batch_size(&self, current_usage: &ResourceUsage) -> usize {
        // Calculate optimal batch size for energy efficiency
        // This is a simplified calculation
        let base_batch_size = self.current_allocation.batch_size;
        let utilization_factor =
            (current_usage.gpu_utilization + current_usage.cpu_utilization) / 2.0;

        (base_batch_size as f32 * utilization_factor * 1.2) as usize
    }
}

/// Optimization history tracking
pub struct OptimizationHistory {
    /// Performance metrics over time
    performance_history: VecDeque<PerformanceMetrics>,
    /// Optimization actions taken
    optimization_actions: VecDeque<OptimizationAction>,
    /// Resource usage history
    resource_history: VecDeque<ResourceUsage>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationAction {
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub action_type: String,
    pub parameters: HashMap<String, f32>,
    pub expected_improvement: f32,
    pub actual_improvement: Option<f32>,
}

impl Default for OptimizationHistory {
    fn default() -> Self {
        Self::new()
    }
}

impl OptimizationHistory {
    pub fn new() -> Self {
        Self {
            performance_history: VecDeque::new(),
            optimization_actions: VecDeque::new(),
            resource_history: VecDeque::new(),
        }
    }

    /// Record optimization action
    pub fn record_optimization_action(&mut self, action: OptimizationAction) {
        self.optimization_actions.push_back(action);

        // Keep only recent actions
        while self.optimization_actions.len() > 200 {
            self.optimization_actions.pop_front();
        }
    }

    /// Get optimization summary
    pub fn get_optimization_summary(&self) -> OptimizationSummary {
        OptimizationSummary {
            total_optimizations: self.optimization_actions.len(),
            successful_optimizations: self
                .optimization_actions
                .iter()
                .filter(|a| a.actual_improvement.unwrap_or(0.0) > 0.0)
                .count(),
            average_improvement: self
                .optimization_actions
                .iter()
                .filter_map(|a| a.actual_improvement)
                .sum::<f32>()
                / self.optimization_actions.len() as f32,
            optimization_efficiency: self.calculate_optimization_efficiency(),
        }
    }

    fn calculate_optimization_efficiency(&self) -> f32 {
        let successful = self
            .optimization_actions
            .iter()
            .filter(|a| a.actual_improvement.unwrap_or(0.0) > 0.0)
            .count() as f32;

        successful / self.optimization_actions.len() as f32
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationSummary {
    pub total_optimizations: usize,
    pub successful_optimizations: usize,
    pub average_improvement: f32,
    pub optimization_efficiency: f32,
}

impl RealTimeOptimizer {
    /// Create a new real-time optimizer
    pub fn new(config: OptimizationConfig) -> Self {
        let performance_monitor = PerformanceMonitor {
            metrics_history: Arc::new(Mutex::new(VecDeque::new())),
            current_baseline: Arc::new(Mutex::new(PerformanceMetrics::default())),
            window_size: config.performance_window_size,
        };

        let learning_rate_scheduler =
            AdaptiveLearningRateScheduler::new(0.001, LearningRateStrategy::PerformanceBased);

        let architecture_optimizer = DynamicArchitectureOptimizer::new(
            ArchitectureConfig {
                embedding_dim: 256,
                num_layers: 3,
                hidden_dims: vec![512, 256, 128],
                activations: vec![
                    "relu".to_string(),
                    "relu".to_string(),
                    "sigmoid".to_string(),
                ],
                dropout_rates: vec![0.1, 0.2, 0.1],
                normalizations: vec!["batch".to_string(), "batch".to_string(), "none".to_string()],
            },
            ArchitectureOptimizationStrategy::EvolutionarySearch,
        );

        let online_learning_manager = OnlineLearningManager::new(OnlineLearningConfig {
            buffer_size: 1000,
            update_frequency: 100,
            online_lr_decay: 0.999,
            enable_ewc: true,
            replay_buffer_size: 5000,
        });

        let resource_optimizer = ResourceOptimizer::new(
            ResourceAllocation {
                cpu_cores: 4,
                memory_mb: 8192,
                gpu_memory_mb: 4096,
                batch_size: 32,
                num_workers: 4,
            },
            ResourceOptimizationStrategy::ThroughputMaximization,
        );

        Self {
            config,
            performance_monitor,
            learning_rate_scheduler,
            architecture_optimizer,
            online_learning_manager,
            resource_optimizer,
            optimization_history: OptimizationHistory::new(),
        }
    }

    /// Start real-time optimization loop
    pub async fn start_optimization_loop<M: EmbeddingModel + Send + Clone + 'static>(
        &mut self,
        model: Arc<Mutex<M>>,
    ) -> Result<()> {
        info!("Starting real-time optimization loop");

        loop {
            // Collect current performance metrics
            let current_metrics = self.collect_performance_metrics(&model).await?;

            // Record metrics
            self.record_performance_metrics(current_metrics.clone());

            // Perform optimizations based on configuration
            if self.config.enable_adaptive_lr {
                self.optimize_learning_rate(&current_metrics).await?;
            }

            if self.config.enable_architecture_opt {
                self.optimize_architecture::<M>(&current_metrics, &model)
                    .await?;
            }

            if self.config.enable_resource_opt {
                self.optimize_resources(&current_metrics).await?;
            }

            // Sleep until next optimization cycle
            sleep(Duration::from_secs(self.config.optimization_frequency)).await;
        }
    }

    async fn collect_performance_metrics<M: EmbeddingModel>(
        &self,
        _model: &Arc<Mutex<M>>,
    ) -> Result<PerformanceMetrics> {
        // Collect current performance metrics from the model
        // This is a simplified implementation
        let mut random = Random::default();
        Ok(PerformanceMetrics {
            timestamp: chrono::Utc::now(),
            training_loss: 0.5 + random.random::<f32>() * 0.3,
            validation_accuracy: 0.7 + random.random::<f32>() * 0.2,
            inference_latency: 50.0 + random.random::<f32>() * 100.0,
            memory_usage: 2048.0 + random.random::<f32>() * 1024.0,
            gpu_utilization: 60.0 + random.random::<f32>() * 30.0,
            throughput: 80.0 + random.random::<f32>() * 40.0,
            learning_rate: self.learning_rate_scheduler.current_lr,
            model_complexity: 0.5 + random.random::<f32>() * 0.3,
        })
    }

    fn record_performance_metrics(&mut self, metrics: PerformanceMetrics) {
        let mut history = self
            .performance_monitor
            .metrics_history
            .lock()
            .expect("lock should not be poisoned");
        history.push_back(metrics.clone());

        // Maintain window size
        while history.len() > self.performance_monitor.window_size {
            history.pop_front();
        }

        // Update baseline
        *self
            .performance_monitor
            .current_baseline
            .lock()
            .expect("lock should not be poisoned") = metrics;
    }

    async fn optimize_learning_rate(&mut self, current_metrics: &PerformanceMetrics) -> Result<()> {
        let history = self
            .performance_monitor
            .metrics_history
            .lock()
            .expect("lock should not be poisoned");
        let recent_metrics: Vec<_> = history.iter().cloned().collect();
        drop(history);

        let new_lr = self
            .learning_rate_scheduler
            .adjust_learning_rate(current_metrics, &recent_metrics)?;

        info!(
            "Learning rate adjusted: {:.6} -> {:.6}",
            current_metrics.learning_rate, new_lr
        );

        Ok(())
    }

    async fn optimize_architecture<M: EmbeddingModel + Clone + Send + Sync>(
        &mut self,
        current_metrics: &PerformanceMetrics,
        model: &Arc<Mutex<M>>,
    ) -> Result<()> {
        // Note: This method needs refactoring to avoid holding mutex across await
        // For now, we'll allow this warning as it may require architectural changes
        let cloned_model = {
            let model_guard = model.lock().expect("lock should not be poisoned");
            (*model_guard).clone()
        };
        let new_architecture = self
            .architecture_optimizer
            .optimize_architecture(current_metrics, &cloned_model)
            .await?;

        info!(
            "Architecture optimization completed: {:?}",
            new_architecture
        );

        Ok(())
    }

    async fn optimize_resources(&mut self, current_metrics: &PerformanceMetrics) -> Result<()> {
        let mut random = Random::default();
        let current_usage = ResourceUsage {
            timestamp: chrono::Utc::now(),
            cpu_utilization: 60.0 + random.random::<f32>() * 30.0,
            memory_usage: current_metrics.memory_usage / 8192.0,
            gpu_utilization: current_metrics.gpu_utilization / 100.0,
            gpu_memory_usage: 0.7 + random.random::<f32>() * 0.2,
            throughput: current_metrics.throughput,
            latency: current_metrics.inference_latency,
        };

        let new_allocation = self
            .resource_optimizer
            .optimize_resources(&current_usage, current_metrics)
            .await?;

        info!("Resource allocation optimized: {:?}", new_allocation);

        Ok(())
    }

    /// Get optimization summary
    pub fn get_optimization_summary(&self) -> OptimizationSummary {
        self.optimization_history.get_optimization_summary()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::models::TransE;
    use crate::ModelConfig;

    fn sample_config() -> OnlineLearningConfig {
        OnlineLearningConfig {
            buffer_size: 100,
            update_frequency: 10,
            online_lr_decay: 0.99,
            enable_ewc: false,
            replay_buffer_size: 50,
        }
    }

    fn sample_data_point(entity1: &str, entity2: &str) -> OnlineDataPoint {
        OnlineDataPoint {
            timestamp: chrono::Utc::now(),
            entity1: entity1.to_string(),
            entity2: entity2.to_string(),
            relation: "knows".to_string(),
            score: 0.8,
            source: "test".to_string(),
        }
    }

    /// Regression test for the P1 finding: `update_model_incremental` (via
    /// `perform_online_update`) must actually train the model and compute
    /// real performance/drift signals, instead of sleeping and returning
    /// fabricated random numbers.
    #[tokio::test]
    async fn test_perform_online_update_trains_model_and_reports_real_stats() {
        let mut model = TransE::new(ModelConfig::default().with_dimensions(8));
        model
            .add_triple(crate::Triple::new(
                crate::NamedNode::new("alice").expect("valid"),
                crate::NamedNode::new("knows").expect("valid"),
                crate::NamedNode::new("bob").expect("valid"),
            ))
            .expect("add_triple should succeed");
        model
            .train(Some(1))
            .await
            .expect("initial train should succeed");

        let mut manager = OnlineLearningManager::new(sample_config());
        manager
            .add_data_point(sample_data_point("alice", "bob"))
            .await
            .expect("add_data_point should succeed");

        let result = manager
            .perform_online_update(&mut model)
            .await
            .expect("online update should succeed");

        assert_eq!(result.samples_processed, 1);
        // The model must have actually learned the new triple.
        assert!(model.get_entities().contains(&"alice".to_string()));
        assert!(model.get_entities().contains(&"bob".to_string()));
        // memory_usage is derived from real model stats (entities/relations ×
        // dimensions), so it must be positive once the model has content.
        assert!(
            result.memory_usage > 0.0,
            "memory_usage = {}",
            result.memory_usage
        );
    }

    #[tokio::test]
    async fn test_update_model_incremental_empty_batch_is_a_real_no_op() {
        let mut model = TransE::new(ModelConfig::default().with_dimensions(8));
        let manager = OnlineLearningManager::new(sample_config());

        let stats = manager
            .update_model_incremental(&mut model, &[])
            .await
            .expect("empty batch should succeed as a no-op");

        assert_eq!(stats.performance_improvement, 0.0);
        assert_eq!(stats.memory_usage, 0.0);
        assert!(!stats.drift_detected);
    }
}