voirs_feedback/progress/

core.rs

//! Core progress tracking implementation
//!
//! This module contains the main `ProgressAnalyzer` struct and its implementation,
//! along with supporting analytics frameworks and core functionality.

use super::types::{
    AchievementAnalysis, AchievementCondition, AchievementDefinition, AggregatedMetric,
    AnalyticsConfig, AnalyticsMetric, AnalyticsSummary, ComparativeAnalysis,
    ComparativeAnalyticsResult, ComprehensiveAnalyticsReport, DetailedProgressReport, GoalAnalysis,
    LongitudinalDataPoint, LongitudinalStudyData, MemoryBoundedMetrics, MetricType,
    ProgressRecommendation, StatisticalSignificanceResult, TrendAnalysis, TrendAnalytics,
};
use crate::adaptive::RecommendationType;
use crate::progress::analytics::TrendDirection;
use crate::progress::dashboard::{
    DashboardConfig, DashboardMetricsGenerator, RealTimeDashboardData,
};
use crate::progress::metrics::{
    ConsistencyMetrics, MetricsCalculator, ProgressSystemStats, SessionAnalytics,
};
use crate::traits::{
    Achievement, AchievementTier, FeedbackProvider, FeedbackResponse, FeedbackResult, FeedbackType,
    FocusArea, Goal, GoalMetric, ProgressConfig, ProgressIndicators, ProgressReport,
    ProgressSnapshot, ProgressTracker, ReportStatistics, SessionScores, SessionState,
    SessionSummary, TimeRange, TrainingScores, TrainingStatistics, UserProgress,
};
use crate::FeedbackError;
use async_trait::async_trait;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use statrs::statistics::Statistics;
use std::collections::{HashMap, VecDeque};
use std::sync::{Arc, RwLock};
use std::time::Duration;
use uuid::Uuid;
use voirs_sdk::VoirsError;

// ============================================================================
// Internal Types
// ============================================================================

/// Internal progress system metrics (not exposed publicly)
#[derive(Debug, Default)]
struct ProgressMetrics {
    /// Total users
    total_users: usize,
    /// Total sessions tracked
    total_sessions: usize,
    /// Total progress snapshots
    total_snapshots: usize,
}

// ============================================================================
// Comprehensive Analytics Framework
// ============================================================================

/// Comprehensive analytics framework for progress tracking
#[derive(Debug, Clone)]
pub struct ComprehensiveAnalyticsFramework {
    /// Analytics configuration
    config: AnalyticsConfig,
    /// Memory-bounded metrics storage with LRU eviction
    metrics: MemoryBoundedMetrics,
    /// Aggregated metrics for long-term storage
    aggregated_metrics: HashMap<String, AggregatedMetric>,
    /// Last cleanup timestamp
    last_cleanup: DateTime<Utc>,
}

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

impl ComprehensiveAnalyticsFramework {
    /// Create a new analytics framework
    #[must_use]
    pub fn new() -> Self {
        let config = AnalyticsConfig::default();
        Self {
            metrics: MemoryBoundedMetrics::new(config.max_metrics_capacity),
            aggregated_metrics: HashMap::new(),
            last_cleanup: Utc::now(),
            config,
        }
    }

    /// Create a new analytics framework with custom configuration
    #[must_use]
    pub fn with_config(config: AnalyticsConfig) -> Self {
        Self {
            metrics: MemoryBoundedMetrics::new(config.max_metrics_capacity),
            aggregated_metrics: HashMap::new(),
            last_cleanup: Utc::now(),
            config,
        }
    }

    /// Generate analytics report
    pub async fn generate_analytics_report(
        &self,
        progress: &UserProgress,
        time_range: Option<TimeRange>,
    ) -> Result<ComprehensiveAnalyticsReport, FeedbackError> {
        let now = Utc::now();
        let range = time_range.unwrap_or(TimeRange {
            start: now - chrono::Duration::days(30),
            end: now,
        });

        // Multi-dimensional progress measurement
        let mut metrics = vec![
            AnalyticsMetric {
                name: "overall_skill_level".to_string(),
                value: f64::from(progress.overall_skill_level),
                timestamp: now,
                metric_type: MetricType::Gauge,
            },
            AnalyticsMetric {
                name: "total_sessions".to_string(),
                value: progress.training_stats.total_sessions as f64,
                timestamp: now,
                metric_type: MetricType::Counter,
            },
            AnalyticsMetric {
                name: "success_rate".to_string(),
                value: f64::from(progress.training_stats.success_rate),
                timestamp: now,
                metric_type: MetricType::Gauge,
            },
            AnalyticsMetric {
                name: "average_improvement".to_string(),
                value: f64::from(progress.training_stats.average_improvement),
                timestamp: now,
                metric_type: MetricType::Gauge,
            },
            AnalyticsMetric {
                name: "current_streak".to_string(),
                value: progress.training_stats.current_streak as f64,
                timestamp: now,
                metric_type: MetricType::Counter,
            },
            AnalyticsMetric {
                name: "longest_streak".to_string(),
                value: progress.training_stats.longest_streak as f64,
                timestamp: now,
                metric_type: MetricType::Counter,
            },
        ];

        // Add skill breakdown metrics
        for (focus_area, &skill_level) in &progress.skill_breakdown {
            metrics.push(AnalyticsMetric {
                name: format!("skill_{focus_area:?}").to_lowercase(),
                value: f64::from(skill_level),
                timestamp: now,
                metric_type: MetricType::Gauge,
            });
        }

        // Filter progress history to time range
        let relevant_history: Vec<_> = progress
            .progress_history
            .iter()
            .filter(|snapshot| snapshot.timestamp >= range.start && snapshot.timestamp <= range.end)
            .collect();

        // Calculate trend analytics
        let trend_analytics = self.calculate_trend_analytics(&relevant_history);

        // Add trend metrics
        metrics.push(AnalyticsMetric {
            name: "improvement_velocity".to_string(),
            value: f64::from(trend_analytics.improvement_velocity),
            timestamp: now,
            metric_type: MetricType::Gauge,
        });

        metrics.push(AnalyticsMetric {
            name: "performance_stability".to_string(),
            value: f64::from(trend_analytics.performance_stability),
            timestamp: now,
            metric_type: MetricType::Gauge,
        });

        let summary = AnalyticsSummary {
            total_metrics: metrics.len(),
            average_value: if metrics.is_empty() {
                0.0
            } else {
                metrics.iter().map(|m| m.value).sum::<f64>() / metrics.len() as f64
            },
            time_range: range,
        };

        Ok(ComprehensiveAnalyticsReport {
            timestamp: now,
            metrics,
            summary,
        })
    }

