Memory Strength Assessment - Comprehensive Cognitive Performance Evaluation

class MemoryStrengthAssessment:
    def __init__(self):
        self.strength_metrics = {
            'recall_consistency': self._assess_recall_consistency,
            'retrieval_speed': self._measure_retrieval_speed,
            'confidence_levels': self._evaluate_confidence_levels,
            'error_patterns': self._analyze_error_patterns,
            'retention_decay': self._measure_retention_decay,
            'interference_resistance': self._assess_interference_resistance,
            'context_independence': self._evaluate_context_independence
        }

    def comprehensive_strength_assessment(self, user_id, assessment_scope='all'):
        """Perform comprehensive memory strength assessment"""

        # Collect assessment data
        assessment_data = self._collect_assessment_data(user_id, assessment_scope)

        # Calculate strength metrics for each card
        card_assessments = {}
        for card_id, card_data in assessment_data.items():
            card_assessment = self._assess_card_memory_strength(card_data)
            card_assessments[card_id] = card_assessment

        # Generate aggregate assessments
        aggregate_assessments = {
            'overall_strength': self._calculate_overall_strength(card_assessments),
            'subject_strength': self._calculate_subject_strength(card_assessments),
            'topic_strength': self._calculate_topic_strength(card_assessments),
            'difficulty_strength': self._calculate_difficulty_strength(card_assessments)
        }

        # Analyze strength patterns
        strength_patterns = {
            'strong_domains': self._identify_strong_domains(card_assessments),
            'weak_domains': self._identify_weak_domains(card_assessments),
            'improving_areas': self._identify_improving_areas(card_assessments),
            'stable_areas': self._identify_stable_areas(card_assessments)
        }

        # Generate strength optimization recommendations
        optimization_plan = self._generate_strength_optimization_plan(
            card_assessments, aggregate_assessments, strength_patterns
        )

        return {
            'assessment_timestamp': datetime.now(),
            'card_assessments': card_assessments,
            'aggregate_assessments': aggregate_assessments,
            'strength_patterns': strength_patterns,
            'optimization_plan': optimization_plan,
            'next_assessment_date': self._schedule_next_assessment(),
            'progress_tracking': self._setup_progress_tracking()
        }

    def _assess_card_memory_strength(self, card_data):
        """Assess memory strength for individual card"""

        review_history = card_data.get('review_history', [])
        if len(review_history) < 3:
            return {
                'strength_score': 0,
                'strength_category': 'insufficient_data',
                'confidence': 'low',
                'recommendations': ['Continue reviews to establish baseline']
            }

        # Calculate individual strength components
        strength_components = {
            'recall_consistency': self._calculate_recall_consistency(review_history),
            'retrieval_speed': self._calculate_retrieval_speed(review_history),
            'confidence_stability': self._calculate_confidence_stability(review_history),
            'error_reduction': self._calculate_error_reduction(review_history),
            'retention_endurance': self._calculate_retention_endurance(review_history),
            'interference_immunity': self._calculate_interference_immunity(review_history)
        }

        # Calculate weighted overall strength score
        weights = {
            'recall_consistency': 0.25,
            'retrieval_speed': 0.15,
            'confidence_stability': 0.20,
            'error_reduction': 0.15,
            'retention_endurance': 0.15,
            'interference_immunity': 0.10
        }

        overall_score = sum(
            strength_components[component] * weights[component]
            for component in strength_components
        )

        # Determine strength category
        strength_category = self._determine_strength_category(overall_score)

        # Calculate confidence in assessment
        assessment_confidence = self._calculate_assessment_confidence(
            strength_components, len(review_history)
        )

        # Predict future strength trajectory
        strength_trajectory = self._predict_strength_trajectory(
            strength_components, overall_score, review_history
        )

        return {
            'strength_score': round(overall_score, 2),
            'strength_category': strength_category,
            'strength_components': strength_components,
            'assessment_confidence': assessment_confidence,
            'strength_trajectory': strength_trajectory,
            'next_review_optimization': self._suggest_next_review_optimization(overall_score),
            'strengthening_strategies': self._recommend_strengthening_strategies(strength_components)
        }

    def _calculate_recall_consistency(self, review_history):
        """Calculate consistency of recall performance over time"""

        if len(review_history) < 5:
            return min(50, len(review_history) * 10)  # Limited data

        # Get quality scores from recent reviews
        quality_scores = [review['quality_score'] for review in review_history[-10:]]

        # Calculate consistency metrics
        average_quality = sum(quality_scores) / len(quality_scores)
        variance = statistics.variance(quality_scores)
        trend_slope = self._calculate_trend_slope(quality_scores)

        # Consistency score based on multiple factors
        base_consistency = max(0, 100 - (variance * 25))  # Lower variance = higher consistency
        quality_bonus = (average_quality / 5) * 20  # Higher average quality = bonus
        trend_bonus = max(-10, min(10, trend_slope * 20))  # Positive trend = bonus

        consistency_score = base_consistency + quality_bonus + trend_bonus
        return max(0, min(100, consistency_score))

    def _calculate_retrieval_speed(self, review_history):
        """Calculate speed and efficiency of memory retrieval"""

        if not review_history:
            return 0

        # Get response times from recent reviews
        response_times = [
            review.get('response_time', 30)  # Default 30 seconds if missing
            for review in review_history[-10:]
        ]

        if not response_times:
            return 0

        # Calculate speed metrics
        average_time = sum(response_times) / len(response_times)
        time_variance = statistics.variance(response_times) if len(response_times) > 1 else 0

        # Speed score calculation (faster = higher score)
        # Optimal time is 5-15 seconds depending on difficulty
        optimal_time = 10  # seconds
        speed_efficiency = max(0, 100 - abs(average_time - optimal_time) * 5)

        # Consistency bonus (lower variance = higher bonus)
        consistency_bonus = max(0, 100 - time_variance * 2)

        # Combine scores
        speed_score = (speed_efficiency * 0.7) + (consistency_bonus * 0.3)
        return max(0, min(100, speed_score))

    def _predict_strength_trajectory(self, strength_components, current_score, review_history):
        """Predict future memory strength trajectory"""

        # Analyze recent trends
        recent_trends = self._analyze_recent_trends(review_history)

        # Calculate trajectory factors
        trajectory_factors = {
            'improvement_trend': recent_trends['quality_trend'],
            'consistency_trend': recent_trends['consistency_trend'],
            'speed_trend': recent_trends['speed_trend'],
            'confidence_trend': recent_trends['confidence_trend']
        }

        # Predict future strength at different time points
        predictions = {}
        base_decay_rate = 0.02  # Daily decay rate if no reviews

        for days_ahead in [7, 14, 30, 60]:
            # Apply trend-based adjustments
            trend_adjustment = sum(trajectory_factors.values()) / len(trajectory_factors)

            # Calculate predicted strength
            predicted_strength = current_score - (days_ahead * base_decay_rate) + (days_ahead * trend_adjustment * 0.1)

            # Apply bounds
            predicted_strength = max(0, min(100, predicted_strength))

            predictions[f'{days_ahead}_days'] = {
                'predicted_strength': round(predicted_strength, 2),
                'change_from_current': round(predicted_strength - current_score, 2),
                'confidence': self._calculate_prediction_confidence(days_ahead, len(review_history))
            }

        return {
            'predictions': predictions,
            'trajectory_factors': trajectory_factors,
            'recommended_intervention_points': self._identify_intervention_points(predictions)
        }

