app.py

# --------------------------------------------------------------
# IGCSE Science Platform – Chemistry & Biology with Deep Understanding Focus
# Models: Gemini 2.5 (Primary) → Cohere → Z.ai → MiniMax (Fallbacks)
# --------------------------------------------------------------

import os
import json
from datetime import datetime
import gradio as gr
import PyPDF2
import time
import re
from PIL import Image
import io

# ---------- 1. Configure ALL AI Systems ----------
# Gemini (Primary)
try:
    import google.generativeai as genai
    genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
    gemini_model = genai.GenerativeModel('gemini-2.5-pro')
    print("✅ Gemini AI initialized successfully (PRIMARY)")
except Exception as e:
    print(f"❌ Error initializing Gemini: {e}")
    gemini_model = None

# Cohere (Secondary)
try:
    import cohere
    cohere_client = cohere.Client(os.getenv("COHERE_API_KEY"))
    print("✅ Cohere initialized successfully (SECONDARY)")
except Exception as e:
    print(f"❌ Error initializing Cohere: {e}")
    cohere_client = None

# Z.ai (Tertiary)
try:
    from huggingface_hub import InferenceClient
    zai_client = InferenceClient(
        provider="novita",
        api_key=os.environ.get("HF_TOKEN"),
    )
    print("✅ Z.ai GLM-4.6 initialized successfully (TERTIARY)")
except Exception as e:
    print(f"❌ Error initializing Z.ai: {e}")
    zai_client = None

# MiniMax (Final Fallback)
try:
    minimax_client = InferenceClient(
        provider="novita",
        api_key=os.environ.get("HF_TOKEN"),
    )
    print("✅ MiniMax AI initialized successfully (FINAL FALLBACK)")
except Exception as e:
    print(f"❌ Error initializing MiniMax: {e}")
    minimax_client = None

# ---------- 2. Unified AI Function with Smart Fallback ----------
def ask_ai(prompt, temperature=0.7, max_retries=2):
    """
    Try models in order: Gemini → Cohere → Z.ai → MiniMax
    Returns: (response_text, source_name)
    """
    last_error = None
    
    # Try Gemini first (Primary)
    if gemini_model:
        for attempt in range(max_retries):
            try:
                response = gemini_model.generate_content(
                    prompt,
                    generation_config=genai.types.GenerationConfig(
                        temperature=temperature,
                    )
                )
                return response.text, "gemini"
            except Exception as e:
                last_error = e
                print(f"⚠ Gemini attempt {attempt+1} failed: {str(e)}")
                if attempt < max_retries - 1:
                    time.sleep(1)
    
    # Try Cohere (Secondary)
    if cohere_client:
        for attempt in range(max_retries):
            try:
                response = cohere_client.chat(
                    model="command-r-plus-08-2024",
                    message=prompt,
                    temperature=temperature
                )
                return response.text, "cohere"
            except Exception as e:
                last_error = e
                print(f"⚠ Cohere attempt {attempt+1} failed: {str(e)}")
                if attempt < max_retries - 1:
                    time.sleep(1)
    
    # Try Z.ai (Tertiary)
    if zai_client:
        for attempt in range(max_retries):
            try:
                completion = zai_client.chat.completions.create(
                    model="zai-org/GLM-4.6",
                    messages=[{"role": "user", "content": prompt}],
                    temperature=temperature
                )
                return completion.choices[0].message.content, "zai"
            except Exception as e:
                last_error = e
                print(f"⚠ Z.ai attempt {attempt+1} failed: {str(e)}")
                if attempt < max_retries - 1:
                    time.sleep(1)
    
    # Try MiniMax (Final Fallback)
    if minimax_client:
        try:
            completion = minimax_client.chat.completions.create(
                model="MiniMaxAI/MiniMax-M2",
                messages=[{"role": "user", "content": prompt}],
                temperature=temperature
            )
            return completion.choices[0].message.content, "minimax"
        except Exception as e:
            last_error = e
            print(f"⚠ MiniMax fallback failed: {str(e)}")
    
    # All failed
    error_msg = f"❌ Error: All AI services failed. Last error: {str(last_error)}"
    return error_msg, "error"

# ---------- 3. Enhanced Global Storage ----------
papers_storage = []
pdf_content_storage = {}
insert_storage = {}
questions_index = []
ADMIN_PASSWORD = "@mikaelJ46"

# ---------- 4. Comprehensive Topic Lists ----------
chemistry_topics = [
    # Principles of Chemistry
    "States of Matter", "Atoms, Elements & Compounds", "Mixtures & Separation Techniques",
    "Atomic Structure", "Electronic Configuration", "Periodic Table",
    "Chemical Bonding: Ionic", "Chemical Bonding: Covalent", "Chemical Bonding: Metallic",
    "Structure & Properties of Materials", "Nanoparticles",
    
    # Inorganic Chemistry
    "Group 1: Alkali Metals", "Group 7: Halogens", "Group 0: Noble Gases",
    "Transition Metals", "Reactivity Series", "Extraction of Metals",
    "Corrosion & Rusting", "Alloys",
    
    # Physical Chemistry
    "Chemical Reactions", "Exothermic & Endothermic Reactions", "Energy Changes",
    "Rates of Reaction", "Catalysts", "Reversible Reactions", "Equilibrium",
    "Redox Reactions", "Electrolysis", "Electrochemistry",
    
    # Acids, Bases & Salts
    "Acids & Alkalis", "pH Scale", "Neutralization", "Making Salts",
    "Titrations", "Strong & Weak Acids",
    
    # Organic Chemistry
    "Hydrocarbons: Alkanes", "Hydrocarbons: Alkenes", "Crude Oil & Fractional Distillation",
    "Polymers", "Alcohols", "Carboxylic Acids", "Organic Synthesis",
    
    # Chemistry of the Environment
    "Air Composition", "Air Pollution", "Greenhouse Effect & Climate Change",
    "Water Treatment", "Sustainable Chemistry",
    
    # Quantitative Chemistry
    "Relative Formula Mass", "Moles & Molar Mass", "Empirical & Molecular Formulae",
    "Reacting Masses", "Limiting Reactants", "Percentage Yield",
    "Gas Volumes", "Concentration Calculations",
    
    # Practical Skills
    "Laboratory Safety", "Experimental Techniques", "Analysis & Evaluation"
]