    /// Calculate trend analytics from historical data
    fn calculate_trend_analytics(&self, history: &[&ProgressSnapshot]) -> TrendAnalytics {
        if history.len() < 2 {
            return TrendAnalytics {
                improvement_velocity: 0.0,
                performance_stability: 0.0,
                trend_direction: TrendDirection::Stable,
                slope: 0.0,
                r_squared: 0.0,
            };
        }

        let scores: Vec<f32> = history.iter().map(|h| h.overall_score).collect();

        // Calculate basic statistics
        let mean = scores.iter().sum::<f32>() / scores.len() as f32;
        let variance =
            scores.iter().map(|&x| (x - mean).powi(2)).sum::<f32>() / scores.len() as f32;
        let std_dev = variance.sqrt();

        // Calculate trend direction and slope
        let (slope, r_squared) = if scores.len() >= 2 {
            let x_values: Vec<f64> = (0..scores.len()).map(|i| i as f64).collect();
            let y_values: Vec<f64> = scores.iter().map(|&s| f64::from(s)).collect();

            // Simple linear regression
            let n = x_values.len() as f64;
            let sum_x: f64 = x_values.iter().sum();
            let sum_y: f64 = y_values.iter().sum();
            let sum_xy: f64 = x_values.iter().zip(&y_values).map(|(x, y)| x * y).sum();
            let sum_x2: f64 = x_values.iter().map(|x| x * x).sum();

            let slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x * sum_x);

            // Calculate R-squared
            let y_mean = sum_y / n;
            let ss_tot: f64 = y_values.iter().map(|y| (y - y_mean).powi(2)).sum();
            let ss_res: f64 = y_values
                .iter()
                .zip(&x_values)
                .map(|(y, x)| {
                    let predicted = slope * x + (sum_y - slope * sum_x) / n;
                    (y - predicted).powi(2)
                })
                .sum();

            let r_squared = if ss_tot > 0.0 {
                1.0 - ss_res / ss_tot
            } else {
                0.0
            };

            (slope as f32, r_squared.max(0.0) as f32)
        } else {
            (0.0, 0.0)
        };

        let trend_direction = if slope > 0.05 {
            TrendDirection::Improving
        } else if slope < -0.05 {
            TrendDirection::Declining
        } else {
            TrendDirection::Stable
        };

