modules/educational_framework.py

"""
Educational Framework for POLYMEROS
Interactive learning system with adaptive progression and competency tracking
"""

import json
import numpy as np
from typing import Dict, List, Any, Optional, Tuple
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path
import streamlit as st


@dataclass
class LearningObjective:
    """Individual learning objective with assessment criteria"""

    id: str
    title: str
    description: str
    prerequisite_ids: List[str]
    difficulty_level: int  # 1-5 scale
    estimated_time: int  # minutes
    assessment_criteria: List[str]
    resources: List[Dict[str, str]]

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)

    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> "LearningObjective":
        return cls(**data)


@dataclass
class UserProgress:
    """Track user progress and competency"""

    user_id: str
    completed_objectives: List[str]
    competency_scores: Dict[str, float]  # objective_id -> score
    learning_path: List[str]
    session_history: List[Dict[str, Any]]
    preferred_learning_style: str
    current_level: str

    def to_dict(self) -> Dict[str, Any]:
        return asdict(self)

    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> "UserProgress":
        return cls(**data)


class CompetencyAssessment:
    """Assess user competency through interactive tasks"""

    def __init__(self):
        self.assessment_tasks = {
            "spectroscopy_basics": [
                {
                    "type": "spectrum_identification",
                    "question": "Which spectral region typically shows C-H stretching vibrations?",
                    "options": [
                        "400-1500 cm⁻¹",
                        "1500-1700 cm⁻¹",
                        "2800-3100 cm⁻¹",
                        "3200-3600 cm⁻¹",
                    ],
                    "correct": 2,
                    "explanation": "C-H stretching vibrations appear in the 2800-3100 cm⁻¹ region",
                },
                {
                    "type": "peak_interpretation",
                    "question": "A peak at 1715 cm⁻¹ in a polymer spectrum most likely indicates:",
                    "options": [
                        "C-H bending",
                        "C=O stretching",
                        "O-H stretching",
                        "C-C stretching",
                    ],
                    "correct": 1,
                    "explanation": "C=O stretching typically appears around 1715 cm⁻¹, indicating carbonyl groups",
                },
            ],
            "polymer_aging": [
                {
                    "type": "degradation_mechanism",
                    "question": "Which process is most commonly responsible for polymer degradation?",
                    "options": [
                        "Hydrolysis",
                        "Oxidation",
                        "Thermal decomposition",
                        "UV radiation",
                    ],
                    "correct": 1,
                    "explanation": "Oxidation is the most common degradation mechanism in polymers",
                }
            ],
            "ai_ml_concepts": [
                {
                    "type": "model_interpretation",
                    "question": "What does a confidence score of 0.95 indicate?",
                    "options": [
                        "95% accuracy",
                        "95% probability",
                        "95% certainty",
                        "95% training success",
                    ],
                    "correct": 1,
                    "explanation": "Confidence score represents the model's estimated probability of the prediction",
                }
            ],
        }

    def assess_competency(self, domain: str, user_responses: List[int]) -> float:
        """Assess user competency in a specific domain"""
        if domain not in self.assessment_tasks:
            return 0.0

        tasks = self.assessment_tasks[domain]
        if len(user_responses) != len(tasks):
            # Handle mismatched response count gracefully
            min_len = min(len(user_responses), len(tasks))
            user_responses = user_responses[:min_len]
            tasks = tasks[:min_len]

            if not tasks:  # No tasks to assess
                return 0.0

        correct_count = sum(
            1
            for i, response in enumerate(user_responses)
            if response == tasks[i]["correct"]
        )

        return correct_count / len(tasks)

    def get_personalized_feedback(
        self, domain: str, user_responses: List[int]
    ) -> List[str]:
        """Provide personalized feedback based on assessment results"""
        feedback = []

        if domain not in self.assessment_tasks:
            return ["Domain not found"]

        tasks = self.assessment_tasks[domain]

        # Handle mismatched response count
        min_len = min(len(user_responses), len(tasks))
        user_responses = user_responses[:min_len]
        tasks = tasks[:min_len]

        for i, response in enumerate(user_responses):
            if i < len(tasks):
                task = tasks[i]
                if response == task["correct"]:
                    feedback.append(f"✅ Correct! {task['explanation']}")
                else:
                    feedback.append(f"❌ Incorrect. {task['explanation']}")

        return feedback


