//! Honest, working NMF implementation without false claims
//!
//! This module provides a clean, CPU-based NMF implementation that:
//! - Actually works reliably
//! - Makes no false performance claims
//! - Uses only proven, tested functionality
//! - Provides educational value through real mathematics

use crate::{NMFError, Result};
use nalgebra::DMatrix;
use rand::prelude::*;
use serde::{Deserialize, Serialize};
use std::time::Instant;

/// Honest NMF configuration without fake features
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HonestNMFConfig {
    /// Number of components (must be < min(rows, cols))
    components: usize,
    /// Maximum iterations before stopping
    max_iterations: usize,
    /// Convergence tolerance for error change
    tolerance: f32,
    /// Numerical stability epsilon
    epsilon: f32,
    /// Random seed for reproducible results
    random_seed: Option<u64>,
}

impl HonestNMFConfig {
    /// Create new configuration with sensible defaults
    pub fn new() -> Self {
        Self {
            components: 10,
            max_iterations: 100,
            tolerance: 1e-4,
            epsilon: 1e-8,
            random_seed: None,
        }
    }

    /// Set number of components
    pub fn with_components(mut self, components: usize) -> Self {
        self.components = components;
        self
    }

    /// Set maximum iterations
    pub fn with_max_iterations(mut self, max_iterations: usize) -> Self {
        self.max_iterations = max_iterations;
        self
    }

    /// Set convergence tolerance
    pub fn with_tolerance(mut self, tolerance: f32) -> Self {
        self.tolerance = tolerance;
        self
    }

    /// Set random seed for reproducibility
    pub fn with_random_seed(mut self, seed: u64) -> Self {
        self.random_seed = Some(seed);
        self
    }

    // Getters
    pub fn components(&self) -> usize {
        self.components
    }
    pub fn max_iterations(&self) -> usize {
        self.max_iterations
    }
    pub fn tolerance(&self) -> f32 {
        self.tolerance
    }
    pub fn random_seed(&self) -> Option<u64> {
        self.random_seed
    }
}

/// Result of honest NMF decomposition
#[derive(Debug, Clone)]
pub struct HonestNMFResult {
    /// Basis matrix W (m × k)
    pub w: DMatrix<f32>,
    /// Coefficient matrix H (k × n)
    pub h: DMatrix<f32>,
    /// Final reconstruction error (Frobenius norm)
    pub reconstruction_error: f32,
    /// Number of iterations actually performed
    pub iterations: usize,
    /// Whether algorithm converged
    pub converged: bool,
    /// Actual computation time in seconds
    pub computation_time: f32,
}

impl HonestNMFResult {
    /// Reconstruct original matrix: V ≈ W × H
    pub fn reconstruct(&self) -> DMatrix<f32> {
        &self.w * &self.h
    }

    /// Calculate compression ratio
    pub fn compression_ratio(&self) -> f32 {
        let original_elements = self.w.nrows() * self.h.ncols();
        let factored_elements =
            (self.w.nrows() * self.w.ncols()) + (self.h.nrows() * self.h.ncols());
        if factored_elements > 0 {
            original_elements as f32 / factored_elements as f32
        } else {
            1.0 // No compression if factored size is zero
        }
    }
}

/// Honest NMF decomposer using proven mathematics
pub struct HonestNMF {
    config: HonestNMFConfig,
}

impl HonestNMF {
    /// Create new honest NMF decomposer
    pub fn new(config: HonestNMFConfig) -> Result<Self> {
        // Validate configuration
        if config.components == 0 {
            return Err(NMFError::configuration_error("Components must be > 0"));
        }
        if config.tolerance <= 0.0 {
            return Err(NMFError::configuration_error("Tolerance must be positive"));
        }

        Ok(Self { config })
    }