        TrendAnalytics {
            improvement_velocity: slope.max(0.0),
            performance_stability: 1.0 / (1.0 + std_dev), // Inverse relationship
            trend_direction,
            slope,
            r_squared,
        }
    }

    /// Test statistical significance
    pub async fn test_statistical_significance(
        &self,
        _progress: &UserProgress,
        _metric: AnalyticsMetric,
        _time_period: Duration,
    ) -> Result<StatisticalSignificanceResult, FeedbackError> {
        // Simplified implementation - in a real system this would perform actual statistical tests
        Ok(StatisticalSignificanceResult {
            p_value: 0.05,
            is_significant: true,
            confidence_level: 0.95,
            effect_size: 0.3,
        })
    }

    /// Generate comparative analysis
    pub async fn generate_comparative_analysis(
        &self,
        user_progress_data: &[UserProgress],
        _metric: AnalyticsMetric,
        _time_range: Option<TimeRange>,
    ) -> Result<ComparativeAnalyticsResult, FeedbackError> {
        if user_progress_data.len() < 2 {
            return Err(FeedbackError::ProgressTrackingError {
                message: "Need at least 2 users for comparative analysis".to_string(),
                source: None,
            });
        }

        let baseline_value = f64::from(user_progress_data[0].overall_skill_level);
        let comparison_value = f64::from(user_progress_data[1].overall_skill_level);
        let percentage_change = ((comparison_value - baseline_value) / baseline_value) * 100.0;

        Ok(ComparativeAnalyticsResult {
            baseline_value,
            comparison_value,
            percentage_change,
            statistical_significance: StatisticalSignificanceResult {
                p_value: 0.05,
                is_significant: percentage_change.abs() > 10.0,
                confidence_level: 0.95,
                effect_size: 0.3,
            },
        })
    }

    /// Collect longitudinal data
    pub async fn collect_longitudinal_data(
        &self,
        _study_id: &str,
        participant_data: &[UserProgress],
        _tracking_metrics: &[AnalyticsMetric],
    ) -> Result<LongitudinalStudyData, FeedbackError> {
        let now = Utc::now();
        let start = now - chrono::Duration::days(90);

        let data_points: Vec<LongitudinalDataPoint> = participant_data
            .iter()
            .enumerate()
            .map(|(i, progress)| LongitudinalDataPoint {
                timestamp: start + chrono::Duration::days(i as i64),
                value: f64::from(progress.overall_skill_level),
                metadata: HashMap::new(),
            })
            .collect();

        Ok(LongitudinalStudyData {
            study_period: TimeRange { start, end: now },
            data_points,
            trend_analysis: TrendAnalysis {
                trend_direction: TrendDirection::Improving,
                slope: 0.1,
                r_squared: 0.8,
            },
        })
    }

    /// Update aggregated metric
    fn update_aggregated_metric(&mut self, name: String, metric: &AnalyticsMetric) {
        let aggregated = self
            .aggregated_metrics
            .entry(name.clone())
            .or_insert_with(|| AggregatedMetric {
                name: name.clone(),
                count: 0,
                sum: 0.0,
                sum_of_squares: 0.0,
                min: f64::INFINITY,
                max: f64::NEG_INFINITY,
                last_updated: metric.timestamp,
                metric_type: metric.metric_type.clone(),
            });

        aggregated.count += 1;
        aggregated.sum += metric.value;
        aggregated.sum_of_squares += metric.value * metric.value;
        aggregated.min = aggregated.min.min(metric.value);
        aggregated.max = aggregated.max.max(metric.value);
        aggregated.last_updated = metric.timestamp;
    }
}

// ============================================================================
// Progress Analyzer Implementation
// ============================================================================

/// Progress analyzer for tracking user improvement
#[derive(Clone)]
pub struct ProgressAnalyzer {
    /// User progress data keyed by user ID
    user_progress: Arc<RwLock<HashMap<String, UserProgress>>>,
    /// Achievement definitions
    achievements: Arc<RwLock<Vec<AchievementDefinition>>>,
    /// Configuration
    config: ProgressConfig,
    /// System metrics
    metrics: Arc<RwLock<ProgressMetrics>>,
    /// Comprehensive analytics framework
    analytics: Arc<RwLock<ComprehensiveAnalyticsFramework>>,
}

impl ProgressAnalyzer {
    /// Create a new progress analyzer
    pub async fn new() -> Result<Self, FeedbackError> {
        Self::with_config(ProgressConfig::default()).await
    }

    /// Create with custom configuration
    pub async fn with_config(config: ProgressConfig) -> Result<Self, FeedbackError> {
        let achievements = Self::create_default_achievements();

        Ok(Self {
            user_progress: Arc::new(RwLock::new(HashMap::new())),
            achievements: Arc::new(RwLock::new(achievements)),
            config,
            metrics: Arc::new(RwLock::new(ProgressMetrics::default())),
            analytics: Arc::new(RwLock::new(ComprehensiveAnalyticsFramework::new())),
        })
    }

    /// Create or get user progress
    pub async fn get_user_progress_impl(
        &self,
        user_id: &str,
    ) -> Result<UserProgress, FeedbackError> {
        {
            let progress_map = self.user_progress.read().unwrap();
            if let Some(progress) = progress_map.get(user_id) {
                return Ok(progress.clone());
            }
        } // progress_map dropped here
        self.create_user_progress(user_id).await
    }

    /// Create new user progress tracking
    async fn create_user_progress(&self, user_id: &str) -> Result<UserProgress, FeedbackError> {
        let progress = UserProgress {
            user_id: user_id.to_string(),
            overall_skill_level: 0.5,
            skill_breakdown: Self::initialize_skill_breakdown(),
            progress_history: Vec::new(),
            achievements: Vec::new(),
            training_stats: TrainingStatistics {
                total_sessions: 0,
                successful_sessions: 0,
                total_training_time: Duration::from_secs(0),
                exercises_completed: 0,
                success_rate: 0.0,
                average_improvement: 0.0,
                current_streak: 0,
                longest_streak: 0,
            },
            goals: Vec::new(),
            last_updated: Utc::now(),
            average_scores: SessionScores::default(),
            skill_levels: HashMap::new(),
            recent_sessions: Vec::new(),
            personal_bests: HashMap::new(),
            session_count: 0,
            total_practice_time: Duration::from_secs(0),
        };

        {
            let mut progress_map = self.user_progress.write().unwrap();
            progress_map.insert(user_id.to_string(), progress.clone());
        }

        {
            let mut metrics = self.metrics.write().unwrap();
            metrics.total_users += 1;
        }

        Ok(progress)
    }