biology_topics = [
    # Cell Biology
    "Cell Structure & Function", "Specialised Cells", "Microscopy",
    "Cell Division: Mitosis", "Cell Division: Meiosis", "Stem Cells",
    "Diffusion", "Osmosis", "Active Transport",
    
    # Organisation
    "Organisation of Organisms", "Enzymes", "Digestive System",
    "Circulatory System: Heart", "Circulatory System: Blood Vessels", "Blood Components",
    "Respiratory System", "Gas Exchange", "Breathing Mechanism",
    
    # Infection & Response
    "Communicable Diseases", "Pathogens: Bacteria & Viruses", "Disease Prevention",
    "Immune System", "Vaccination", "Antibiotics & Painkillers",
    "Developing New Medicines", "Monoclonal Antibodies",
    
    # Bioenergetics
    "Photosynthesis", "Factors Affecting Photosynthesis", "Uses of Glucose",
    "Respiration: Aerobic", "Respiration: Anaerobic", "Metabolism",
    
    # Homeostasis & Response
    "Homeostasis Principles", "Nervous System", "Reflex Actions", "Brain Structure",
    "Eye Structure & Function", "Body Temperature Control",
    "Endocrine System", "Hormones", "Blood Glucose Regulation",
    "Diabetes", "Water & Nitrogen Balance", "Kidneys & Dialysis",
    
    # Inheritance, Variation & Evolution
    "DNA Structure", "Protein Synthesis", "Genetic Inheritance",
    "Inherited Disorders", "Sex Determination", "Genetic Diagrams",
    "Variation", "Evolution", "Natural Selection", "Selective Breeding",
    "Genetic Engineering", "Cloning", "Classification",
    
    # Ecology
    "Ecosystems", "Food Chains & Webs", "Energy Transfer",
    "Nutrient Cycles: Carbon", "Nutrient Cycles: Water", "Nutrient Cycles: Nitrogen",
    "Biodiversity", "Habitat Loss", "Conservation",
    "Population Dynamics", "Competition", "Adaptations",
    "Waste Management", "Pollution", "Global Warming Impact",
    "Deforestation", "Sustainable Development",
    
    # Practical Skills
    "Scientific Method", "Variables & Controls", "Data Analysis",
    "Biological Techniques", "Field Studies"
]

# ---------- 5. Enhanced PDF Processing ----------
def extract_text_from_pdf(pdf_file):
    """Extract text from uploaded PDF file"""
    if pdf_file is None:
        return ""
    try:
        pdf_reader = PyPDF2.PdfReader(pdf_file)
        text = ""
        for page in pdf_reader.pages:
            text += page.extract_text() + "\n"
        return text
    except Exception as e:
        return f"Error extracting PDF: {e}"

def identify_paper_details(text, filename):
    """Use AI to identify paper year, series, variant, and subject from content"""
    sample_text = text[:2000] if len(text) > 2000 else text
    
    prompt = f"""Analyze this IGCSE science past paper and identify its details.

Filename: {filename}
Paper Text Sample:
{sample_text}

Identify and return ONLY a JSON object with:
- subject: "Chemistry" or "Biology"
- year: The year (e.g., "2023", "2022")
- series: The exam series (e.g., "June", "November", "May/June", "October/November")
- variant: The paper variant (e.g., "1", "2", "3" or "11", "12", "21", "22")
- paper_number: The paper number (e.g., "1", "2", "3", "4", "6")
- syllabus_code: If visible (e.g., "0620" for Chemistry, "0610" for Biology)

Look for clues like "Cambridge IGCSE", subject codes, dates, paper numbers.

Return ONLY valid JSON (no markdown):
{{"subject": "...", "year": "...", "series": "...", "variant": "...", "paper_number": "...", "syllabus_code": "..."}}"""
    
    try:
        response, _ = ask_ai(prompt, temperature=0.1)
        clean_txt = response.replace("```json", "").replace("```", "").strip()
        details = json.loads(clean_txt)
        return details
    except Exception as e:
        print(f"Error identifying paper details: {e}")
        return parse_filename_for_details(filename)