class AdvancedStrengthAnalyzer:
    def __init__(self):
        self.analysis_dimensions = {
            'temporal_stability': self._analyze_temporal_stability,
            'contextual_flexibility': self._analyze_contextual_flexibility,
            'interference_resistance': self._analyze_interference_resistance,
            'retrieval_pathways': self._analyze_retrieval_pathways,
            'neural_efficiency': self._estimate_neural_efficiency
        }

    def deep_strength_analysis(self, user_id, analysis_targets=None):
        """Perform deep analysis of memory strength across multiple dimensions"""

        if analysis_targets is None:
            analysis_targets = self._get_analysis_targets(user_id)

        deep_analysis = {
            'dimensional_analysis': {},
            'strength_clusters': {},
            'vulnerability_assessment': {},
            'optimization_opportunities': {}
        }

        # Perform dimensional analysis
        for dimension, analysis_function in self.analysis_dimensions.items():
            dimension_results = analysis_function(user_id, analysis_targets)
            deep_analysis['dimensional_analysis'][dimension] = dimension_results

        # Identify strength clusters
        deep_analysis['strength_clusters'] = self._identify_strength_clusters(
            deep_analysis['dimensional_analysis']
        )

        # Assess vulnerabilities
        deep_analysis['vulnerability_assessment'] = self._assess_strength_vulnerabilities(
            deep_analysis['dimensional_analysis']
        )

        # Identify optimization opportunities
        deep_analysis['optimization_opportunities'] = self._identify_optimization_opportunities(
            deep_analysis['dimensional_analysis'],
            deep_analysis['strength_clusters']
        )

        return deep_analysis

    def _analyze_temporal_stability(self, user_id, analysis_targets):
        """Analyze how stable memory strength is over time"""

        stability_analysis = {
            'short_term_stability': {},  # Hours to days
            'medium_term_stability': {},  # Days to weeks
            'long_term_stability': {},    # Weeks to months
            'decay_patterns': {},
            'consolidation_quality': {}
        }

        for target in analysis_targets:
            target_data = self._get_target_data(user_id, target)

            # Short-term stability (first 24 hours)
            short_term_reviews = self._get_reviews_in_period(target_data, hours=24)
            stability_analysis['short_term_stability'][target] = self._calculate_stability_score(
                short_term_reviews
            )

            # Medium-term stability (1-4 weeks)
            medium_term_reviews = self._get_reviews_in_period(target_data, days=28)
            stability_analysis['medium_term_stability'][target] = self._calculate_stability_score(
                medium_term_reviews
            )

            # Long-term stability (1+ months)
            long_term_reviews = self._get_reviews_in_period(target_data, months=3)
            stability_analysis['long_term_stability'][target] = self._calculate_stability_score(
                long_term_reviews
            )

            # Analyze decay patterns
            stability_analysis['decay_patterns'][target] = self._analyze_decay_pattern(target_data)

            # Assess consolidation quality
            stability_analysis['consolidation_quality'][target] = self._assess_consolidation_quality(
                target_data
            )

        # Generate temporal insights
        temporal_insights = self._generate_temporal_insights(stability_analysis)

        return {
            'stability_data': stability_analysis,
            'temporal_insights': temporal_insights,
            'consolidation_recommendations': self._generate_consolidation_recommendations(
                stability_analysis
            )
        }

    def _analyze_contextual_flexibility(self, user_id, analysis_targets):
        """Analyze how well knowledge transfers across different contexts"""

        flexibility_analysis = {
            'subject_transfer': {},
            'topic_transfer': {},
            'difficulty_transfer': {},
            'format_transfer': {},
            'contextual_independence': {}
        }

        for target in analysis_targets:
            target_data = self._get_target_data(user_id, target)

            # Analyze performance across different contexts
            context_performance = self._analyze_cross_context_performance(target_data)

            flexibility_analysis['subject_transfer'][target] = context_performance.get('subject_transfer', 0)
            flexibility_analysis['topic_transfer'][target] = context_performance.get('topic_transfer', 0)
            flexibility_analysis['difficulty_transfer'][target] = context_performance.get('difficulty_transfer', 0)
            flexibility_analysis['format_transfer'][target] = context_performance.get('format_transfer', 0)

            # Calculate contextual independence
            flexibility_analysis['contextual_independence'][target] = self._calculate_contextual_independence(
                context_performance
            )

        # Generate flexibility insights
        flexibility_insights = self._generate_flexibility_insights(flexibility_analysis)

        return {
            'flexibility_data': flexibility_analysis,
            'flexibility_insights': flexibility_insights,
            'transfer_recommendations': self._generate_transfer_recommendations(flexibility_analysis)
        }

    def _identify_strength_clusters(self, dimensional_analysis):
        """Identify clusters of similar strength patterns"""

        # Collect all dimensional data
        all_targets = set()
        for dimension_data in dimensional_analysis.values():
            if isinstance(dimension_data, dict) and 'stability_data' in dimension_data:
                all_targets.update(dimension_data['stability_data'].get('short_term_stability', {}).keys())

        # Create feature vectors for each target
        feature_vectors = {}
        for target in all_targets:
            features = []

            # Extract features from each dimension
            for dimension, data in dimensional_analysis.items():
                if isinstance(data, dict) and 'stability_data' in data:
                    # Add stability features
                    stability_data = data['stability_data']
                    features.extend([
                        stability_data.get('short_term_stability', {}).get(target, 0),
                        stability_data.get('medium_term_stability', {}).get(target, 0),
                        stability_data.get('long_term_stability', {}).get(target, 0)
                    ])

            feature_vectors[target] = features

        # Perform clustering (simplified k-means)
        clusters = self._perform_clustering(feature_vectors, num_clusters=5)

        # Analyze cluster characteristics
        cluster_analysis = {}
        for cluster_id, cluster_targets in clusters.items():
            cluster_analysis[cluster_id] = {
                'targets': cluster_targets,
                'size': len(cluster_targets),
                'characteristics': self._analyze_cluster_characteristics(
                    cluster_targets, dimensional_analysis
                ),
                'strength_profile': self._create_cluster_strength_profile(
                    cluster_targets, dimensional_analysis
                )
            }

        return {
            'clusters': cluster_analysis,
            'clustering_method': 'k_means',
            'total_targets': len(all_targets),
            'cluster_quality': self._assess_cluster_quality(clusters, feature_vectors)
        }