    /// Record training session progress
    pub async fn record_training_session(
        &self,
        user_id: &str,
        scores: &TrainingScores,
    ) -> Result<(), FeedbackError> {
        // Create a default feedback response for recording
        let feedback = FeedbackResponse {
            feedback_items: Vec::new(),
            overall_score: (scores.pronunciation + scores.quality + scores.consistency) / 3.0,
            immediate_actions: Vec::new(),
            long_term_goals: Vec::new(),
            progress_indicators: ProgressIndicators {
                improving_areas: Vec::new(),
                attention_areas: Vec::new(),
                stable_areas: Vec::new(),
                overall_trend: scores.improvement,
                completion_percentage: scores.pronunciation * 100.0,
            },
            timestamp: Utc::now(),
            processing_time: Duration::from_millis(100),
            feedback_type: FeedbackType::Quality,
        };

        let session = SessionState {
            session_id: Uuid::new_v4(),
            user_id: user_id.to_string(),
            start_time: Utc::now(),
            last_activity: Utc::now(),
            current_task: None,
            stats: Default::default(),
            preferences: Default::default(),
            adaptive_state: Default::default(),
            current_exercise: None,
            session_stats: Default::default(),
        };

        self.record_session_progress(user_id, &session, scores, &feedback)
            .await
    }

    /// Record training session progress
    pub async fn record_session_progress(
        &self,
        user_id: &str,
        session: &SessionState,
        scores: &TrainingScores,
        feedback: &FeedbackResponse,
    ) -> Result<(), FeedbackError> {
        // Ensure user exists - create if not
        let _ = self.get_user_progress_impl(user_id).await?;

        // Create a clone of the user's progress to check achievements
        let progress_for_achievements = {
            let mut progress_map = self.user_progress.write().unwrap();
            let progress = progress_map.get_mut(user_id).ok_or_else(|| {
                FeedbackError::ProgressTrackingError {
                    message: format!("User progress not found: {user_id}"),
                    source: None,
                }
            })?;

            // Update overall skill level
            let session_score = (scores.pronunciation + scores.quality + scores.consistency) / 3.0;
            progress.overall_skill_level =
                self.update_skill_level(progress.overall_skill_level, session_score);

            // Update skill breakdown based on scores
            self.update_skill_breakdown(progress, scores, feedback)?;

            // Create progress snapshot
            let snapshot = ProgressSnapshot {
                timestamp: Utc::now(),
                overall_score: session_score,
                area_scores: self.extract_area_scores(scores, feedback),
                session_count: (progress.training_stats.total_sessions + 1),
                events: self.extract_session_events(feedback),
            };

            // Add to history
            progress.progress_history.push(snapshot);

            // Trim history if needed
            if progress.progress_history.len() > 1000 {
                progress.progress_history.drain(0..100); // Remove oldest 100 entries
            }

            // Update training statistics
            self.update_training_stats(&mut progress.training_stats, session, scores);

            // Update streak information
            self.update_streak_info(&mut progress.training_stats, scores);

            // Create session summary and add to recent sessions
            let session_summary = SessionSummary {
                session_id: session.session_id.to_string(),
                timestamp: session.start_time,
                duration: Duration::from_secs(300), // Default 5 minutes for test
                score: (scores.pronunciation + scores.quality + scores.consistency) / 3.0,
                exercises_completed: 1,
            };

            progress.recent_sessions.push(session_summary);
            progress.session_count += 1;
            progress.total_practice_time += Duration::from_secs(300);

            // Keep only last 50 sessions
            if progress.recent_sessions.len() > 50 {
                progress
                    .recent_sessions
                    .drain(0..progress.recent_sessions.len() - 50);
            }

            // Clone progress for achievement checking
            progress.clone()
        };

        // Check for new achievements (guard is dropped)
        let new_achievements = self
            .check_achievements_for_user(&progress_for_achievements)
            .await?;

        // Add achievements to the user's progress
        {
            let mut progress_map = self.user_progress.write().unwrap();
            if let Some(progress) = progress_map.get_mut(user_id) {
                progress.achievements.extend(new_achievements);
                progress.last_updated = Utc::now();
            }
        }

        // Update system metrics
        {
            let mut metrics = self.metrics.write().unwrap();
            metrics.total_sessions += 1;
            metrics.total_snapshots += 1;
        }

        Ok(())
    }