def parse_filename_for_details(filename):
    """Fallback: Parse filename for paper details"""
    details = {
        "subject": "Unknown",
        "year": "Unknown",
        "series": "Unknown",
        "variant": "Unknown",
        "paper_number": "Unknown",
        "syllabus_code": "Unknown"
    }
    
    # Extract year
    year_match = re.search(r'(20\d{2})|(\d{2}(?=_[wsmj]|[WS]))', filename)
    if year_match:
        year = year_match.group(1) or ("20" + year_match.group(2))
        details["year"] = year
    
    # Extract series
    if re.search(r'[Jj]une?|[Mm]ay[_/-]?[Jj]une?|mj|MJ', filename):
        details["series"] = "May/June"
    elif re.search(r'[Nn]ov(ember)?|[Oo]ct(ober)?|ON', filename):
        details["series"] = "October/November"
    elif re.search(r'[Mm]ar(ch)?|[Ff]eb(ruary)?|FM', filename):
        details["series"] = "February/March"
    
    # Extract variant
    variant_match = re.search(r'[Vv]ariant[_\s]?(\d)|[Pp]aper[_\s]?(\d{1,2})|_qp_(\d{1,2})', filename)
    if variant_match:
        details["variant"] = variant_match.group(1) or variant_match.group(2) or variant_match.group(3)
    
    # Extract syllabus code and subject
    code_match = re.search(r'\b(0\d{3})\b', filename)
    if code_match:
        details["syllabus_code"] = code_match.group(1)
        code_subject_map = {
            '0620': 'Chemistry', '0610': 'Biology'
        }
        details["subject"] = code_subject_map.get(code_match.group(1), "Unknown")
    
    return details

def extract_questions_from_text(text, paper_id, paper_title, subject, paper_details):
    """Use AI to intelligently extract questions from past paper text"""
    if not text or len(text) < 100:
        return []
    
    prompt = f"""Analyze this IGCSE {subject} past paper and extract ALL questions.

Paper Details:
- Subject: {subject}
- Year: {paper_details.get('year', 'Unknown')}
- Series: {paper_details.get('series', 'Unknown')}
- Paper: {paper_details.get('paper_number', 'Unknown')}
- Variant: {paper_details.get('variant', 'Unknown')}

Paper Text:
{text[:8000]}

Extract each question and return as JSON array. For each question include:
- question_number (e.g., "1(a)", "2(b)(i)")
- question_text (the complete question)
- marks (number of marks)
- topic (specific IGCSE {subject} topic)
- requires_insert (true/false - references diagrams, figures, data?)
- question_type (e.g., "multiple choice", "structured", "practical", "calculation", "explanation")

Return ONLY valid JSON array (no markdown):
[{{"question_number": "1(a)", "question_text": "...", "marks": 2, "topic": "...", "requires_insert": false, "question_type": "..."}}]"""
    
    try:
        response, _ = ask_ai(prompt, temperature=0.2)
        clean_txt = response.replace("```json", "").replace("```", "").strip()
        questions = json.loads(clean_txt)
        
        for q in questions:
            q['paper_id'] = paper_id
            q['paper_title'] = paper_title
            q['subject'] = subject
            q['year'] = paper_details.get('year', 'Unknown')
            q['series'] = paper_details.get('series', 'Unknown')
            q['variant'] = paper_details.get('variant', 'Unknown')
            q['paper_number'] = paper_details.get('paper_number', 'Unknown')
            q['syllabus_code'] = paper_details.get('syllabus_code', 'Unknown')
        
        return questions
    except Exception as e:
        print(f"Error extracting questions: {e}")
        return extract_questions_fallback(text, paper_id, paper_title, subject, paper_details)

def extract_questions_fallback(text, paper_id, paper_title, subject, paper_details):
    """Fallback method using regex patterns"""
    questions = []
    pattern = r'(\d+(?:\([a-z]\))?(?:\([ivx]+\))?)\s+(.{20,500}?)\[(\d+)\]'
    matches = re.finditer(pattern, text, re.IGNORECASE)
    
    for match in matches:
        q_num = match.group(1)
        q_text = match.group(2).strip()
        marks = int(match.group(3))
        
        questions.append({
            'question_number': q_num,
            'question_text': q_text,
            'marks': marks,
            'topic': 'General',
            'requires_insert': bool(re.search(r'Fig\.|diagram|table|graph|data|shown', q_text, re.IGNORECASE)),
            'question_type': 'structured',
            'paper_id': paper_id,
            'paper_title': paper_title,
            'subject': subject,
            'year': paper_details.get('year', 'Unknown'),
            'series': paper_details.get('series', 'Unknown'),
            'variant': paper_details.get('variant', 'Unknown'),
            'paper_number': paper_details.get('paper_number', 'Unknown'),
            'syllabus_code': paper_details.get('syllabus_code', 'Unknown')
        })
    
    return questions

def process_insert_file(insert_file):
    """Process insert file (PDF or image)"""
    if insert_file is None:
        return None, None
    
    try:
        file_name = insert_file.name
        file_ext = file_name.lower().split('.')[-1]
        
        if file_ext == 'pdf':
            text = extract_text_from_pdf(insert_file)
            return text, "pdf"
        elif file_ext in ['jpg', 'jpeg', 'png', 'gif']:
            image = Image.open(insert_file)
            return image, "image"
        else:
            return None, None
    except Exception as e:
        print(f"Error processing insert: {e}")
        return None, None