class StrengthOptimizer:
    def __init__(self):
        self.optimization_strategies = {
            'recall_practice': self._optimize_recall_practice,
            'retrieval_practice': self._optimize_retrieval_practice,
            'spacing_optimization': self._optimize_spacing,
            'interweaving': self._optimize_interweaving,
            'elaboration': self._optimize_elaboration_techniques,
            'multimodal_learning': self._optimize_multimodal_approaches
        }

    def create_personalized_optimization_plan(self, user_id, strength_assessment):
        """Create personalized plan to improve memory strength"""

        # Identify optimization priorities
        optimization_priorities = self._identify_optimization_priorities(strength_assessment)

        # Create optimization plan
        optimization_plan = {
            'immediate_actions': [],
            'short_term_goals': [],
            'long_term_strategies': [],
            'monitoring_metrics': [],
            'expected_timeline': {}
        }

        # Generate recommendations based on strength gaps
        for priority in optimization_priorities:
            if priority['urgency'] == 'high':
                # Immediate actions for high-priority issues
                actions = self._generate_immediate_actions(priority)
                optimization_plan['immediate_actions'].extend(actions)

                # Short-term goals
                goals = self._generate_short_term_goals(priority)
                optimization_plan['short_term_goals'].extend(goals)

            elif priority['urgency'] == 'medium':
                # Short-term goals for medium-priority issues
                goals = self._generate_short_term_goals(priority)
                optimization_plan['short_term_goals'].extend(goals)

            else:
                # Long-term strategies for low-priority issues
                strategies = self._generate_long_term_strategies(priority)
                optimization_plan['long_term_strategies'].extend(strategies)

        # Setup monitoring metrics
        optimization_plan['monitoring_metrics'] = self._setup_monitoring_metrics(optimization_priorities)

        # Create expected timeline
        optimization_plan['expected_timeline'] = self._create_expected_timeline(optimization_priorities)

        return optimization_plan

    def _optimize_recall_practice(self, user_id, target_cards):
        """Optimize recall practice for specific cards"""

        recall_optimization = {
            'practice_techniques': [],
            'frequency_schedule': {},
            'difficulty_progression': {},
            'success_metrics': []
        }

        for card in target_cards:
            card_data = self._get_card_strength_data(card)
            current_strength = card_data['strength_score']

            # Determine optimal practice technique
            if current_strength < 40:
                technique = 'active_recall_with_cues'
            elif current_strength < 70:
                technique = 'free_recall_practice'
            else:
                technique = 'rapid_recall_testing'

            recall_optimization['practice_techniques'].append({
                'card_id': card,
                'technique': technique,
                'rationale': self._explain_technique_choice(current_strength),
                'implementation_guide': self._get_technique_implementation_guide(technique)
            })

            # Create frequency schedule
            recall_optimization['frequency_schedule'][card] = self._create_recall_schedule(
                current_strength, card_data
            )

            # Define difficulty progression
            recall_optimization['difficulty_progression'][card] = self._define_difficulty_progression(
                current_strength
            )

        return {
            'optimization_type': 'recall_practice',
            'target_cards': target_cards,
            'optimization_details': recall_optimization,
            'expected_improvement': self._predict_recall_improvement(target_cards),
            'monitoring_plan': self._create_recall_monitoring_plan(target_cards)
        }

    def _optimize_spacing(self, user_id, target_cards):
        """Optimize spacing intervals for maximum retention"""

        spacing_analysis = {}
        for card in target_cards:
            card_data = self._get_card_strength_data(card)

            # Analyze current spacing effectiveness
            current_spacing = card_data['current_interval']
            retention_rate = card_data['retention_rate']

            # Calculate optimal spacing
            optimal_spacing = self._calculate_optimal_spacing(
                card_data['strength_score'],
                card_data['difficulty_level'],
                retention_rate
            )

            spacing_analysis[card] = {
                'current_spacing': current_spacing,
                'optimal_spacing': optimal_spacing,
                'spacing_adjustment': optimal_spacing - current_spacing,
                'adjustment_rationale': self._explain_spacing_adjustment(
                    current_spacing, optimal_spacing, retention_rate
                ),
                'implementation_schedule': self._create_spacing_implementation_schedule(
                    current_spacing, optimal_spacing
                )
            }

        return {
            'optimization_type': 'spacing_optimization',
            'spacing_analysis': spacing_analysis,
            'overall_adjustment_strategy': self._create_overall_spacing_strategy(spacing_analysis),
            'expected_retention_improvement': self._predict_retention_improvement(spacing_analysis),
            'risk_assessment': self._assess_spacing_adjustment_risks(spacing_analysis)
        }