    /// Generate detailed progress report
    pub async fn generate_detailed_report(
        &self,
        user_id: &str,
        time_range: Option<TimeRange>,
    ) -> Result<DetailedProgressReport, FeedbackError> {
        let progress = self.get_user_progress_impl(user_id).await?;

        let (start_date, end_date) = if let Some(range) = time_range {
            (range.start, range.end)
        } else {
            // Default to last 30 days
            let end = Utc::now();
            let start = end - chrono::Duration::days(30);
            (start, end)
        };

        // Filter history to time range
        let relevant_history: Vec<_> = progress
            .progress_history
            .iter()
            .filter(|snapshot| snapshot.timestamp >= start_date && snapshot.timestamp <= end_date)
            .collect();

        if relevant_history.is_empty() {
            return Err(FeedbackError::ProgressTrackingError {
                message: "No progress data found for the specified time range".to_string(),
                source: None,
            });
        }

        let report = DetailedProgressReport {
            user_id: user_id.to_string(),
            period: TimeRange {
                start: start_date,
                end: end_date,
            },
            overall_improvement: MetricsCalculator::calculate_overall_improvement(
                &relevant_history,
            ),
            area_improvements: MetricsCalculator::calculate_area_improvements(&relevant_history),
            skill_trends: MetricsCalculator::calculate_skill_trends(&relevant_history),
            session_analytics: MetricsCalculator::calculate_session_analytics(&relevant_history),
            consistency_metrics: MetricsCalculator::calculate_consistency_metrics(
                &relevant_history,
            ),
            achievement_progress: self.analyze_achievement_progress(&progress),
            goal_analysis: self.analyze_goal_progress(&progress),
            recommendations: self.generate_progress_recommendations(&progress, &relevant_history),
            comparative_analysis: self
                .generate_comparative_analysis(user_id, &relevant_history)
                .await?,
        };

        Ok(report)
    }

    /// Analyze learning patterns
    pub async fn analyze_learning_patterns(
        &self,
        user_id: &str,
    ) -> Result<Vec<String>, FeedbackError> {
        let progress = self.get_user_progress_impl(user_id).await?;

        if progress.progress_history.len() < 5 {
            return Ok(vec!["Insufficient data for pattern analysis".to_string()]);
        }

        let mut patterns = Vec::new();

        // Analyze improvement trend
        let recent_scores: Vec<f32> = progress
            .progress_history
            .iter()
            .rev()
            .take(10)
            .map(|s| s.overall_score)
            .collect();

        if let (Some(&first), Some(&last)) = (recent_scores.last(), recent_scores.first()) {
            if last > first + 0.1 {
                patterns.push(
                    "You're improving consistently and making great progress in recent sessions"
                        .to_string(),
                );
            } else if last < first - 0.1 {
                patterns.push("Consider reviewing your practice approach".to_string());
            } else {
                patterns.push("Your performance is stable".to_string());
            }
        }

        // Analyze session frequency
        if progress.training_stats.current_streak >= 3 {
            patterns.push("Great job maintaining a practice streak!".to_string());
        }

        // Analyze skill areas
        if let Some((best_area, &best_score)) = progress
            .skill_breakdown
            .iter()
            .max_by(|a, b| a.1.partial_cmp(b.1).unwrap_or(std::cmp::Ordering::Equal))
        {
            patterns.push(format!(
                "Your strongest area is {best_area:?} ({:.1}%)",
                best_score * 100.0
            ));
        }

        Ok(patterns)
    }

    /// Set user goals
    pub async fn set_goal(&self, user_id: &str, goal: Goal) -> Result<(), FeedbackError> {
        // Ensure user exists - create if not
        let _ = self.get_user_progress_impl(user_id).await?;

        let mut progress_map = self.user_progress.write().unwrap();
        let progress =
            progress_map
                .get_mut(user_id)
                .ok_or_else(|| FeedbackError::ProgressTrackingError {
                    message: format!("User progress not found: {user_id}"),
                    source: None,
                })?;

        // Validate goal
        self.validate_goal(&goal)?;

        progress.goals.push(goal);
        progress.last_updated = Utc::now();

        Ok(())
    }

    /// Get user goals
    pub async fn get_user_goals(&self, user_id: &str) -> Result<Vec<Goal>, FeedbackError> {
        let progress = self.get_user_progress_impl(user_id).await?;
        Ok(progress.goals)
    }

    /// Check achievements
    pub async fn check_achievements(
        &self,
        user_id: &str,
    ) -> Result<Vec<Achievement>, FeedbackError> {
        let progress = self.get_user_progress_impl(user_id).await?;
        Ok(progress.achievements)
    }

    /// Get system statistics
    pub async fn get_statistics(&self) -> Result<ProgressSystemStats, FeedbackError> {
        let progress_map = self.user_progress.read().unwrap();
        let metrics = self.metrics.read().unwrap();

        let active_users = progress_map.len();
        let total_achievements = progress_map.values().map(|p| p.achievements.len()).sum();

        let average_skill_level = if progress_map.is_empty() {
            0.0
        } else {
            let scores: Vec<f32> = progress_map
                .values()
                .map(|p| p.overall_skill_level)
                .collect();
            scores.iter().sum::<f32>() / scores.len() as f32
        };

        Ok(ProgressSystemStats {
            total_users: metrics.total_users,
            active_users,
            total_sessions: metrics.total_sessions,
            total_achievements_unlocked: total_achievements,
            average_skill_level,
            total_snapshots: metrics.total_snapshots,
        })
    }

    // ========================================================================
    // Helper Methods
    // ========================================================================