# ---------- 6. Deep Understanding AI Tutor ----------
def ai_tutor_chat(message, history, subject, topic):
    """AI tutor focused on deep understanding and conceptual clarity"""
    if not message.strip():
        return history

    subject_context = {
        "Chemistry": """You are an expert IGCSE Chemistry tutor who prioritizes DEEP UNDERSTANDING over memorization.

Your teaching approach:
- Always explain the WHY behind chemical phenomena (not just the what)
- Connect microscopic (atomic/molecular) behavior to macroscopic observations
- Use real-world examples and applications to make concepts tangible
- Break down complex reactions into step-by-step mechanisms
- Emphasize patterns and relationships (e.g., periodic trends, reaction types)
- Address common misconceptions directly
- Use analogies and visual descriptions to clarify abstract concepts
- Encourage students to predict outcomes based on understanding, not memorization
- Link different topics together (e.g., bonding → properties → reactivity)

Key teaching principles:
- Particle theory underlies everything (structure determines properties)
- Energy changes drive chemical processes
- Conservation laws (mass, charge, energy) are fundamental
- Equilibrium and rates are about competing processes""",

        "Biology": """You are an expert IGCSE Biology tutor who emphasizes DEEP UNDERSTANDING and interconnected thinking.

Your teaching approach:
- Always explain biological processes in terms of structure-function relationships
- Connect molecular/cellular processes to organism-level phenomena
- Use real-world health, ecology, and evolution examples
- Explain mechanisms step-by-step (don't just list facts)
- Emphasize the REASONS for biological adaptations and processes
- Address common misconceptions about evolution, genetics, and body systems
- Use analogies to make complex processes accessible (but explain their limits)
- Show how different biological systems interact and depend on each other
- Encourage students to apply knowledge to novel situations
- Link topics together (e.g., respiration → transport → gas exchange)

Key teaching principles:
- Evolution by natural selection explains adaptations
- Enzymes control the rate of life processes
- Homeostasis maintains stable internal conditions
- Energy flow and nutrient cycling connect ecology
- DNA → RNA → protein → trait (central dogma)"""
    }

    system = f"""{subject_context[subject]}

Current focus: {topic or 'any topic'}

When answering:
1. Check for understanding gaps before giving the full answer
2. Use the Socratic method - guide thinking with questions
3. Provide detailed step-by-step explanations with reasoning
4. Include diagrams descriptions when helpful
5. Give practice examples for students to try
6. Connect to exam skills (command words, mark schemes)
7. Celebrate curiosity and deeper questions

Remember: Understanding beats memorization. Help students THINK like scientists."""
    
    # Build conversation context
    conversation = ""
    for user_msg, bot_msg in history[-6:]:
        if user_msg:
            conversation += f"Student: {user_msg}\n"
        if bot_msg:
            clean_msg = bot_msg.replace("🔵 ", "").replace("🟢 ", "").replace("🟣 ", "")
            conversation += f"Tutor: {clean_msg}\n"
    
    conversation += f"Student: {message}\nTutor:"
    full_prompt = f"{system}\n\nConversation:\n{conversation}"
    
    bot_response, source = ask_ai(full_prompt, temperature=0.7)
    
    # Add source indicator
    if source == "cohere":
        bot_response = f"🔵 {bot_response}"
    elif source == "zai":
        bot_response = f"🟢 {bot_response}"
    elif source == "minimax":
        bot_response = f"🟣 {bot_response}"
    
    history.append((message, bot_response))
    return history

def clear_chat():
    return []

# ---------- 7. Concept Explainer with Depth ----------
def explain_concept(subject, concept):
    """Deep dive explanation of scientific concepts"""
    if not concept:
        return "Enter a concept to explain!"
    
    prompt = f"""Provide a COMPREHENSIVE explanation of this IGCSE {subject} concept: "{concept}"

Structure your explanation as follows:

**1. CORE IDEA** (In simple terms - what IS it?)

**2. DEEPER UNDERSTANDING** (Why does it work this way? What's the mechanism?)

**3. KEY DETAILS & FACTS** (Important specifics students need to know)

**4. COMMON MISCONCEPTIONS** (What do students often get wrong?)

**5. REAL-WORLD CONNECTIONS** (Where do we see this? Why does it matter?)

**6. EXAM TIPS** (What questions test this? How to approach them?)

**7. PRACTICE THINKING** (A question to test understanding)

Use clear language, step-by-step reasoning, and helpful analogies.
Make connections to other topics. Focus on UNDERSTANDING, not just facts."""
    
    response, source = ask_ai(prompt, temperature=0.5)
    
    if source in ["cohere", "zai", "minimax"]:
        response = f"{response}\n\n_[Explained by {source.title()}]_"
    
    return response

# ---------- 8. Calculation Helper ----------
def solve_calculation(subject, problem, show_steps):
    """Step-by-step calculation solver with conceptual explanation"""
    if not problem.strip():
        return "Enter a calculation problem!"
    
    steps_instruction = "Show EVERY step with full working" if show_steps else "Show key steps"
    
    prompt = f"""Solve this IGCSE {subject} calculation problem with DEEP EXPLANATION:

Problem: {problem}

Provide:
1. **What we're finding**: Identify what the question asks for
2. **What we know**: List given information and its meaning
3. **Formula/Concept**: Which formula/principle applies and WHY
4. **Step-by-step solution**: {steps_instruction} with units
5. **Checking**: Does the answer make sense? Why?
6. **Concept explanation**: What does this result mean scientifically?
7. **Common mistakes**: What errors do students typically make?
8. **Related problems**: Similar question types to practice

Use clear formatting. Explain the reasoning at each step, not just the math."""
    
    response, source = ask_ai(prompt, temperature=0.3)
    
    if source in ["cohere", "zai", "minimax"]:
        response = f"{response}\n\n_[Solved by {source.title()}]_"
    
    return response