class StrengthProgressTracker:
    def __init__(self):
        self.tracking_metrics = {
            'strength_trajectory': self._track_strength_trajectory,
            'improvement_rate': self._track_improvement_rate,
            'consistency_metrics': self._track_consistency_metrics,
            'milestone_achievement': self._track_milestone_achievement
        }

    def setup_strength_tracking(self, user_id, tracking_config=None):
        """Setup comprehensive strength progress tracking"""

        if tracking_config is None:
            tracking_config = {
                'tracking_frequency': 'daily',
                'benchmark_frequency': 'weekly',
                'milestone_check': 'monthly',
                'alert_thresholds': {
                    'strength_decline': 0.15,    # 15% decline triggers alert
                    'stagnation_period': 14,     # 14 days of no improvement
                    'rapid_improvement': 0.25    # 25% improvement triggers celebration
                }
            }

        # Initialize tracking system
        tracking_system = {
            'baseline_assessment': self._establish_baseline(user_id),
            'tracking_schedule': self._create_tracking_schedule(tracking_config),
            'milestone_definitions': self._define_strength_milestones(),
            'alert_system': self._setup_alert_system(tracking_config['alert_thresholds']),
            'progress_visualization': self._setup_progress_visualization()
        }

        # Create initial progress report
        initial_report = self._generate_initial_progress_report(user_id, tracking_system)

        return {
            'tracking_system': tracking_system,
            'initial_report': initial_report,
            'next_update': self._schedule_next_tracking_update(tracking_config),
            'user_instructions': self._generate_tracking_instructions(tracking_config)
        }

    def track_strength_progress(self, user_id, time_period=30):
        """Track strength progress over specified time period"""

        # Collect progress data
        progress_data = self._collect_progress_data(user_id, time_period)

        # Analyze strength changes
        strength_analysis = {
            'overall_strength_change': self._calculate_overall_strength_change(progress_data),
            'dimensional_changes': self._analyze_dimensional_strength_changes(progress_data),
            'card_level_changes': self._analyze_card_level_changes(progress_data),
            'pattern_analysis': self._analyze_strength_patterns(progress_data)
        }

        # Identify progress trends
        trend_analysis = {
            'improvement_trend': self._analyze_improvement_trend(progress_data),
            'stability_trend': self._analyze_stability_trend(progress_data),
            'acceleration_trend': self._analyze_acceleration_trend(progress_data)
        }

        # Assess milestone achievement
        milestone_assessment = {
            'achieved_milestones': self._check_achieved_milestones(progress_data),
            'upcoming_milestones': self._identify_upcoming_milestones(progress_data),
            'milestone_progress': self._calculate_milestone_progress(progress_data)
        }

        # Generate progress insights
        progress_insights = self._generate_progress_insights(
            strength_analysis, trend_analysis, milestone_assessment
        )

        return {
            'tracking_period': time_period,
            'strength_analysis': strength_analysis,
            'trend_analysis': trend_analysis,
            'milestone_assessment': milestone_assessment,
            'progress_insights': progress_insights,
            'recommendations': self._generate_progress_recommendations(progress_insights),
            'next_tracking_focus': self._identify_next_tracking_focus(progress_insights)
        }

    def _analyze_improvement_trend(self, progress_data):
        """Analyze improvement trends in memory strength"""

        # Extract strength measurements over time
        strength_timeline = []
        for date, measurements in progress_data.items():
            overall_strength = measurements.get('overall_strength', 0)
            strength_timeline.append({
                'date': date,
                'strength': overall_strength
            })

        if len(strength_timeline) < 2:
            return {'trend': 'insufficient_data', 'slope': 0, 'confidence': 0}

        # Calculate trend slope using linear regression
        dates_numeric = [(date - strength_timeline[0]['date']).days for date in
                        [entry['date'] for entry in strength_timeline]]
        strengths = [entry['strength'] for entry in strength_timeline]

        # Simple linear regression
        n = len(strength_timeline)
        sum_x = sum(dates_numeric)
        sum_y = sum(strengths)
        sum_xy = sum(d * s for d, s in zip(dates_numeric, strengths))
        sum_x2 = sum(d * d for d in dates_numeric)

        slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x * sum_x) if n > 1 else 0

        # Calculate confidence in trend
        residuals = [strengths[i] - (slope * dates_numeric[i] +
                   (sum_y - slope * sum_x) / n) for i in range(n)]
        residual_variance = sum(r * r for r in residuals) / (n - 2) if n > 2 else 0

        confidence = max(0, min(1, 1 - (residual_variance / 100)))  # Normalize to 0-1

        # Determine trend category
        if slope > 0.5:
            trend_category = 'rapid_improvement'
        elif slope > 0.1:
            trend_category = 'steady_improvement'
        elif slope > -0.1:
            trend_category = 'stable'
        elif slope > -0.5:
            trend_category = 'gradual_decline'
        else:
            trend_category = 'rapid_decline'

        return {
            'trend': trend_category,
            'slope': round(slope, 4),
            'confidence': round(confidence, 3),
            'data_points': n,
            'time_span': (strength_timeline[-1]['date'] - strength_timeline[0]['date']).days,
            'interpretation': self._interpret_trend(trend_category, slope, confidence)
        }