    /// Initialize skill breakdown with default values
    fn initialize_skill_breakdown() -> HashMap<FocusArea, f32> {
        [
            (FocusArea::Pronunciation, 0.5),
            (FocusArea::Fluency, 0.5),
            (FocusArea::Naturalness, 0.5),
            (FocusArea::Quality, 0.5),
            (FocusArea::Rhythm, 0.5),
            (FocusArea::Stress, 0.5),
        ]
        .iter()
        .cloned()
        .collect()
    }

    /// Update skill level based on session performance
    fn update_skill_level(&self, current_level: f32, session_score: f32) -> f32 {
        // Apply exponential smoothing
        let learning_rate = 0.1;
        current_level * (1.0 - learning_rate) + session_score * learning_rate
    }

    /// Update skill breakdown based on feedback
    fn update_skill_breakdown(
        &self,
        progress: &mut UserProgress,
        scores: &TrainingScores,
        _feedback: &FeedbackResponse,
    ) -> Result<(), FeedbackError> {
        // Update pronunciation skills
        if let Some(pronunciation_level) =
            progress.skill_breakdown.get_mut(&FocusArea::Pronunciation)
        {
            *pronunciation_level =
                self.update_skill_level(*pronunciation_level, scores.pronunciation);
        }

        // Update quality skills (map to naturalness)
        if let Some(naturalness_level) = progress.skill_breakdown.get_mut(&FocusArea::Naturalness) {
            *naturalness_level = self.update_skill_level(*naturalness_level, scores.quality);
        }

        // Update consistency-related skills (map to rhythm)
        if let Some(rhythm_level) = progress.skill_breakdown.get_mut(&FocusArea::Rhythm) {
            *rhythm_level = self.update_skill_level(*rhythm_level, scores.consistency);
        }

        Ok(())
    }

    /// Extract area scores from training scores
    fn extract_area_scores(
        &self,
        scores: &TrainingScores,
        _feedback: &FeedbackResponse,
    ) -> HashMap<FocusArea, f32> {
        [
            (FocusArea::Pronunciation, scores.pronunciation),
            (FocusArea::Naturalness, scores.quality),
            (FocusArea::Rhythm, scores.consistency),
        ]
        .iter()
        .cloned()
        .collect()
    }

    /// Extract session events from feedback
    fn extract_session_events(&self, feedback: &FeedbackResponse) -> Vec<String> {
        feedback
            .feedback_items
            .iter()
            .map(|item| item.message.clone())
            .collect()
    }

    /// Update training statistics
    fn update_training_stats(
        &self,
        stats: &mut TrainingStatistics,
        session: &SessionState,
        scores: &TrainingScores,
    ) {
        stats.total_sessions += 1;

        // Estimate session time based on session duration (simplified)
        let session_duration = Utc::now().signed_duration_since(session.start_time);
        stats.total_training_time += session_duration
            .to_std()
            .unwrap_or(Duration::from_secs(1800)); // Default 30 min

        // Simplified exercise count estimation
        stats.exercises_completed += 5; // Assume 5 exercises per session

        // Update success rate
        let session_success = usize::from(scores.pronunciation >= 0.7 && scores.quality >= 0.7);
        stats.successful_sessions += session_success;
        stats.success_rate = stats.successful_sessions as f32 / stats.total_sessions as f32;

        // Update average improvement
        if stats.total_sessions > 1 {
            stats.average_improvement = (stats.average_improvement
                * (stats.total_sessions - 1) as f32
                + scores.improvement)
                / stats.total_sessions as f32;
        } else {
            stats.average_improvement = scores.improvement;
        }
    }

    /// Update streak information
    fn update_streak_info(&self, stats: &mut TrainingStatistics, scores: &TrainingScores) {
        // Consider a session successful for streak purposes if average score is good
        let avg_score = (scores.pronunciation + scores.quality + scores.consistency) / 3.0;
        if avg_score >= 0.7 {
            stats.current_streak += 1;
            stats.longest_streak = stats.longest_streak.max(stats.current_streak);
        } else {
            stats.current_streak = 0;
        }
    }

    /// Check achievements for a user
    async fn check_achievements_for_user(
        &self,
        progress: &UserProgress,
    ) -> Result<Vec<Achievement>, FeedbackError> {
        let achievements = self.achievements.read().unwrap();
        let mut new_achievements = Vec::new();

        for achievement_def in achievements.iter() {
            // Check if already unlocked
            if progress
                .achievements
                .iter()
                .any(|a| a.achievement_id == achievement_def.id)
            {
                continue;
            }

            // Check if condition is met
            if self.is_achievement_condition_met(progress, &achievement_def.condition) {
                new_achievements.push(Achievement {
                    achievement_id: achievement_def.id.clone(),
                    name: achievement_def.name.clone(),
                    description: achievement_def.description.clone(),
                    tier: achievement_def.tier.clone(),
                    points: achievement_def.points,
                    unlocked_at: Utc::now(),
                });
            }
        }

        Ok(new_achievements)
    }

    /// Check if achievement condition is met
    fn is_achievement_condition_met(
        &self,
        progress: &UserProgress,
        condition: &AchievementCondition,
    ) -> bool {
        match condition {
            AchievementCondition::SessionCount(required) => {
                progress.training_stats.total_sessions >= *required
            }
            AchievementCondition::SkillLevel(required) => progress.overall_skill_level >= *required,
            AchievementCondition::Streak(required) => {
                progress.training_stats.longest_streak >= *required
            }
            AchievementCondition::AreaMastery(area, required) => {
                progress.skill_breakdown.get(area).unwrap_or(&0.0) >= required
            }
            AchievementCondition::TrainingTime(required) => {
                progress.training_stats.total_training_time >= *required
            }
        }
    }