# ---------- 9. Experiment Analyzer ----------
def analyze_experiment(subject, experiment_description, question):
    """Analyze experiments and practical work with scientific reasoning"""
    if not experiment_description.strip():
        return "Describe the experiment!"
    
    prompt = f"""Analyze this IGCSE {subject} experiment with focus on SCIENTIFIC THINKING:

Experiment: {experiment_description}

Question: {question if question else "Analyze this experiment comprehensively"}

Provide:
1. **Aim**: What is being investigated and why?
2. **Science Behind It**: What principles/concepts does this test?
3. **Method Analysis**: Why is it done this way? What makes it valid?
4. **Variables**: Independent, dependent, control variables and why they matter
5. **Expected Results**: What should happen and WHY (predict using theory)
6. **Safety & Practical Tips**: Important precautions and techniques
7. **Possible Errors**: What could go wrong? How to minimize errors?
8. **Results Analysis**: How to interpret data scientifically
9. **Evaluation**: How could this experiment be improved?
10. **Exam Connection**: How might this be tested?

Think like a scientist - connect method to theory."""
    
    response, source = ask_ai(prompt, temperature=0.4)
    
    if source in ["cohere", "zai", "minimax"]:
        response = f"{response}\n\n_[Analyzed by {source.title()}]_"
    
    return response

# ---------- 10. Enhanced Practice Questions ----------
def generate_question(subject, topic, difficulty):
    """Generate practice questions with focus on understanding"""
    if not topic:
        return "Select a topic!", "", ""
    
    difficulty_guide = {
        "Easy": "Test basic understanding and recall. Simple calculations or describe questions.",
        "Medium": "Test application and analysis. Require explanations and connections.",
        "Hard": "Test evaluation and synthesis. Multi-step problems, novel scenarios."
    }
    
    pdf_context = ""
    for paper_id, content in pdf_content_storage.items():
        paper = next((p for p in papers_storage if p['id'] == paper_id), None)
        if paper and paper['subject'] == subject:
            pdf_context += f"\n\nReference: {paper['title']}:\n{content[:2000]}"
    
    prompt = f"""Create ONE high-quality IGCSE {subject} exam question on: "{topic}"

Difficulty: {difficulty} - {difficulty_guide[difficulty]}
{f"Base style on: {pdf_context[:1500]}" if pdf_context else "Create authentic exam-style question."}

The question should:
- Test UNDERSTANDING, not just recall
- Use appropriate command words (describe, explain, evaluate, calculate, etc.)
- Be worth 4-8 marks
- Include context/data if relevant
- Test ability to apply knowledge to new situations

Return ONLY valid JSON (no markdown):
{{
    "question": "complete question with all context",
    "marks": 6,
    "command_word": "explain/describe/calculate/etc",
    "expectedAnswer": "detailed key points with scientific reasoning",
    "markScheme": "specific mark allocations and what earns each mark",
    "understandingTips": "what concepts students need to understand to answer this"
}}"""
    
    response, source = ask_ai(prompt, temperature=0.4)
    
    try:
        clean_txt = response.replace("```json", "").replace("```", "").strip()
        data = json.loads(clean_txt)
        
        question_text = f"**[{data['marks']} marks] - {data['command_word'].upper()}**\n\n{data['question']}"
        expected = f"**Understanding Required:**\n{data.get('understandingTips', '')}\n\n**Key Points:**\n{data['expectedAnswer']}"
        marks = data['markScheme']
        
        return question_text, expected, marks
    except:
        return response, "", "Error parsing response"

def check_answer(question, expected, user_answer, subject):
    """Check answers with focus on understanding and reasoning"""
    if not user_answer.strip():
        return "Write your answer first!"
    
    prompt = f"""Evaluate this IGCSE {subject} answer focusing on UNDERSTANDING and SCIENTIFIC REASONING:

Question: {question}

Expected answer points: {expected}

Student's answer:
{user_answer}

Assess:
1. Scientific accuracy
2. Depth of understanding (not just memorization)
3. Use of scientific terminology
4. Logical reasoning and explanations
5. Answering the specific command word
6. Completeness

Return JSON (no markdown):
{{
    "score": 0-100,
    "marks": "X/8",
    "understanding_level": "surface/developing/strong/excellent",
    "feedback": "detailed feedback on scientific understanding",
    "strengths": "what shows good understanding",
    "improvements": "how to deepen understanding",
    "misconceptions": "any misunderstandings evident",
    "examTips": "exam technique advice",
    "followUpQuestion": "a question to test/extend understanding further"
}}"""
    
    response, source = ask_ai(prompt, temperature=0.3)
    
    try:
        clean_txt = response.replace("```json", "").replace("```", "").strip()
        fb = json.loads(clean_txt)
        
        result = f"""📊 **Score: {fb['score']}% ({fb['marks']})**
**Understanding Level:** {fb['understanding_level'].upper()}

📝 **Detailed Feedback:**
{fb['feedback']}

✅ **Your Strengths:**
{fb['strengths']}

📈 **How to Deepen Understanding:**
{fb['improvements']}

⚠️ **Misconceptions to Address:**
{fb.get('misconceptions', 'None identified')}

💡 **Exam Tips:**
{fb['examTips']}

🤔 **Think Further:**
{fb.get('followUpQuestion', 'Keep practicing!')}"""
        
        if source in ["cohere", "zai", "minimax"]:
            result += f"\n\n_[Graded by {source.title()}]_"
        
        return result
    except:
        return response