class StrengthDashboard:
    def __init__(self):
        self.dashboard_components = {
            'strength_meter': self._create_strength_meter,
            'progress_charts': self._create_progress_charts,
            'strength_heatmap': self._create_strength_heatmap,
            'improvement_tracker': self._create_improvement_tracker,
            'recommendation_panel': self._create_recommendation_panel
        }

    def create_interactive_dashboard(self, user_id):
        """Create interactive memory strength dashboard"""

        dashboard_data = {
            'user_id': user_id,
            'last_updated': datetime.now(),
            'components': {},
            'real_time_data': {},
            'alerts': [],
            'recommendations': []
        }

        # Generate all dashboard components
        for component_name, component_function in self.dashboard_components.items():
            try:
                component_data = component_function(user_id)
                dashboard_data['components'][component_name] = component_data
            except Exception as e:
                dashboard_data['components'][component_name] = {'error': str(e)}

        # Get real-time data
        dashboard_data['real_time_data'] = self._get_real_time_strength_data(user_id)

        # Generate alerts and recommendations
        dashboard_data['alerts'] = self._generate_strength_alerts(dashboard_data)
        dashboard_data['recommendations'] = self._generate_dashboard_recommendations(dashboard_data)

        return dashboard_data

    def _create_strength_meter(self, user_id):
        """Create visual strength meter component"""

        # Get current strength assessment
        strength_assessment = MemoryStrengthAssessment().comprehensive_strength_assessment(user_id)
        overall_strength = strength_assessment['aggregate_assessments']['overall_strength']['score']

        # Create strength meter data
        strength_meter = {
            'type': 'gauge_chart',
            'title': 'Overall Memory Strength',
            'current_value': overall_strength,
            'max_value': 100,
            'zones': [
                {'min': 0, 'max': 20, 'color': '#ff4444', 'label': 'Very Weak'},
                {'min': 20, 'max': 40, 'color': '#ff8844', 'label': 'Weak'},
                {'min': 40, 'max': 60, 'color': '#ffcc44', 'label': 'Moderate'},
                {'min': 60, 'max': 80, 'color': '#88cc44', 'label': 'Strong'},
                {'min': 80, 'max': 100, 'color': '#44cc44', 'label': 'Very Strong'}
            ],
            'historical_data': self._get_strength_history(user_id, days=30),
            'target_strength': self._get_target_strength(user_id),
            'strength_trend': self._calculate_strength_trend(user_id)
        }

        return strength_meter

    def _create_strength_heatmap(self, user_id):
        """Create strength heatmap visualization"""

        # Get strength data by subject and topic
        strength_data = self._get_strength_by_subject_topic(user_id)

        # Prepare heatmap data
        heatmap_data = {
            'type': 'heatmap',
            'title': 'Memory Strength by Subject and Topic',
            'data': [],
            'subjects': [],
            'topics': []
        }

        # Organize data for heatmap
        subjects = set()
        topics = set()

        for item in strength_data:
            subjects.add(item['subject'])
            topics.add(item['topic'])

        subjects = sorted(list(subjects))
        topics = sorted(list(topics))

        # Create heatmap matrix
        for i, subject in enumerate(subjects):
            for j, topic in enumerate(topics):
                # Find strength for this subject-topic combination
                strength = 0
                for item in strength_data:
                    if item['subject'] == subject and item['topic'] == topic:
                        strength = item['strength_score']
                        break

                heatmap_data['data'].append({
                    'x': j,
                    'y': i,
                    'v': strength,
                    'subject': subject,
                    'topic': topic
                })

        heatmap_data['subjects'] = subjects
        heatmap_data['topics'] = topics

        # Color configuration
        heatmap_data['color_scale'] = {
            'min': 0,
            'max': 100,
            'colors': ['#ff4444', '#ff8844', '#ffcc44', '#88cc44', '#44cc44']
        }

        return heatmap_data

    def _create_improvement_tracker(self, user_id):
        """Create improvement tracking component"""

        # Get improvement data
        progress_tracker = StrengthProgressTracker()
        progress_data = progress_tracker.track_strength_progress(user_id, time_period=30)

        # Create improvement tracker data
        improvement_tracker = {
            'type': 'multi_line_chart',
            'title': 'Memory Strength Improvement Over Time',
            'datasets': [
                {
                    'label': 'Overall Strength',
                    'data': progress_data['strength_analysis']['overall_strength_change']['timeline'],
                    'borderColor': '#44cc44',
                    'backgroundColor': 'rgba(68, 204, 68, 0.1)'
                },
                {
                    'label': 'Target Strength',
                    'data': progress_data['strength_analysis']['overall_strength_change']['target_timeline'],
                    'borderColor': '#4444cc',
                    'borderDash': [5, 5],
                    'fill': False
                }
            ],
            'improvement_rate': progress_data['trend_analysis']['improvement_trend']['slope'],
            'milestones': progress_data['milestone_assessment']['achieved_milestones'],
            'upcoming_milestones': progress_data['milestone_assessment']['upcoming_milestones']
        }

        return improvement_tracker