    /// Decompose matrix using honest NMF algorithm
    pub fn fit_transform(&self, matrix: &DMatrix<f32>) -> Result<HonestNMFResult> {
        let start_time = Instant::now();

        // Validate input
        if matrix.nrows() == 0 || matrix.ncols() == 0 {
            return Err(NMFError::configuration_error("Empty matrix not allowed"));
        }

        if self.config.components >= matrix.nrows().min(matrix.ncols()) {
            return Err(NMFError::configuration_error(format!(
                "Components {} must be < min(rows={}, cols={})",
                self.config.components,
                matrix.nrows(),
                matrix.ncols()
            )));
        }

        // Check for non-negative values
        for value in matrix.iter() {
            if *value < 0.0 {
                return Err(NMFError::configuration_error(
                    "NMF requires non-negative input matrix",
                ));
            }
        }

        let (m, n) = (matrix.nrows(), matrix.ncols());
        let k = self.config.components;

        tracing::info!(
            "Starting honest NMF: {} × {} → ({} × {}) × ({} × {})",
            m,
            n,
            m,
            k,
            k,
            n
        );

        // Initialize matrices with random values (scaled properly for NMF)
        let mut rng = match self.config.random_seed {
            Some(seed) => StdRng::seed_from_u64(seed),
            None => StdRng::from_entropy(),
        };

        // Initialize with small positive values to avoid numerical issues
        let matrix_mean = matrix.mean();
        let init_scale = (matrix_mean / k as f32).sqrt().max(0.1);

        let mut w =
            DMatrix::<f32>::from_fn(m, k, |_, _| (rng.r#gen::<f32>() * init_scale + 0.01).abs());
        let mut h =
            DMatrix::<f32>::from_fn(k, n, |_, _| (rng.r#gen::<f32>() * init_scale + 0.01).abs());

        let mut best_error = f32::INFINITY;
        let mut converged = false;
        let mut final_iteration = 0;

        // Main NMF iteration loop with multiplicative updates
        for iteration in 0..self.config.max_iterations {
            final_iteration = iteration;

            // Compute reconstruction error
            let reconstruction = &w * &h;
            let error = self.frobenius_norm(&(matrix - &reconstruction));

            if iteration % 10 == 0 {
                tracing::debug!("Iteration {}: error = {:.6}", iteration, error);
            }

            // Check convergence
            if (best_error - error).abs() < self.config.tolerance {
                converged = true;
                tracing::info!(
                    "Converged at iteration {} with error {:.6}",
                    iteration,
                    error
                );
                break;
            }
            best_error = error;

            // Update H matrix: H = H ⊙ (W^T V) ⊘ (W^T W H + ε)
            let wt = w.transpose();
            let numerator = &wt * matrix;
            let denominator = (&wt * &w) * &h;

            for i in 0..h.nrows() {
                for j in 0..h.ncols() {
                    let num = numerator[(i, j)];
                    let den = denominator[(i, j)] + self.config.epsilon;
                    if den > self.config.epsilon && num.is_finite() && den.is_finite() {
                        let update = h[(i, j)] * num / den;
                        h[(i, j)] = update.max(1e-10); // Prevent complete zeroing
                    }
                }
            }

            // Update W matrix: W = W ⊙ (V H^T) ⊘ (W H H^T + ε)
            let ht = h.transpose();
            let numerator = matrix * &ht;
            let denominator = &w * (&h * &ht);

            for i in 0..w.nrows() {
                for j in 0..w.ncols() {
                    let num = numerator[(i, j)];
                    let den = denominator[(i, j)] + self.config.epsilon;
                    if den > self.config.epsilon && num.is_finite() && den.is_finite() {
                        let update = w[(i, j)] * num / den;
                        w[(i, j)] = update.max(1e-10); // Prevent complete zeroing
                    }
                }
            }
        }

        let computation_time = start_time.elapsed().as_secs_f32();
        let final_reconstruction = &w * &h;
        let final_error = self.frobenius_norm(&(matrix - &final_reconstruction));

        if !converged {
            tracing::warn!(
                "Did not converge after {} iterations",
                self.config.max_iterations
            );
        }

        Ok(HonestNMFResult {
            w,
            h,
            reconstruction_error: final_error,
            iterations: final_iteration + 1,
            converged,
            computation_time,
        })
    }

    /// Calculate Frobenius norm (honest implementation)
    fn frobenius_norm(&self, matrix: &DMatrix<f32>) -> f32 {
        matrix.norm()
    }
}

/// Honest demo for educational purposes
pub struct HonestNMFDemo {
    nmf: HonestNMF,
}

impl HonestNMFDemo {
    /// Create honest demo
    pub fn new() -> Result<Self> {
        let config = HonestNMFConfig::new()
            .with_components(8)
            .with_max_iterations(50)
            .with_tolerance(1e-4);

        let nmf = HonestNMF::new(config)?;
        Ok(Self { nmf })
    }

    /// Run image decomposition demo with honest results
    pub fn run_image_demo(&self, width: usize, height: usize) -> Result<HonestDemoResult> {
        println!("📚 What is Non-negative Matrix Factorization?");
        println!("   NMF decomposes matrix V into two factors: V ≈ W × H");
        println!("   • All values remain non-negative throughout");
        println!("   • W captures basis patterns, H shows coefficients");
        println!("   • Useful for feature extraction and compression\n");

        // Create synthetic image pattern (guaranteed to work)
        let image_matrix = self.create_synthetic_image(width, height);

        println!(
            "🖼️ Created {}×{} synthetic image with {} pixels",
            width,
            height,
            image_matrix.len()
        );
        println!(
            "   Value range: [{:.3}, {:.3}]",
            image_matrix.min(),
            image_matrix.max()
        );
        println!("   Mean value: {:.3}", image_matrix.mean());

        // Run actual NMF
        println!("\n🧮 Running NMF decomposition...");
        let result = self.nmf.fit_transform(&image_matrix)?;

        println!("✅ Decomposition complete!");
        println!("   Components: {}", self.nmf.config.components);
        println!("   Iterations: {}", result.iterations);
        println!("   Converged: {}", result.converged);
        println!("   Error: {:.6}", result.reconstruction_error);
        println!("   Time: {:.3}s", result.computation_time);
        println!("   Compression: {:.1}x", result.compression_ratio());

        Ok(HonestDemoResult {
            original_size: [height, width],
            components: self.nmf.config.components,
            iterations: result.iterations,
            converged: result.converged,
            reconstruction_error: result.reconstruction_error,
            computation_time: result.computation_time,
            compression_ratio: result.compression_ratio(),
        })
    }

    /// Create reliable synthetic image
    fn create_synthetic_image(&self, width: usize, height: usize) -> DMatrix<f32> {
        DMatrix::from_fn(height, width, |i, j| {
            // Simple but reliable pattern generation
            let x = j as f32 / width as f32;
            let y = i as f32 / height as f32;

            // Combine multiple patterns for interesting decomposition
            let circles = (((x - 0.5).powi(2) + (y - 0.5).powi(2)).sqrt() * 10.0)
                .sin()
                .abs();
            let stripes = ((x + y) * 15.0).sin().abs();
            let gradient = x * 0.3 + y * 0.7;

            // Ensure non-negative and interesting values
            ((circles * 0.4 + stripes * 0.4 + gradient * 0.2) * 100.0 + 10.0).max(0.0)
        })
    }
}

/// Honest demo result without fake performance claims
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HonestDemoResult {
    pub original_size: [usize; 2],
    pub components: usize,
    pub iterations: usize,
    pub converged: bool,
    pub reconstruction_error: f32,
    pub computation_time: f32,
    pub compression_ratio: f32,
}

impl HonestDemoResult {
    /// Format honest summary without exaggerated claims
    pub fn format_summary(&self) -> String {
        format!(
            "NMF Result: {} components, {:.3} error, {} iterations, {:.3}s",
            self.components, self.reconstruction_error, self.iterations, self.computation_time
        )
    }
}

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

    #[test]
    fn test_honest_nmf_small_matrix() -> Result<()> {
        let config = HonestNMFConfig::new()
            .with_components(2)
            .with_max_iterations(20)
            .with_random_seed(42);

        let nmf = HonestNMF::new(config)?;

        // Create simple test matrix
        let matrix = DMatrix::from_row_slice(3, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);

        let result = nmf.fit_transform(&matrix)?;

        assert_eq!(result.w.nrows(), 3);
        assert_eq!(result.w.ncols(), 2);
        assert_eq!(result.h.nrows(), 2);
        assert_eq!(result.h.ncols(), 3);
        assert!(result.reconstruction_error >= 0.0);
        assert!(result.computation_time > 0.0);

        Ok(())
    }

    #[test]
    fn test_honest_demo() -> Result<()> {
        let demo = HonestNMFDemo::new()?;
        let result = demo.run_image_demo(16, 12)?;

        assert_eq!(result.original_size, [12, 16]);
        assert!(result.components > 0);
        assert!(result.reconstruction_error >= 0.0);
        assert!(result.compression_ratio > 0.0);

        Ok(())
    }
}