# ---------- 11. Past Papers Browser ----------
def search_questions_by_topic(subject, topic):
    """Search for questions matching a specific topic"""
    if not questions_index:
        return "📭 No questions available yet. Admin needs to upload past papers first!"
    
    matching = [q for q in questions_index 
                if q['subject'] == subject and 
                (topic.lower() in q['topic'].lower() or topic.lower() in q['question_text'].lower())]
    
    if not matching:
        return f"📭 No questions found for {topic} in {subject}. Try a different topic or broader search."
    
    result = f"### 🎯 Found {len(matching)} question(s) on '{topic}' in {subject}\n\n"
    
    for i, q in enumerate(matching, 1):
        insert_note = " 🖼️ **[Requires Insert]**" if q.get('requires_insert') else ""
        q_type = f" ({q.get('question_type', 'structured')})" if q.get('question_type') else ""
        
        paper_info = f"**{q['year']} {q['series']}** - Paper {q['paper_number']}"
        if q.get('variant') != 'Unknown':
            paper_info += f" Variant {q['variant']}"
        if q.get('syllabus_code') != 'Unknown':
            paper_info += f" ({q['syllabus_code']})"
        
        result += f"""**Question {i}** - {paper_info}
📝 **{q['question_number']}** [{q['marks']} marks]{q_type}{insert_note}
{q['question_text']}

{'─'*80}
"""
    
    return result

def view_papers_student(subject):
    """View all papers for a subject"""
    filtered = [p for p in papers_storage if p["subject"] == subject]
    if not filtered:
        return f"📭 No {subject} papers available."
    
    result = ""
    for p in filtered:
        insert_note = " 🖼️ Insert Available" if p['id'] in insert_storage else ""
        q_count = len([q for q in questions_index if q['paper_id'] == p['id']])
        
        paper_details = p.get('paper_details', {})
        year = paper_details.get('year', 'Unknown')
        series = paper_details.get('series', 'Unknown')
        variant = paper_details.get('variant', 'Unknown')
        paper_num = paper_details.get('paper_number', 'Unknown')
        syllabus = paper_details.get('syllabus_code', 'Unknown')
        
        paper_info = f"**{year} {series}** - Paper {paper_num}"
        if variant != 'Unknown':
            paper_info += f" Variant {variant}"
        if syllabus != 'Unknown':
            paper_info += f" ({syllabus})"
        
        result += f"""**{p['title']}** {'📄 PDF' if p.get('has_pdf') else ''}{insert_note}
{paper_info}
⏰ Uploaded: {p['uploaded_at']} | 📝 {q_count} questions extracted
{p['content'][:200]}...

{'═'*80}
"""
    
    return result

# ---------- 12. Admin Functions ----------
def verify_admin_password(password):
    if password == ADMIN_PASSWORD:
        return gr.update(visible=True), gr.update(visible=False), "✅ Access granted!"
    return gr.update(visible=False), gr.update(visible=True), "❌ Incorrect password!"

def upload_paper(title, subject, content, pdf_file, insert_file):
    """Upload past papers with AI extraction"""
    if not all([title, subject, content]):
        return "⚠ Please fill all required fields!", get_papers_list(), "📊 Status: Waiting for upload"
    
    paper_id = len(papers_storage) + 1
    
    pdf_text = ""
    paper_details = {}
    if pdf_file is not None:
        pdf_text = extract_text_from_pdf(pdf_file)
        if pdf_text and not pdf_text.startswith("Error"):
            paper_details = identify_paper_details(pdf_text, pdf_file.name)
            pdf_content_storage[paper_id] = pdf_text
            
            detail_str = f"\n\n📋 **Paper Details:**"
            detail_str += f"\n- Year: {paper_details.get('year', 'Unknown')}"
            detail_str += f"\n- Series: {paper_details.get('series', 'Unknown')}"
            detail_str += f"\n- Paper: {paper_details.get('paper_number', 'Unknown')}"
            detail_str += f"\n- Variant: {paper_details.get('variant', 'Unknown')}"
            if paper_details.get('syllabus_code') != 'Unknown':
                detail_str += f"\n- Syllabus Code: {paper_details.get('syllabus_code')}"
            content += detail_str
            content += f"\n[📄 PDF extracted: {len(pdf_text)} characters]"
    
    insert_data = None
    insert_type = None
    if insert_file is not None:
        insert_data, insert_type = process_insert_file(insert_file)
        if insert_data:
            insert_storage[paper_id] = (insert_data, insert_type)
            content += f"\n[🖼️ Insert attached: {insert_type}]"
    
    papers_storage.append({
        "id": paper_id,
        "title": title,
        "subject": subject,
        "content": content,
        "has_pdf": bool(pdf_text and not pdf_text.startswith("Error")),
        "has_insert": bool(insert_data),
        "paper_details": paper_details,
        "uploaded_at": datetime.now().strftime("%Y-%m-%d %H:%M")
    })
    
    status_msg = "✅ Paper uploaded!"
    if pdf_text and not pdf_text.startswith("Error"):
        status_msg += "\n⏳ AI is extracting questions..."
        questions = extract_questions_from_text(pdf_text, paper_id, title, subject, paper_details)
        questions_index.extend(questions)
        
        paper_info = f"{paper_details.get('year', 'Unknown')} {paper_details.get('series', 'Unknown')}"
        if paper_details.get('variant') != 'Unknown':
            paper_info += f" Variant {paper_details.get('variant')}"
        
        status_msg += f"\n✅ Extracted {len(questions)} questions from **{paper_info}**!"
        status_msg += f"\n📋 Identified as: {subject} Paper {paper_details.get('paper_number', 'Unknown')}"
    
    return status_msg, get_papers_list(), f"📊 Total papers: {len(papers_storage)} | Total questions: {len(questions_index)}"