class AdaptiveLearningPath:
    """Generate personalized learning paths based on user competency and goals"""

    def __init__(self):
        self.learning_objectives = self._initialize_objectives()
        self.learning_styles = ["visual", "hands-on", "theoretical", "collaborative"]

    def _initialize_objectives(self) -> Dict[str, LearningObjective]:
        """Initialize learning objectives database"""
        objectives = {}

        # Basic spectroscopy objectives
        objectives["spec_001"] = LearningObjective(
            id="spec_001",
            title="Introduction to Vibrational Spectroscopy",
            description="Understand the principles of Raman and FTIR spectroscopy",
            prerequisite_ids=[],
            difficulty_level=1,
            estimated_time=15,
            assessment_criteria=[
                "Identify spectral regions",
                "Explain molecular vibrations",
            ],
            resources=[
                {"type": "tutorial", "url": "interactive_spectroscopy_tutorial"},
                {"type": "video", "url": "spectroscopy_basics_video"},
            ],
        )

        objectives["spec_002"] = LearningObjective(
            id="spec_002",
            title="Spectral Interpretation",
            description="Learn to interpret peaks and identify functional groups",
            prerequisite_ids=["spec_001"],
            difficulty_level=2,
            estimated_time=25,
            assessment_criteria=[
                "Identify functional groups",
                "Interpret peak intensities",
            ],
            resources=[
                {"type": "interactive", "url": "peak_identification_tool"},
                {"type": "practice", "url": "spectral_analysis_exercises"},
            ],
        )

        # Polymer science objectives
        objectives["poly_001"] = LearningObjective(
            id="poly_001",
            title="Polymer Structure and Properties",
            description="Understand polymer chemistry and structure-property relationships",
            prerequisite_ids=[],
            difficulty_level=2,
            estimated_time=20,
            assessment_criteria=[
                "Explain polymer structures",
                "Relate structure to properties",
            ],
            resources=[
                {"type": "tutorial", "url": "polymer_basics_tutorial"},
                {"type": "simulation", "url": "molecular_structure_viewer"},
            ],
        )

        objectives["poly_002"] = LearningObjective(
            id="poly_002",
            title="Polymer Degradation Mechanisms",
            description="Learn about polymer aging and degradation pathways",
            prerequisite_ids=["poly_001"],
            difficulty_level=3,
            estimated_time=30,
            assessment_criteria=[
                "Identify degradation mechanisms",
                "Predict aging effects",
            ],
            resources=[
                {"type": "case_study", "url": "degradation_case_studies"},
                {"type": "interactive", "url": "aging_simulation"},
            ],
        )

        # AI/ML objectives
        objectives["ai_001"] = LearningObjective(
            id="ai_001",
            title="Introduction to Machine Learning",
            description="Basic concepts of ML for scientific applications",
            prerequisite_ids=[],
            difficulty_level=2,
            estimated_time=20,
            assessment_criteria=["Explain ML concepts", "Understand model types"],
            resources=[
                {"type": "tutorial", "url": "ml_basics_tutorial"},
                {"type": "interactive", "url": "model_playground"},
            ],
        )

        objectives["ai_002"] = LearningObjective(
            id="ai_002",
            title="Model Interpretation and Validation",
            description="Understanding model outputs and reliability assessment",
            prerequisite_ids=["ai_001"],
            difficulty_level=3,
            estimated_time=25,
            assessment_criteria=["Interpret model outputs", "Assess model reliability"],
            resources=[
                {"type": "hands-on", "url": "model_interpretation_lab"},
                {"type": "case_study", "url": "validation_examples"},
            ],
        )

        return objectives

    def generate_learning_path(
        self, user_progress: UserProgress, target_competencies: List[str]
    ) -> List[str]:
        """Generate personalized learning path"""
        available_objectives = []

        # Find objectives that meet prerequisites
        for obj_id, objective in self.learning_objectives.items():
            if obj_id not in user_progress.completed_objectives:
                prerequisites_met = all(
                    prereq in user_progress.completed_objectives
                    for prereq in objective.prerequisite_ids
                )
                if prerequisites_met:
                    available_objectives.append(obj_id)

        # Sort by difficulty and relevance to target competencies
        def objective_priority(obj_id):
            obj = self.learning_objectives[obj_id]
            relevance = (
                1.0
                if any(comp in obj.title.lower() for comp in target_competencies)
                else 0.5
            )
            difficulty_penalty = obj.difficulty_level * 0.1
            return relevance - difficulty_penalty

        sorted_objectives = sorted(
            available_objectives, key=objective_priority, reverse=True
        )

        return sorted_objectives[:5]  # Return top 5 recommendations

    def adapt_to_learning_style(
        self, objective_id: str, learning_style: str
    ) -> Dict[str, Any]:
        """Adapt content delivery to user's learning style"""
        objective = self.learning_objectives[objective_id]
        adapted_content = {
            "objective": objective.to_dict(),
            "recommended_approach": "",
            "priority_resources": [],
        }

        if learning_style == "visual":
            adapted_content["recommended_approach"] = (
                "Start with visualizations and diagrams"
            )
            adapted_content["priority_resources"] = [
                r for r in objective.resources if r["type"] in ["video", "simulation"]
            ]

        elif learning_style == "hands-on":
            adapted_content["recommended_approach"] = "Begin with interactive exercises"
            adapted_content["priority_resources"] = [
                r
                for r in objective.resources
                if r["type"] in ["interactive", "hands-on"]
            ]

        elif learning_style == "theoretical":
            adapted_content["recommended_approach"] = (
                "Focus on conceptual understanding"
            )
            adapted_content["priority_resources"] = [
                r
                for r in objective.resources
                if r["type"] in ["tutorial", "case_study"]
            ]

        elif learning_style == "collaborative":
            adapted_content["recommended_approach"] = (
                "Engage with community discussions"
            )
            adapted_content["priority_resources"] = [
                r
                for r in objective.resources
                if r["type"] in ["practice", "case_study"]
            ]

        return adapted_content