    /// Validate goal
    fn validate_goal(&self, goal: &Goal) -> Result<(), FeedbackError> {
        if goal.target_value < 0.0 || goal.target_value > 1.0 {
            return Err(FeedbackError::ProgressTrackingError {
                message: "Goal target value must be between 0.0 and 1.0".to_string(),
                source: None,
            });
        }
        Ok(())
    }

    /// Analyze achievement progress
    fn analyze_achievement_progress(&self, progress: &UserProgress) -> Vec<AchievementAnalysis> {
        let achievements = self.achievements.read().unwrap();
        let mut analyses = Vec::new();

        for achievement_def in achievements.iter() {
            let current_progress = self.calculate_achievement_progress(progress, achievement_def);
            let is_unlocked = progress
                .achievements
                .iter()
                .any(|a| a.achievement_id == achievement_def.id);

            analyses.push(AchievementAnalysis {
                achievement_id: achievement_def.id.clone(),
                name: achievement_def.name.clone(),
                current_progress,
                is_unlocked,
                estimated_time_to_unlock: None, // Simplified
            });
        }

        analyses
    }

    /// Calculate achievement progress
    fn calculate_achievement_progress(
        &self,
        progress: &UserProgress,
        achievement_def: &AchievementDefinition,
    ) -> f32 {
        match &achievement_def.condition {
            AchievementCondition::SessionCount(required) => {
                (progress.training_stats.total_sessions as f32 / *required as f32).min(1.0)
            }
            AchievementCondition::SkillLevel(required) => {
                (progress.overall_skill_level / required).min(1.0)
            }
            AchievementCondition::Streak(required) => {
                (progress.training_stats.longest_streak as f32 / *required as f32).min(1.0)
            }
            AchievementCondition::AreaMastery(area, required) => {
                let current = progress.skill_breakdown.get(area).unwrap_or(&0.0);
                (current / required).min(1.0)
            }
            AchievementCondition::TrainingTime(required) => {
                let current_secs = progress.training_stats.total_training_time.as_secs() as f32;
                let required_secs = required.as_secs() as f32;
                (current_secs / required_secs).min(1.0)
            }
        }
    }

    /// Analyze goal progress
    fn analyze_goal_progress(&self, progress: &UserProgress) -> Vec<GoalAnalysis> {
        progress
            .goals
            .iter()
            .map(|goal| {
                let current_value = match &goal.target_metric {
                    GoalMetric::OverallSkill => progress.overall_skill_level,
                    GoalMetric::FocusAreaSkill(area) => {
                        *progress.skill_breakdown.get(area).unwrap_or(&0.0)
                    }
                    GoalMetric::ExerciseCount => progress.training_stats.exercises_completed as f32,
                    GoalMetric::SessionCount => progress.training_stats.total_sessions as f32,
                    GoalMetric::TrainingTime => {
                        progress.training_stats.total_training_time.as_secs() as f32
                    }
                    GoalMetric::Streak => progress.training_stats.current_streak as f32,
                };

                let progress_percentage = (current_value / goal.target_value * 100.0).min(100.0);

                GoalAnalysis {
                    goal: goal.clone(),
                    current_value,
                    progress_percentage,
                    on_track: progress_percentage >= 50.0, // Simplified
                    estimated_completion: None,            // Simplified
                }
            })
            .collect()
    }

    /// Generate progress recommendations
    fn generate_progress_recommendations(
        &self,
        progress: &UserProgress,
        _history: &[&ProgressSnapshot],
    ) -> Vec<ProgressRecommendation> {
        let mut recommendations = Vec::new();

        // Check for areas needing improvement
        for (area, &score) in &progress.skill_breakdown {
            if score < 0.6 {
                recommendations.push(ProgressRecommendation {
                    recommendation_type: RecommendationType::Practice,
                    title: format!("Focus on {area:?}"),
                    description: format!(
                        "Your {area:?} skills could use some attention. Current level: {:.0}%",
                        score * 100.0
                    ),
                    priority: 1.0 - score, // Higher priority for lower scores
                    estimated_impact: 0.8,
                    suggested_actions: vec![
                        format!("Practice {area:?} exercises for 15 minutes daily"),
                        "Review related learning materials".to_string(),
                    ],
                });
            }
        }

        // Check streak
        if progress.training_stats.current_streak == 0 {
            recommendations.push(ProgressRecommendation {
                recommendation_type: RecommendationType::Consistency,
                title: "Build a Practice Streak".to_string(),
                description: "Start building a daily practice habit".to_string(),
                priority: 0.7,
                estimated_impact: 0.9,
                suggested_actions: vec![
                    "Set a daily practice reminder".to_string(),
                    "Start with short 10-minute sessions".to_string(),
                ],
            });
        }

        recommendations
    }