def get_papers_list():
    """Get formatted list of all papers"""
    if not papers_storage:
        return "No papers yet."
    
    result = []
    for p in papers_storage:
        paper_details = p.get('paper_details', {})
        year = paper_details.get('year', 'Unknown')
        series = paper_details.get('series', 'Unknown')
        variant = paper_details.get('variant', 'Unknown')
        paper_num = paper_details.get('paper_number', 'Unknown')
        
        paper_info = f"{year} {series} - Paper {paper_num}"
        if variant != 'Unknown':
            paper_info += f" V{variant}"
        
        insert_icon = '🖼️ Insert' if p.get('has_insert') else ''
        pdf_icon = '📄 PDF' if p.get('has_pdf') else ''
        
        result.append(f"**{p['title']}** ({p['subject']}) {pdf_icon} {insert_icon}\n{paper_info}\n⏰ {p['uploaded_at']}\n{p['content'][:120]}...\n{'─'*60}")
    
    return "\n".join(result)

# ---------- 13. Gradio UI ----------
with gr.Blocks(theme=gr.themes.Soft(), title="IGCSE Science Platform") as app:
    gr.Markdown("""
    # 🔬 IGCSE Science Learning Platform
    Chemistry ⚗️ | Biology 🧬
    _Deep Understanding Through AI-Powered Learning_
    """)

    with gr.Tabs():
        # ───── STUDENT PORTAL ─────
        with gr.Tab("👨‍🎓 Student Portal"):
            with gr.Tabs():
                # AI TUTOR
                with gr.Tab("🤖 AI Tutor - Deep Understanding"):
                    gr.Markdown("""### Chat with Your AI Science Tutor
*Focus on understanding WHY, not just memorizing facts*

**Tips for getting the most from your tutor:**
- Ask "why" and "how" questions
- Request step-by-step explanations
- Ask for real-world examples
- Challenge yourself with "what if" scenarios""")
                    
                    with gr.Row():
                        subj = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                        topc = gr.Dropdown(chemistry_topics, label="Topic (optional)", allow_custom_value=True)

                    def update_topics(s):
                        topics = {"Chemistry": chemistry_topics, "Biology": biology_topics}
                        return gr.Dropdown(choices=topics[s], value=None)
                    subj.change(update_topics, subj, topc)

                    chat = gr.Chatbot(height=500, show_label=False)
                    txt = gr.Textbox(placeholder="Ask anything... e.g., 'Why do ionic compounds conduct electricity when molten but not when solid?'", label="Message")
                    with gr.Row():
                        send = gr.Button("Send 📤", variant="primary")
                        clr = gr.Button("Clear 🗑")
                    
                    send.click(ai_tutor_chat, [txt, chat, subj, topc], chat)
                    txt.submit(ai_tutor_chat, [txt, chat, subj, topc], chat)
                    clr.click(clear_chat, outputs=chat)

                # CONCEPT EXPLAINER
                with gr.Tab("💡 Concept Explainer"):
                    gr.Markdown("""### Deep Dive into Scientific Concepts
*Get comprehensive explanations that build real understanding*""")
                    
                    with gr.Row():
                        ce_subj = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                        ce_concept = gr.Textbox(label="Concept to Explain", 
                                               placeholder="e.g., 'covalent bonding', 'osmosis', 'enzyme action'")
                    
                    ce_output = gr.Markdown(label="Explanation")
                    gr.Button("🔍 Explain Concept", variant="primary", size="lg").click(
                        explain_concept, [ce_subj, ce_concept], ce_output
                    )

                # CALCULATION HELPER
                with gr.Tab("🧮 Calculation Helper"):
                    gr.Markdown("""### Step-by-Step Problem Solving
*Understand the reasoning, not just the answer*""")
                    
                    calc_subj = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                    calc_problem = gr.Textbox(lines=4, label="Problem", 
                                            placeholder="e.g., 'Calculate the mass of calcium carbonate needed to produce 22g of carbon dioxide'")
                    calc_steps = gr.Checkbox(label="Show detailed steps", value=True)
                    calc_output = gr.Markdown(label="Solution")
                    
                    gr.Button("✏️ Solve Problem", variant="primary", size="lg").click(
                        solve_calculation, [calc_subj, calc_problem, calc_steps], calc_output
                    )

                # EXPERIMENT ANALYZER
                with gr.Tab("🔬 Experiment Analyzer"):
                    gr.Markdown("""### Understand Scientific Investigations
*Connect practical work to theory*""")
                    
                    exp_subj = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                    exp_desc = gr.Textbox(lines=5, label="Experiment Description", 
                                         placeholder="Describe the experiment setup and procedure...")
                    exp_q = gr.Textbox(label="Specific Question (optional)", 
                                      placeholder="e.g., 'Why must we use excess acid in this experiment?'")
                    exp_output = gr.Markdown(label="Analysis")
                    
                    gr.Button("🔍 Analyze Experiment", variant="primary", size="lg").click(
                        analyze_experiment, [exp_subj, exp_desc, exp_q], exp_output
                    )

                # PAST PAPERS BROWSER
                with gr.Tab("📚 Past Papers Browser"):
                    gr.Markdown("""### 🎯 Search Real Exam Questions by Topic
*Practice with actual IGCSE questions*""")
                    
                    with gr.Row():
                        pp_subject = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                        pp_topic = gr.Dropdown(chemistry_topics, label="Select Topic")
                    
                    pp_subject.change(update_topics, pp_subject, pp_topic)
                    
                    search_btn = gr.Button("🔍 Search Questions", variant="primary", size="lg")
                    questions_output = gr.Markdown(label="Questions Found", value="Select a topic and click Search")
                    
                    search_btn.click(search_questions_by_topic, [pp_subject, pp_topic], questions_output)
                    
                    gr.Markdown("---\n### 📄 Browse All Papers")
                    browse_subject = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                    papers_display = gr.Markdown(label="Available Papers")
                    gr.Button("📖 Show All Papers").click(view_papers_student, browse_subject, papers_display)

                # PRACTICE QUESTIONS
                with gr.Tab("✍ Practice Questions"):
                    gr.Markdown("""### Generate & Practice Exam Questions
*Focus on understanding, not just correct answers*""")
                    
                    with gr.Row():
                        ps = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                        pt = gr.Dropdown(chemistry_topics, label="Topic")
                        diff = gr.Radio(["Easy", "Medium", "Hard"], label="Difficulty", value="Medium")
                    
                    ps.change(update_topics, ps, pt)

                    q = gr.Textbox(label="📝 Question", lines=8, interactive=False)
                    exp = gr.Textbox(label="Understanding Required & Expected Points", lines=6, interactive=False)
                    mark = gr.Textbox(label="📊 Mark Scheme", lines=5, interactive=False)
                    ans = gr.Textbox(lines=12, label="✏ Your Answer", 
                                    placeholder="Write your answer here. Focus on explaining your reasoning...")
                    fb = gr.Textbox(lines=18, label="📋 Detailed Feedback", interactive=False)

                    with gr.Row():
                        gr.Button("🎲 Generate Question", variant="primary").click(
                            generate_question, [ps, pt, diff], [q, exp, mark]
                        )
                        gr.Button("✅ Check Answer", variant="secondary").click(
                            check_answer, [q, exp, ans, ps], fb
                        )

        # ───── ADMIN PANEL ─────
        with gr.Tab("🔐 Admin Panel"):
            with gr.Column() as login_section:
                gr.Markdown("### 🔐 Admin Login")
                pwd = gr.Textbox(label="Password", type="password", placeholder="Enter admin password")
                login_btn = gr.Button("🔓 Login", variant="primary")
                login_status = gr.Textbox(label="Status", interactive=False)
            
            with gr.Column(visible=False) as admin_section:
                gr.Markdown("""### 📤 Upload Past Papers & Resources
                
**Instructions:**
1. **Title**: e.g., "Paper 2 Chemistry - June 2023"
2. **Subject**: Select Chemistry or Biology
3. **Content**: Add description, syllabus code (0620 Chemistry, 0610 Biology), or notes
4. **PDF**: Upload the actual past paper (questions will be auto-extracted)
5. **Insert**: Upload any accompanying insert/resource booklet

The AI will automatically:
- Identify paper details (year, series, variant)
- Extract all questions with topics
- Index them for student search
- Store insert materials for reference
""")
                
                with gr.Row():
                    with gr.Column():
                        t = gr.Textbox(label="📋 Title", placeholder="e.g., Paper 2 Chemistry - October/November 2023")
                        s = gr.Radio(["Chemistry", "Biology"], label="Subject", value="Chemistry")
                        c = gr.Textbox(lines=5, label="Content/Description", 
                                      placeholder="Add notes, syllabus code (0620/0610), or instructions...")
                        pdf = gr.File(label="📄 Past Paper PDF (questions will be extracted)", file_types=[".pdf"])
                        insert = gr.File(label="🖼️ Insert/Resource Booklet (optional)", 
                                        file_types=[".pdf", ".jpg", ".jpeg", ".png"])
                        
                        up = gr.Button("⬆ Upload Paper", variant="primary", size="lg")
                        st = gr.Textbox(label="Upload Status", lines=4)
                        stats = gr.Textbox(label="📊 Database Statistics", value="📊 Status: No papers uploaded yet")
                    
                    with gr.Column():
                        gr.Markdown("### 📚 All Uploaded Papers")
                        lst = gr.Textbox(lines=26, label="Papers Database", value=get_papers_list(), 
                                        interactive=False, show_label=False)
                
                up.click(upload_paper, [t, s, c, pdf, insert], [st, lst, stats])
            
            login_btn.click(verify_admin_password, [pwd], [admin_section, login_section, login_status])

    gr.Markdown("""
    ---
    **System Status:** 🟢 Gemini AI (Primary) | 🔵 Cohere (Secondary) | 🟢 Z.ai (Tertiary) | 🟣 MiniMax (Fallback)
    
    **Key Features:**
    - 🧠 **Deep Understanding Focus**: AI emphasizes WHY, not just WHAT
    - 🎯 Smart question extraction and topic-based search
    - 🖼️ Insert/resource support for diagrams and data
    - 🔍 Comprehensive concept explanations
    - 🧮 Step-by-step calculation support
    - 🔬 Experiment analysis with theory connections
    - 🤖 Multi-AI fallback system for reliability
    
    **Teaching Philosophy:**
    - Structure determines function
    - Understanding beats memorization
    - Connect concepts across topics
    - Apply knowledge to novel situations
    """)

app.launch()