class VirtualLaboratory:
    """Simulated laboratory environment for hands-on learning"""

    def __init__(self):
        self.experiments = {
            "polymer_identification": {
                "title": "Polymer Identification Challenge",
                "description": "Identify unknown polymers using spectroscopic analysis",
                "difficulty": 2,
                "estimated_time": 20,
                "learning_objectives": ["spec_002", "poly_001"],
            },
            "aging_simulation": {
                "title": "Polymer Aging Simulation",
                "description": "Observe spectral changes during accelerated aging",
                "difficulty": 3,
                "estimated_time": 30,
                "learning_objectives": ["poly_002", "spec_002"],
            },
            "model_training": {
                "title": "Train Your Own Model",
                "description": "Build and train a classification model",
                "difficulty": 4,
                "estimated_time": 45,
                "learning_objectives": ["ai_001", "ai_002"],
            },
        }

    def run_experiment(
        self, experiment_id: str, user_inputs: Dict[str, Any]
    ) -> Dict[str, Any]:
        """Run virtual experiment with user inputs"""
        if experiment_id not in self.experiments:
            return {"error": "Experiment not found"}

        # The experiment details are not used directly here
        # Removed unused variable assignment

        if experiment_id == "polymer_identification":
            return self._run_identification_experiment(user_inputs)
        elif experiment_id == "aging_simulation":
            return self._run_aging_simulation(user_inputs)
        elif experiment_id == "model_training":
            return self._run_model_training(user_inputs)

        return {"error": "Experiment not implemented"}

    def _run_identification_experiment(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
        """Simulate polymer identification experiment"""
        # Generate synthetic spectrum for learning
        wavenumbers = np.linspace(400, 4000, 500)

        # Simple synthetic spectrum generation
        polymer_type = inputs.get("polymer_type", "PE")
        if polymer_type == "PE":
            # Polyethylene-like spectrum
            spectrum = (
                np.exp(-(((wavenumbers - 2920) / 50) ** 2)) * 0.8
                + np.exp(-(((wavenumbers - 2850) / 30) ** 2)) * 0.6
                + np.random.normal(0, 0.02, len(wavenumbers))
            )
        else:
            # Generic polymer spectrum
            spectrum = np.exp(
                -(((wavenumbers - 1600) / 100) ** 2)
            ) * 0.5 + np.random.normal(0, 0.02, len(wavenumbers))

        return {
            "wavenumbers": wavenumbers.tolist(),
            "spectrum": spectrum.tolist(),
            "hints": [
                "Look for C-H stretching around 2900 cm⁻¹",
                "Check the fingerprint region for characteristic patterns",
            ],
            "success": True,
        }

    def _run_aging_simulation(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
        """Simulate polymer aging experiment"""
        aging_time = inputs.get("aging_time", 0)

        # Generate time-series data showing spectral changes
        wavenumbers = np.linspace(400, 4000, 500)

        # Base spectrum
        base_spectrum = np.exp(-(((wavenumbers - 2900) / 100) ** 2)) * 0.8

        # Add aging effects
        oxidation_peak = np.exp(-(((wavenumbers - 1715) / 20) ** 2)) * (
            aging_time / 100
        )
        degraded_spectrum = base_spectrum + oxidation_peak
        degraded_spectrum += np.random.normal(0, 0.01, len(wavenumbers))

        return {
            "wavenumbers": wavenumbers.tolist(),
            "initial_spectrum": base_spectrum.tolist(),
            "aged_spectrum": degraded_spectrum.tolist(),
            "aging_time": aging_time,
            "observations": [
                "New peak emerging at 1715 cm⁻¹ (carbonyl)",
                f"Aging time: {aging_time} hours",
                "Oxidative degradation pathway activated",
            ],
            "success": True,
        }

    def _run_model_training(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
        """Simulate model training experiment"""
        model_type = inputs.get("model_type", "CNN")
        epochs = inputs.get("epochs", 10)

        # Simulate training metrics
        train_losses = [
            1.0 - i * 0.08 + np.random.normal(0, 0.02) for i in range(epochs)
        ]
        val_accuracies = [
            0.5 + i * 0.04 + np.random.normal(0, 0.01) for i in range(epochs)
        ]

        return {
            "model_type": model_type,
            "epochs": epochs,
            "train_losses": train_losses,
            "val_accuracies": val_accuracies,
            "final_accuracy": val_accuracies[-1],
            "insights": [
                "Model converged after 8 epochs",
                "Validation accuracy plateau suggests good generalization",
                "Consider data augmentation for further improvement",
            ],
            "success": True,
        }


class EducationalFramework:
    """Main educational framework interface"""

    def __init__(self, user_data_dir: str = "user_data"):
        self.user_data_dir = Path(user_data_dir)
        self.user_data_dir.mkdir(exist_ok=True)

        self.competency_assessor = CompetencyAssessment()
        self.learning_path_generator = AdaptiveLearningPath()
        self.virtual_lab = VirtualLaboratory()

        self.current_user: Optional[UserProgress] = None

    def initialize_user(self, user_id: str) -> UserProgress:
        """Initialize or load user progress"""
        user_file = self.user_data_dir / f"{user_id}.json"

        if user_file.exists():
            with open(user_file, "r", encoding="utf-8") as f:
                data = json.load(f)
            user_progress = UserProgress.from_dict(data)
        else:
            user_progress = UserProgress(
                user_id=user_id,
                completed_objectives=[],
                competency_scores={},
                learning_path=[],
                session_history=[],
                preferred_learning_style="visual",
                current_level="beginner",
            )

        self.current_user = user_progress
        return user_progress

    def assess_user_competency(
        self, domain: str, responses: List[int]
    ) -> Dict[str, Any]:
        """Assess user competency and update progress"""
        if not self.current_user:
            return {"error": "No user initialized"}

        score = self.competency_assessor.assess_competency(domain, responses)
        feedback = self.competency_assessor.get_personalized_feedback(domain, responses)

        # Update user progress
        self.current_user.competency_scores[domain] = score

        # Determine user level based on overall competency
        avg_score = np.mean(list(self.current_user.competency_scores.values()))
        if avg_score >= 0.8:
            self.current_user.current_level = "advanced"
        elif avg_score >= 0.6:
            self.current_user.current_level = "intermediate"
        else:
            self.current_user.current_level = "beginner"

        self.save_user_progress()

        return {
            "score": score,
            "feedback": feedback,
            "level": self.current_user.current_level,
            "recommendations": self.get_learning_recommendations(),
        }

    def get_personalized_learning_path(
        self, target_competencies: List[str]
    ) -> List[Dict[str, Any]]:
        """Get personalized learning path for user"""
        if not self.current_user:
            return []

        path_ids = self.learning_path_generator.generate_learning_path(
            self.current_user, target_competencies
        )

        adapted_path = []
        for obj_id in path_ids:
            adapted_content = self.learning_path_generator.adapt_to_learning_style(
                obj_id, self.current_user.preferred_learning_style
            )
            adapted_path.append(adapted_content)

        return adapted_path

    def run_virtual_experiment(
        self, experiment_id: str, user_inputs: Dict[str, Any]
    ) -> Dict[str, Any]:
        """Run virtual laboratory experiment"""
        result = self.virtual_lab.run_experiment(experiment_id, user_inputs)

        # Track experiment in user history
        if self.current_user and result.get("success"):
            experiment_record = {
                "experiment_id": experiment_id,
                "timestamp": datetime.now().isoformat(),
                "inputs": user_inputs,
                "completed": True,
            }
            self.current_user.session_history.append(experiment_record)
            self.save_user_progress()

        return result

    def get_learning_recommendations(self) -> List[str]:
        """Get learning recommendations based on current progress"""
        recommendations = []

        if not self.current_user or not self.current_user.competency_scores:
            recommendations.append("Start with basic spectroscopy concepts")
            recommendations.append("Complete the introductory assessment")
        else:
            weak_areas = [
                domain
                for domain, score in (
                    self.current_user.competency_scores.items()
                    if self.current_user
                    else {}
                )
                if score < 0.6
            ]

            for area in weak_areas:
                recommendations.append(f"Review {area} concepts")

            if not weak_areas:
                recommendations.append(
                    "Explore advanced topics in your areas of interest"
                )
                recommendations.append("Try hands-on virtual experiments")

        return recommendations

    def save_user_progress(self):
        """Save user progress to file"""
        if self.current_user:
            user_file = self.user_data_dir / f"{self.current_user.user_id}.json"
            with open(user_file, "w", encoding="utf-8") as f:
                json.dump(self.current_user.to_dict(), f, indent=2)

    def get_learning_analytics(self) -> Dict[str, Any]:
        """Get learning analytics for the current user"""
        if not self.current_user:
            return {}

        total_time = sum(
            obj.estimated_time
            for obj_id in self.current_user.completed_objectives
            for obj in [self.learning_path_generator.learning_objectives.get(obj_id)]
            if obj
        )

        return {
            "completed_objectives": len(self.current_user.completed_objectives),
            "total_study_time": total_time,
            "competency_scores": self.current_user.competency_scores,
            "current_level": self.current_user.current_level,
            "learning_style": self.current_user.preferred_learning_style,
            "session_count": len(self.current_user.session_history),
        }