    /// Generate comparative analysis
    async fn generate_comparative_analysis(
        &self,
        user_id: &str,
        _history: &[&ProgressSnapshot],
    ) -> Result<ComparativeAnalysis, FeedbackError> {
        let progress = self.get_user_progress_impl(user_id).await?;
        let stats = self.get_statistics().await?;

        Ok(ComparativeAnalysis {
            user_percentile: 50.0, // Simplified
            average_user_score: stats.average_skill_level,
            user_score: progress.overall_skill_level,
            improvement_rate_vs_average: 0.0, // Simplified
            strengths_vs_peers: vec!["Consistent practice".to_string()],
            areas_for_improvement: vec!["Pronunciation".to_string()],
        })
    }

    /// Create default achievements
    fn create_default_achievements() -> Vec<AchievementDefinition> {
        vec![
            AchievementDefinition {
                id: "first_session".to_string(),
                name: "First Steps".to_string(),
                description: "Complete your first training session".to_string(),
                condition: AchievementCondition::SessionCount(1),
                tier: AchievementTier::Bronze,
                points: 10,
            },
            AchievementDefinition {
                id: "ten_sessions".to_string(),
                name: "Getting Started".to_string(),
                description: "Complete 10 training sessions".to_string(),
                condition: AchievementCondition::SessionCount(10),
                tier: AchievementTier::Bronze,
                points: 50,
            },
            AchievementDefinition {
                id: "three_day_streak".to_string(),
                name: "Streak Starter".to_string(),
                description: "Maintain a 3-day practice streak".to_string(),
                condition: AchievementCondition::Streak(3),
                tier: AchievementTier::Bronze,
                points: 30,
            },
            AchievementDefinition {
                id: "pronunciation_master".to_string(),
                name: "Pronunciation Master".to_string(),
                description: "Achieve 90% pronunciation accuracy".to_string(),
                condition: AchievementCondition::AreaMastery(FocusArea::Pronunciation, 0.9),
                tier: AchievementTier::Gold,
                points: 100,
            },
        ]
    }
}

// ============================================================================
// Trait Implementations
// ============================================================================

#[async_trait]
impl ProgressTracker for ProgressAnalyzer {
    async fn record_progress(
        &mut self,
        user_id: &str,
        session: &SessionState,
        scores: &TrainingScores,
    ) -> FeedbackResult<()> {
        let feedback = FeedbackResponse {
            feedback_items: Vec::new(),
            overall_score: (scores.pronunciation + scores.quality + scores.consistency) / 3.0,
            immediate_actions: Vec::new(),
            long_term_goals: Vec::new(),
            progress_indicators: ProgressIndicators {
                improving_areas: Vec::new(),
                attention_areas: Vec::new(),
                stable_areas: Vec::new(),
                overall_trend: scores.improvement,
                completion_percentage: scores.pronunciation * 100.0,
            },
            timestamp: Utc::now(),
            processing_time: Duration::from_millis(100),
            feedback_type: FeedbackType::Quality,
        };

        self.record_session_progress(user_id, session, scores, &feedback)
            .await
            .map_err(std::convert::Into::into)
    }

    async fn get_user_progress(&self, user_id: &str) -> FeedbackResult<UserProgress> {
        self.get_user_progress_impl(user_id)
            .await
            .map_err(std::convert::Into::into)
    }

    async fn generate_progress_report(
        &self,
        user_id: &str,
        time_range: Option<TimeRange>,
    ) -> FeedbackResult<ProgressReport> {
        let progress = self.get_user_progress_impl(user_id).await?;

        let period = time_range.unwrap_or_else(|| {
            let now = Utc::now();
            TimeRange {
                start: now - chrono::Duration::days(30),
                end: now,
            }
        });

        Ok(ProgressReport {
            user_id: progress.user_id,
            period,
            overall_improvement: 0.1, // Simplified
            area_improvements: progress.skill_breakdown,
            achievements: progress.achievements,
            goal_progress: Vec::new(), // Simplified
            recommendations: vec!["Keep practicing daily".to_string()],
            statistics: ReportStatistics {
                sessions_count: progress.training_stats.total_sessions,
                total_practice_time: progress.training_stats.total_training_time,
                average_session_length: Duration::from_secs(1800), // Simplified
                exercises_completed: progress.training_stats.exercises_completed,
                success_rate: progress.training_stats.success_rate,
            },
        })
    }

    async fn check_achievements(&self, user_id: &str) -> FeedbackResult<Vec<Achievement>> {
        let progress = self.get_user_progress(user_id).await?;
        Ok(progress.achievements)
    }

    async fn set_goals(&mut self, user_id: &str, goals: Vec<Goal>) -> FeedbackResult<()> {
        let mut progress_map = self.user_progress.write().unwrap();
        let progress = progress_map.get_mut(user_id).ok_or_else(|| {
            VoirsError::from(FeedbackError::ProgressTrackingError {
                message: format!("User progress not found: {user_id}"),
                source: None,
            })
        })?;

        // Validate goals
        for goal in &goals {
            self.validate_goal(goal).map_err(VoirsError::from)?;
        }

        progress.goals = goals;
        progress.last_updated = Utc::now();

        Ok(())
    }
}