Update app.py

app.py

@@ -1,7 +1,6 @@
 """
 SEA Prep Pro - AI-Powered Tutor 🇹🇹
 FULLY FREE VERSION - No API Keys Required!
-Uses local models and open-source libraries
 """
 import gradio as gr
 import sqlite3
@@ -9,39 +8,16 @@ import json
 import os
 import re
 import random
-import requests
-from datetime import datetime, timedelta
-from typing import List, Dict, Optional, Tuple
-import threading
-import time
-import hashlib
 import math
+import threading
+from datetime import datetime
 
-# ==================== FREE AI ALTERNATIVES ====================
-# We'll use rule-based AI and local models via Hugging Face's free inference API
-# No API key needed for public models!
-
+# ==================== FREE AI TUTOR ====================
 class FreeAITutor:
-    """Free AI tutor using rule-based generation and public models"""
+    """Free AI tutor using rule-based generation"""
     
     def __init__(self):
-        self.math_patterns = {
-            "addition": r"(\d+)\s*\+\s*(\d+)",
-            "subtraction": r"(\d+)\s*-\s*(\d+)",
-            "multiplication": r"(\d+)\s*[x×]\s*(\d+)",
-            "division": r"(\d+)\s*÷\s*(\d+)",
-            "fraction": r"(\d+)/(\d+)"
-        }
-        
-        self.grammar_rules = {
-            "is_are": [("he is", "she is", "it is"), ("they are", "we are", "you are")],
-            "was_were": [("i was", "he was", "she was"), ("they were", "we were")],
-            "has_have": [("he has", "she has"), ("i have", "they have", "we have")]
-        }
-    
-    def generate_math_question(self, topic, difficulty):
-        """Generate math questions using templates"""
-        templates = {
+        self.math_templates = {
             "Fractions": [
                 "Simplify the fraction {num}/{den}.",
                 "Add {a}/{b} + {c}/{d}.",
@@ -49,42 +25,33 @@ class FreeAITutor:
                 "What is {num}/{den} of {whole}?",
                 "Convert {decimal} to a fraction."
             ],
-            "Decimals": [
-                "Add {a}.{b} + {c}.{d}",
-                "Subtract {a}.{b} - {c}.{d}",
-                "Multiply {a}.{b} × {c}",
-                "Divide {a}.{b} ÷ {c}",
-                "Round {num}.{dec} to the nearest {place}."
-            ],
-            "Percentages": [
-                "What is {percent}% of {number}?",
-                "{number} is what percent of {total}?",
-                "Increase {number} by {percent}%.",
-                "Decrease {number} by {percent}%.",
-                "Find the percentage change from {old} to {new}."
-            ],
             "Geometry": [
                 "Find the area of a rectangle with length {l}cm and width {w}cm.",
                 "Calculate the perimeter of a square with side {s}cm.",
                 "Find the area of a triangle with base {b}cm and height {h}cm.",
                 "Calculate the circumference of a circle with radius {r}cm (use π=3.14).",
                 "Find the volume of a cube with side {s}cm."
-            ],
-            "Algebra": [
-                "Solve for x: {a}x + {b} = {c}",
-                "Simplify: {a}x + {b}y + {c}x - {d}y",
-                "Expand: {a}(x + {b})",
-                "Factor: {a}x + {b}",
-                "Evaluate {a}x² + {b}x + {c} when x = {d}"
             ]
         }
         
-        topic_templates = templates.get(topic, ["Practice {topic} problems."])
-        template = random.choice(topic_templates)
+        self.english_templates = {
+            "Grammar": [
+                "Correct the sentence: '{sentence}'",
+                "Choose the correct word: '{sentence}'"
+            ],
+            "Vocabulary": [
+                "What is a synonym for '{word}'?",
+                "What is the antonym of '{word}'?"
+            ]
+        }
+    
+    def generate_math_question(self, topic, difficulty):
+        """Generate math question"""
+        templates = self.math_templates.get(topic, ["Practice {topic}."])
+        template = random.choice(templates)
         
-        # Fill template with random values based on difficulty
-        multipliers = {1: 10, 2: 20, 3: 50, 4: 100, 5: 500}
-        max_val = multipliers.get(difficulty, 50)
+        # Generate values based on difficulty
+        max_val = {1: 10, 2: 20, 3: 50, 4: 100, 5: 200}[difficulty]
         
         values = {
             'num': random.randint(1, max_val),
@@ -95,46 +62,28 @@ class FreeAITutor:
             'd': random.randint(2, max_val),
             'whole': random.randint(10, 100),
             'decimal': round(random.uniform(0.1, 0.9), 2),
-            'percent': random.randint(1, 100),
-            'number': random.randint(1, max_val),
-            'total': random.randint(10, 100),
-            'old': random.randint(10, 100),
-            'new': random.randint(10, 100),
             'l': random.randint(5, 20),
             'w': random.randint(3, 15),
             's': random.randint(4, 12),
             'r': random.randint(2, 10),
             'h': random.randint(3, 12),
             'b': random.randint(4, 16),
-            'x': random.randint(1, 10),
-            'y': random.randint(1, 10),
-            'place': random.choice(["whole number", "tenth", "hundredth"]),
             'topic': topic
         }
         
         question = template.format(**values)
-        
-        # Calculate answer
-        answer = self._calculate_answer(question, topic, values)
+        answer = self._calculate_answer(question, values)
         
         return question, answer
     
-    def _calculate_answer(self, question, topic, values):
-        """Calculate answer for math questions"""
+    def _calculate_answer(self, question, values):
+        """Calculate answer for math question"""
         try:
             if "Simplify the fraction" in question:
                 num, den = values['num'], values['den']
                 gcd = math.gcd(num, den)
                 return f"{num//gcd}/{den//gcd}"
             
-            elif "Add" in question and "/" in question:
-                # Fraction addition
-                a, b, c, d = values['a'], values['b'], values['c'], values['d']
-                lcm = b * d // math.gcd(b, d)
-                num = a * (lcm // b) + c * (lcm // d)
-                gcd = math.gcd(num, lcm)
-                return f"{num//gcd}/{lcm//gcd}"
-            
             elif "area of a rectangle" in question:
                 return f"{values['l'] * values['w']} cm²"
             
@@ -145,270 +94,39 @@ class FreeAITutor:
                 return f"{0.5 * values['b'] * values['h']} cm²"
             
             elif "circumference of a circle" in question:
-                return f"{2 * 3.14 * values['r']} cm"
+                return f"{2 * 3.14 * values['r']:.2f} cm"
             
             elif "volume of a cube" in question:
                 return f"{values['s'] ** 3} cm³"
             
-            elif "Solve for x:" in question:
-                a, b, c = values['a'], values['b'], values['c']
-                return f"{(c - b) / a}"
-            
-            elif "What is" in question and "% of" in question:
-                return f"{values['number'] * values['percent'] / 100}"
+            elif "Add" in question and "/" in question:
+                a, b, c, d = values['a'], values['b'], values['c'], values['d']
+                lcm = b * d // math.gcd(b, d)
+                num = a * (lcm // b) + c * (lcm // d)
+                gcd = math.gcd(num, lcm)
+                return f"{num//gcd}/{lcm//gcd}"
             
             else:
-                # Try to evaluate mathematically
-                expr = question.lower()
-                expr = expr.replace("what is", "").replace("calculate", "").replace("find", "")
-                expr = expr.replace("×", "*").replace("x", "*").replace("÷", "/")
-                
-                # Remove units and text
-                expr = re.sub(r'[a-zA-Z\s]+', '', expr)
-                expr = expr.strip(" .?")
+                return "Calculate step by step"
                 
-                try:
-                    result = eval(expr)
-                    return str(round(result, 2))
-                except:
-                    return "Calculate step by step"
-                    
-        except Exception as e:
-            print(f"Calculation error: {e}")
+        except Exception:
             return "Practice this concept"
     
-    def generate_english_question(self, topic, difficulty):
-        """Generate English questions using templates"""
-        templates = {
-            "Grammar": [
-                "Correct the sentence: '{sentence}'",
-                "Choose the correct word: '{sentence}'",
-                "Identify the error: '{sentence}'",
-                "Complete the sentence: '{sentence}'",
-                "Rewrite in past tense: '{sentence}'"
-            ],
-            "Vocabulary": [
-                "What is a synonym for '{word}'?",
-                "What is the antonym of '{word}'?",
-                "Use '{word}' in a sentence.",
-                "What does '{word}' mean?",
-                "Which word doesn't belong: '{words}'?"
-            ],
-            "Comprehension": [
-                "Read this passage: '{passage}'. Answer: {question}",
-                "What is the main idea? '{passage}'",
-                "What can you infer from: '{passage}'?",
-                "Who is the main character? '{passage}'",
-                "What happened first? '{passage}'"
-            ],
-            "Writing": [
-                "Write a paragraph about '{topic}'.",
-                "Write a letter to your teacher about '{topic}'.",
-                "Write a story that includes: '{elements}'",
-                "Describe your favorite place in Trinidad.",
-                "Write instructions for '{activity}'."
-            ]
-        }
-        
-        # Word banks
-        vocabulary = {
-            "easy": ["happy", "big", "small", "fast", "slow", "hot", "cold", "good", "bad"],
-            "medium": ["excited", "enormous", "minuscule", "rapid", "gradual", "scorching", "freezing", "excellent", "terrible"],
-            "hard": ["ecstatic", "colossal", "microscopic", "expeditious", "leisurely", "blistering", "glacial", "superb", "atrocious"]
-        }
-        
-        grammar_sentences = {
-            "easy": [
-                "He go to school.",
-                "They is happy.",
-                "I has a book.",
-                "She don't like it.",
-                "We was playing."
-            ],
-            "medium": [
-                "Neither of the boys have finished.",
-                "Each of the students are here.",
-                "The team are winning.",
-                "One of the books were missing.",
-                "Everybody know the answer."
-            ],
-            "hard": [
-                "The data suggests that the hypothesis are correct.",
-                "A number of students was absent.",
-                "The committee have made their decision.",
-                "Physics are my favorite subject.",
-                "The police is investigating."
-            ]
-        }
-        
-        passages = [
-            "The Caribbean sun shone brightly on the beaches of Trinidad. Children played in the sand while their parents watched from under colorful umbrellas. The sound of steelpan music floated on the breeze.",
-            "In the rainforest, brightly colored birds flew between the trees. Monkeys chattered in the canopy, and exotic flowers bloomed everywhere. The air was filled with the sounds of nature.",
-            "During Carnival, the streets of Port of Spain come alive with music and dancing. People in elaborate costumes parade through the streets, celebrating with joy and energy.",
-            "The market was bustling with activity. Vendors sold fresh fruits, vegetables, and spices. The smell of curry and fresh bread filled the air as people shopped for their dinner ingredients."
-        ]
-        
-        difficulty_key = ["easy", "medium", "hard", "hard", "hard"][difficulty-1]
-        
-        if topic in templates:
-            template = random.choice(templates[topic])
-            
-            if topic == "Grammar":
-                sentence = random.choice(grammar_sentences[difficulty_key])
-                question = template.format(sentence=sentence)
-                answer = self._correct_grammar(sentence)
-                
-            elif topic == "Vocabulary":
-                word = random.choice(vocabulary[difficulty_key])
-                question = template.format(word=word)
-                answer = self._get_word_info(word, template)
-                
-            elif topic == "Comprehension":
-                passage = random.choice(passages)
-                questions = [
-                    "What is happening?",
-                    "Where does this take place?",
-                    "Who is mentioned?",
-                    "What time of day is it?",
-                    "What sounds are mentioned?"
-                ]
-                q = random.choice(questions)
-                question = template.format(passage=passage, question=q)
-                answer = self._comprehension_answer(passage, q)
-                
-            elif topic == "Writing":
-                writing_topics = ["your family", "your school", "Carnival", "the beach", "a rainforest adventure"]
-                topic_word = random.choice(writing_topics)
-                question = template.format(topic=topic_word)
-                answer = "Write a well-structured paragraph with complete sentences."
-                
-            else:
-                question = f"Practice {topic}."
-                answer = "Practice answer"
-            
-            return question, answer
-        
-        return f"Practice {topic} questions.", "Check your textbook."
-    
-    def _correct_grammar(self, sentence):
-        """Correct grammar errors in sentences"""
-        corrections = {
-            "He go to school.": "He goes to school.",
-            "They is happy.": "They are happy.",
-            "I has a book.": "I have a book.",
-            "She don't like it.": "She doesn't like it.",
-            "We was playing.": "We were playing.",
-            "Neither of the boys have finished.": "Neither of the boys has finished.",
-            "Each of the students are here.": "Each of the students is here.",
-            "The team are winning.": "The team is winning.",
-            "One of the books were missing.": "One of the books was missing.",
-            "Everybody know the answer.": "Everybody knows the answer."
-        }
-        return corrections.get(sentence, "Sentence appears to be correct.")
-    
-    def _get_word_info(self, word, template):
-        """Get word synonyms/antonyms"""
-        synonyms = {
-            "happy": "joyful, cheerful",
-            "big": "large, huge",
-            "small": "little, tiny",
-            "fast": "quick, rapid",
-            "slow": "gradual, unhurried",
-            "hot": "warm, boiling",
-            "cold": "chilly, freezing",
-            "good": "excellent, great",
-            "bad": "poor, terrible"
-        }
-        
-        antonyms = {
-            "happy": "sad",
-            "big": "small",
-            "small": "big",
-            "fast": "slow",
-            "slow": "fast",
-            "hot": "cold",
-            "cold": "hot",
-            "good": "bad",
-            "bad": "good"
-        }
-        
-        if "synonym" in template:
-            return synonyms.get(word, "Look up in dictionary")
-        elif "antonym" in template:
-            return antonyms.get(word, "Look up in dictionary")
-        else:
-            return "Check dictionary for meaning"
-    
-    def _comprehension_answer(self, passage, question):
-        """Generate comprehension answers"""
-        if "What is happening" in question:
-            return "People are enjoying outdoor activities in Trinidad."
-        elif "Where" in question:
-            if "beach" in passage.lower():
-                return "At the beach in Trinidad"
-            elif "rainforest" in passage.lower():
-                return "In a rainforest"
-            elif "Carnival" in passage.lower():
-                return "In Port of Spain during Carnival"
-            elif "market" in passage.lower():
-                return "At a market"
-        elif "Who" in question:
-            return "People, children, parents, vendors (depending on passage)"
-        elif "time of day" in question:
-            return "During the day"
-        elif "sounds" in question:
-            return "Music, nature sounds, chatter"
-        
-        return "Read the passage carefully for the answer."
-    
-    def evaluate_answer(self, student_answer, correct_answer, question):
+    def evaluate_answer(self, student_answer, correct_answer):
         """Evaluate student's answer"""
         student = str(student_answer).strip().lower()
         correct = str(correct_answer).strip().lower()
         
-        # Basic matching
         if student == correct:
-            return {
-                "correct": True,
-                "confidence": 1.0,
-                "feedback": "✅ Perfect answer!",
-                "score": 1
-            }
-        
-        # For math: check numeric equivalence
-        try:
-            # Extract numbers
-            s_num = re.findall(r"[-+]?\d*\.\d+|\d+", student)
-            c_num = re.findall(r"[-+]?\d*\.\d+|\d+", correct)
-            
-            if s_num and c_num:
-                if abs(float(s_num[0]) - float(c_num[0])) < 0.01:
-                    return {
-                        "correct": True,
-                        "confidence": 0.9,
-                        "feedback": "✅ Numerically correct!",
-                        "score": 0.9
-                    }
-        except:
-            pass
+            return {"correct": True, "score": 1.0, "feedback": "✅ Correct! Well done!"}
         
         # Partial credit for showing work
-        if len(student) > 10 and any(word in student for word in ["step", "calculate", "solve", "answer"]):
-            return {
-                "correct": False,
-                "confidence": 0.5,
-                "feedback": "⚠️ Good attempt. The correct answer is: " + correct_answer,
-                "score": 0.5
-            }
+        if len(student) > 10:
+            return {"correct": False, "score": 0.5, "feedback": "⚠️ Good attempt. Keep practicing!"}
         
-        return {
-            "correct": False,
-            "confidence": 0.0,
-            "feedback": "❌ Incorrect. The correct answer is: " + correct_answer,
-            "score": 0
-        }
+        return {"correct": False, "score": 0.0, "feedback": "❌ Incorrect. Try again!"}
 
-# ==================== DATABASE SETUP ====================
+# ==================== DATABASE ====================
 class ThreadLocal(threading.local):
     def __init__(self):
         self.connections = {}
@@ -416,679 +134,309 @@ class ThreadLocal(threading.local):
 thread_local = ThreadLocal()
 
 def get_db_connection(db_name="questions"):
-    """Get thread-local database connection"""
+    """Get database connection"""
     if not hasattr(thread_local, 'connections'):
         thread_local.connections = {}
     
     if db_name not in thread_local.connections:
-        db_dir = "/tmp/database"
-        os.makedirs(db_dir, exist_ok=True)
-        
-        conn = sqlite3.connect(
-            os.path.join(db_dir, f"{db_name}.db"), 
-            check_same_thread=False
-        )
+        conn = sqlite3.connect(f"/tmp/{db_name}.db", check_same_thread=False)
         thread_local.connections[db_name] = conn
     
     return thread_local.connections[db_name]
 
 def init_databases():
-    """Initialize all databases"""
-    # Questions database
-    q_conn = get_db_connection("questions")
-    q_cur = q_conn.cursor()
-    
-    q_cur.execute('''
+    """Initialize databases"""
+    # Questions DB
+    conn = get_db_connection("questions")
+    cur = conn.cursor()
+    cur.execute('''
         CREATE TABLE IF NOT EXISTS questions (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             subject TEXT,
             topic TEXT,
             question_text TEXT,
-            question_type TEXT,
-            difficulty INTEGER DEFAULT 3,
-            options TEXT,
+            difficulty INTEGER,
             correct_answer TEXT,
-            explanation TEXT,
             created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
         )
     ''')
     
-    # Student database
-    s_conn = get_db_connection("students")
-    s_cur = s_conn.cursor()
-    
-    s_cur.execute('''
+    # Student DB
+    conn = get_db_connection("students")
+    cur = conn.cursor()
+    cur.execute('''
         CREATE TABLE IF NOT EXISTS student_progress (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            student_id TEXT DEFAULT 'student_001',
+            student_id TEXT,
             question_id INTEGER,
             student_answer TEXT,
             correct BOOLEAN,
             score REAL,
-            feedback TEXT,
-            topic TEXT,
-            difficulty INTEGER,
-            date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
         )
     ''')
     
-    s_cur.execute('''
+    cur.execute('''
         CREATE TABLE IF NOT EXISTS student_stats (
             student_id TEXT PRIMARY KEY,
             total_questions INTEGER DEFAULT 0,
             correct_answers INTEGER DEFAULT 0,
             total_score REAL DEFAULT 0,
-            current_streak INTEGER DEFAULT 0,
-            best_streak INTEGER DEFAULT 0,
-            level INTEGER DEFAULT 1,
-            last_active TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            level INTEGER DEFAULT 1
         )
     ''')
     
-    # Add sample questions if empty
-    q_cur.execute("SELECT COUNT(*) FROM questions")
-    if q_cur.fetchone()[0] == 0:
-        add_sample_questions()
-    
-    s_conn.commit()
-    q_conn.commit()
-
-def add_sample_questions():
-    """Add sample questions to database"""
-    conn = get_db_connection("questions")
-    cur = conn.cursor()
-    
-    sample_questions = [
-        ("Mathematics", "Fractions", "Simplify 12/16", "Short Answer", 2, None, "3/4", "Divide numerator and denominator by 4"),
-        ("Mathematics", "Geometry", "Find the area of a rectangle with length 8cm and width 5cm", "Short Answer", 2, None, "40 cm²", "Area = length × width = 8 × 5"),
-        ("English", "Grammar", "Correct: He go to school every day", "Short Answer", 1, None, "He goes to school every day", "Use 'goes' for third person singular"),
-        ("English", "Vocabulary", "What is a synonym for happy?", "Short Answer", 1, None, "joyful", "Synonyms are words with similar meanings"),
-        ("Mathematics", "Percentages", "What is 20% of 50?", "Short Answer", 2, None, "10", "20% of 50 = 0.20 × 50 = 10")
-    ]
-    
-    for q in sample_questions:
-        cur.execute('''
-            INSERT INTO questions (subject, topic, question_text, question_type, difficulty, options, correct_answer, explanation)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        ''', q)
-    
     conn.commit()
 
-# ==================== MAIN TUTOR ENGINE ====================
+# ==================== MAIN APP ====================
 class SEAITutor:
     def __init__(self):
-        self.free_ai = FreeAITutor()
+        self.ai = FreeAITutor()
         init_databases()
-        print("🤖 FREE SEA AI Tutor Initialized - No API Keys Needed!")
+        print("🚀 SEA Prep Pro - Free AI Tutor Started!")
         
         self.subjects = {
             "Mathematics": {
-                "icon": "📐",
-                "topics": ["Fractions", "Decimals", "Percentages", "Geometry", "Algebra", "Measurement", "Word Problems"],
-                "description": "Practice SEA-level math problems"
+                "topics": ["Fractions", "Geometry", "Algebra", "Word Problems", "Percentages"],
+                "icon": "📐"
             },
             "English": {
-                "icon": "📚",
-                "topics": ["Grammar", "Vocabulary", "Comprehension", "Writing", "Spelling", "Punctuation"],
-                "description": "Improve English language skills"
+                "topics": ["Grammar", "Vocabulary", "Comprehension", "Writing"],
+                "icon": "📚"
             }
         }
         
         self.difficulty_levels = {
-            1: {"label": "Beginner", "color": "#4CAF50"},
-            2: {"label": "Easy", "color": "#8BC34A"},
-            3: {"label": "Medium", "color": "#FFC107"},
-            4: {"label": "Hard", "color": "#FF9800"},
-            5: {"label": "Expert", "color": "#F44336"}
+            1: "Beginner", 2: "Easy", 3: "Medium", 4: "Hard", 5: "Expert"
         }
         
         self.student_id = "student_001"
     
-    def generate_question(self, subject, topic, difficulty=3):
+    def generate_question(self, subject, topic, difficulty):
         """Generate a new question"""
-        try:
-            if subject == "Mathematics":
-                question, answer = self.free_ai.generate_math_question(topic, difficulty)
-            else:
-                question, answer = self.free_ai.generate_english_question(topic, difficulty)
-            
-            # Store in database
-            conn = get_db_connection("questions")
-            cursor = conn.cursor()
-            cursor.execute('''
-                INSERT INTO questions 
-                (subject, topic, question_text, question_type, difficulty, correct_answer, explanation)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-            ''', (subject, topic, question, "Generated", difficulty, answer, f"Practice {topic} concepts."))
-            
-            question_id = cursor.lastrowid
-            conn.commit()
-            
-            return {
-                "id": question_id,
-                "subject": subject,
-                "topic": topic,
-                "text": question,
-                "difficulty": difficulty,
-                "difficulty_label": self.difficulty_levels.get(difficulty, {}).get("label", "Medium"),
-                "correct_answer": answer,
-                "explanation": f"Practice {topic} to improve your skills."
-            }
-            
-        except Exception as e:
-            print(f"Error generating question: {e}")
-            # Return a fallback question
-            return {
-                "id": None,
-                "subject": subject,
-                "topic": topic,
-                "text": f"What is an example of a {topic.lower()} question in {subject}?",
-                "difficulty": difficulty,
-                "difficulty_label": self.difficulty_levels.get(difficulty, {}).get("label", "Medium"),
-                "correct_answer": "Practice this topic regularly.",
-                "explanation": "Keep practicing to improve!"
-            }
+        if subject == "Mathematics":
+            question, answer = self.ai.generate_math_question(topic, difficulty)
+        else:
+            question = f"Practice {topic} in {subject}. Write your answer below."
+            answer = "Sample answer for practice."
+        
+        # Store in DB
+        conn = get_db_connection("questions")
+        cur = conn.cursor()
+        cur.execute('''
+            INSERT INTO questions (subject, topic, question_text, difficulty, correct_answer)
+            VALUES (?, ?, ?, ?, ?)
+        ''', (subject, topic, question, difficulty, answer))
+        
+        question_id = cur.lastrowid
+        conn.commit()
+        
+        return {
+            "id": question_id,
+            "text": question,
+            "subject": subject,
+            "topic": topic,
+            "difficulty": self.difficulty_levels.get(difficulty, "Medium")
+        }
     
     def submit_answer(self, question_id, student_answer):
-        """Submit and evaluate an answer"""
-        try:
-            # Get question from database
-            conn = get_db_connection("questions")
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT question_text, correct_answer, explanation, topic, difficulty 
-                FROM questions WHERE id = ?
-            ''', (question_id,))
-            
-            result = cursor.fetchone()
-            if not result:
-                return {
-                    "correct": False,
-                    "feedback": "Question not found.",
-                    "score": 0,
-                    "correct_answer": ""
-                }
-            
-            question_text, correct_answer, explanation, topic, difficulty = result
-            
-            # Evaluate using free AI
-            evaluation = self.free_ai.evaluate_answer(student_answer, correct_answer, question_text)
-            
-            # Record progress
-            self._record_progress(question_id, student_answer, evaluation["correct"], 
-                                evaluation["score"], evaluation["feedback"], topic, difficulty)
-            
-            return {
-                "correct": evaluation["correct"],
-                "feedback": evaluation["feedback"],
-                "score": evaluation["score"],
-                "correct_answer": correct_answer,
-                "explanation": explanation
-            }
-            
-        except Exception as e:
-            print(f"Error submitting answer: {e}")
-            return {
-                "correct": False,
-                "feedback": "Error processing answer. Please try again.",
-                "score": 0,
-                "correct_answer": "",
-                "explanation": ""
-            }
-    
-    def _record_progress(self, question_id, student_answer, correct, score, feedback, topic, difficulty):
-        """Record student progress"""
-        conn = get_db_connection("students")
-        cursor = conn.cursor()
+        """Submit and evaluate answer"""
+        # Get question
+        conn = get_db_connection("questions")
+        cur = conn.cursor()
+        cur.execute('SELECT correct_answer FROM questions WHERE id = ?', (question_id,))
+        row = cur.fetchone()
+        
+        if not row:
+            return {"feedback": "Question not found.", "score": 0}
         
-        # Record answer
-        cursor.execute('''
-            INSERT INTO student_progress 
-            (student_id, question_id, student_answer, correct, score, feedback, topic, difficulty)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        ''', (self.student_id, question_id, student_answer, correct, score, feedback, topic, difficulty))
+        correct_answer = row[0]
+        evaluation = self.ai.evaluate_answer(student_answer, correct_answer)
+        
+        # Record progress
+        conn = get_db_connection("students")
+        cur = conn.cursor()
+        cur.execute('''
+            INSERT INTO student_progress (student_id, question_id, student_answer, correct, score)
+            VALUES (?, ?, ?, ?, ?)
+        ''', (self.student_id, question_id, student_answer, evaluation["correct"], evaluation["score"]))
         
         # Update stats
-        cursor.execute('''
-            INSERT OR REPLACE INTO student_stats 
-            (student_id, total_questions, correct_answers, total_score, last_active)
+        cur.execute('''
+            INSERT OR REPLACE INTO student_stats (student_id, total_questions, correct_answers, total_score)
             VALUES (?, 
                 COALESCE((SELECT total_questions FROM student_stats WHERE student_id = ?), 0) + 1,
                 COALESCE((SELECT correct_answers FROM student_stats WHERE student_id = ?), 0) + ?,
-                COALESCE((SELECT total_score FROM student_stats WHERE student_id = ?), 0) + ?,
-                CURRENT_TIMESTAMP
+                COALESCE((SELECT total_score FROM student_stats WHERE student_id = ?), 0) + ?
             )
-        ''', (self.student_id, self.student_id, self.student_id, 1 if correct else 0, 
-              self.student_id, score))
-        
-        # Update streak
-        if correct:
-            cursor.execute('''
-                UPDATE student_stats 
-                SET current_streak = COALESCE(current_streak, 0) + 1,
-                    best_streak = MAX(best_streak, COALESCE(current_streak, 0) + 1)
-                WHERE student_id = ?
-            ''', (self.student_id,))
-        else:
-            cursor.execute('''
-                UPDATE student_stats SET current_streak = 0 WHERE student_id = ?
-            ''', (self.student_id,))
-        
-        # Update level based on total score
-        cursor.execute('''
-            UPDATE student_stats 
-            SET level = CAST(total_score / 100 AS INTEGER) + 1 
-            WHERE student_id = ? AND level < CAST(total_score / 100 AS INTEGER) + 1
-        ''', (self.student_id,))
+        ''', (self.student_id, self.student_id, self.student_id, 
+              1 if evaluation["correct"] else 0, self.student_id, evaluation["score"]))
         
         conn.commit()
+        
+        return evaluation
     
-    def get_student_stats(self):
+    def get_stats(self):
         """Get student statistics"""
         conn = get_db_connection("students")
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            SELECT total_questions, correct_answers, total_score, current_streak, best_streak, level
+        cur = conn.cursor()
+        cur.execute('''
+            SELECT total_questions, correct_answers, total_score, level 
             FROM student_stats WHERE student_id = ?
         ''', (self.student_id,))
         
-        row = cursor.fetchone()
+        row = cur.fetchone()
         if not row:
-            return {
-                "total_questions": 0,
-                "correct_answers": 0,
-                "accuracy": 0,
-                "total_score": 0,
-                "current_streak": 0,
-                "best_streak": 0,
-                "level": 1,
-                "level_progress": 0
-            }
+            return {"total_questions": 0, "correct_answers": 0, "accuracy": 0, "level": 1}
         
-        total, correct, total_score, streak, best_streak, level = row
+        total, correct, score, level = row
         accuracy = (correct / total * 100) if total > 0 else 0
-        level_progress = (total_score % 100)
-        
-        # Get topic performance
-        cursor.execute('''
-            SELECT topic, 
-                   COUNT(*) as total,
-                   AVG(score) as avg_score
-            FROM student_progress 
-            WHERE student_id = ?
-            GROUP BY topic
-            ORDER BY avg_score ASC
-            LIMIT 3
-        ''', (self.student_id,))
-        
-        weak_topics = []
-        for topic, total_q, avg_score in cursor.fetchall():
-            weak_topics.append({
-                "topic": topic,
-                "accuracy": round((avg_score or 0) * 100, 1),
-                "total": total_q
-            })
         
         return {
             "total_questions": total,
             "correct_answers": correct,
             "accuracy": round(accuracy, 1),
-            "total_score": round(total_score, 1),
-            "current_streak": streak,
-            "best_streak": best_streak,
-            "level": level,
-            "level_progress": level_progress,
-            "weak_topics": weak_topics
+            "total_score": round(score, 1),
+            "level": level
         }
-    
-    def get_random_tip(self):
-        """Get random study tip"""
-        tips = [
-            "🎯 Study a little every day instead of cramming before exams.",
-            "📝 Practice past SEA exam papers regularly.",
-            "⏰ Take short breaks during study sessions to stay focused.",
-            "📚 Review your mistakes to learn from them.",
-            "🧮 For math, show all your working steps.",
-            "📖 Read every day to improve vocabulary and comprehension.",
-            "✅ Check your work before submitting answers.",
-            "🎨 Use colors and diagrams to remember concepts.",
-            "🤔 Ask questions when you don't understand something.",
-            "🎵 Study in a quiet place without distractions."
-        ]
-        return random.choice(tips)
-    
-    def get_leaderboard(self):
-        """Get leaderboard data (simulated for demo)"""
-        return [
-            {"rank": 1, "name": "Aaliyah", "score": 1250, "level": 13},
-            {"rank": 2, "name": "Brandon", "score": 1180, "level": 12},
-            {"rank": 3, "name": "Chelsea", "score": 1050, "level": 11},
-            {"rank": 4, "name": "David", "score": 980, "level": 10},
-            {"rank": 5, "name": "Emily", "score": 920, "level": 10}
-        ]
 
-# Initialize tutor
-ai_tutor = SEAITutor()
+# Initialize
+tutor = SEAITutor()
 
 # ==================== GRADIO UI ====================
-def create_app():
-    """Create the Gradio interface"""
-    
+def create_ui():
     with gr.Blocks(
-        title="🤖 FREE SEA Prep AI Tutor | Trinidad & Tobago",
-        theme=gr.themes.Soft(
-            primary_hue="blue",
-            secondary_hue="green"
-        ),
-        css="""
-        .gradio-container {
-            max-width: 1200px !important;
-            margin: 0 auto;
-        }
-        .header {
-            text-align: center;
-            padding: 20px;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            border-radius: 10px;
-            margin-bottom: 20px;
-        }
-        .free-badge {
-            background: #4CAF50;
-            color: white;
-            padding: 5px 15px;
-            border-radius: 20px;
-            font-weight: bold;
-            display: inline-block;
-            margin: 5px;
-        }
-        .question-card {
-            background: #f8f9fa;
-            padding: 20px;
-            border-radius: 10px;
-            border-left: 5px solid #2196F3;
-            margin: 15px 0;
-        }
-        .feedback-correct {
-            background: #d4edda;
-            padding: 15px;
-            border-radius: 10px;
-            border-left: 5px solid #28a745;
-        }
-        .feedback-incorrect {
-            background: #f8d7da;
-            padding: 15px;
-            border-radius: 10px;
-            border-left: 5px solid #dc3545;
-        }
-        .stat-card {
-            text-align: center;
-            padding: 15px;
-            background: white;
-            border-radius: 10px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-            margin: 10px 0;
-        }
-        .stat-value {
-            font-size: 2em;
-            font-weight: bold;
-            color: #2196F3;
-        }
-        .tip-box {
-            background: #e3f2fd;
-            padding: 15px;
-            border-radius: 10px;
-            font-style: italic;
-            margin: 10px 0;
-        }
-        """
+        title="SEA Prep Pro - Free AI Tutor 🇹🇹",
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="purple")
     ) as demo:
         
         # Header
         gr.Markdown("""
-        <div class="header">
-        <h1>🤖 FREE SEA Prep AI Tutor 🇹🇹</h1>
-        <h3>100% Free AI-Powered Secondary Entrance Assessment Preparation</h3>
-        <span class="free-badge">NO API KEYS REQUIRED</span>
-        <span class="free-badge">COMPLETELY FREE</span>
-        <span class="free-badge">LOCAL PROCESSING</span>
-        <p>Practice Mathematics and English questions for Trinidad & Tobago SEA exams</p>
-        </div>
+        # 🤖 SEA Prep Pro - Free AI Tutor 🇹🇹
+        ### 100% Free • No API Keys • Trinidad & Tobago SEA Exam Preparation
         """)
         
-        # Main content
         with gr.Tabs():
-            # Practice Tab
             with gr.TabItem("🎯 Practice"):
                 with gr.Row():
                     with gr.Column(scale=1):
-                        gr.Markdown("### 📝 Question Settings")
                         subject = gr.Dropdown(
-                            choices=list(ai_tutor.subjects.keys()),
-                            label="Select Subject",
-                            value="Mathematics"
+                            choices=["Mathematics", "English"],
+                            value="Mathematics",
+                            label="Subject"
                         )
                         topic = gr.Dropdown(
-                            choices=ai_tutor.subjects["Mathematics"]["topics"],
-                            label="Select Topic",
-                            value="Fractions"
+                            choices=tutor.subjects["Mathematics"]["topics"],
+                            value="Fractions",
+                            label="Topic"
                         )
                         difficulty = gr.Slider(
-                            minimum=1, maximum=5, value=3, step=1,
+                            1, 5, value=3, step=1,
                             label="Difficulty Level"
                         )
                         
-                        # Update topics when subject changes
-                        def update_topics(subject):
-                            topics = ai_tutor.subjects.get(subject, {}).get("topics", [])
-                            return gr.Dropdown.update(choices=topics, value=topics[0] if topics else "")
-                        
-                        subject.change(update_topics, inputs=subject, outputs=topic)
-                        
-                        generate_btn = gr.Button("✨ Generate New Question", variant="primary", size="lg")
+                        generate_btn = gr.Button("✨ Generate Question", variant="primary")
                         
                         gr.Markdown("---")
-                        gr.Markdown("### 📊 Quick Stats")
-                        stats_display = gr.JSON(label="Your Statistics")
-                        refresh_stats = gr.Button("🔄 Refresh Stats")
-                        
+                        stats = gr.JSON(label="📊 Your Stats")
+                        refresh_btn = gr.Button("🔄 Refresh Stats")
+                    
                     with gr.Column(scale=2):
-                        gr.Markdown("### ❓ Your Question")
-                        question_text = gr.Markdown("", elem_classes="question-card")
-                        
-                        gr.Markdown("### ✏️ Your Answer")
-                        answer_input = gr.Textbox(
-                            label="Type your answer here:",
-                            placeholder="Enter your answer...",
-                            lines=3
-                        )
+                        question_display = gr.Markdown("### Your question will appear here")
+                        answer_input = gr.Textbox(label="Your Answer", lines=3)
                         
                         with gr.Row():
                             submit_btn = gr.Button("✅ Submit Answer", variant="primary")
-                            clear_btn = gr.Button("🗑️ Clear Answer")
+                            clear_btn = gr.Button("🗑️ Clear")
                         
-                        gr.Markdown("### 💬 Feedback")
-                        feedback_display = gr.Markdown("")
-                        
-                        gr.Markdown("### 📖 Explanation")
-                        explanation_display = gr.Markdown("")
+                        feedback = gr.Markdown("### 💬 Feedback")
             
-            # Progress Tab
             with gr.TabItem("📈 Progress"):
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### 📊 Your Progress")
-                        progress_stats = gr.JSON(label="Detailed Statistics")
-                        
-                        gr.Markdown("### 🎯 Recommendations")
-                        recommendations = gr.Markdown("")
-                        
-                    with gr.Column():
-                        gr.Markdown("### 🏆 Leaderboard")
-                        leaderboard = gr.Dataframe(
-                            value=ai_tutor.get_leaderboard(),
-                            headers=["Rank", "Name", "Score", "Level"],
-                            interactive=False
-                        )
-                        
-                        gr.Markdown("### 💡 Study Tip")
-                        tip_display = gr.Markdown("")
-                        new_tip_btn = gr.Button("🎲 New Tip")
+                gr.Markdown("### Your Learning Journey")
+                progress_stats = gr.JSON()
+                gr.Markdown("### 🎯 Tips for Success")
+                gr.Markdown("""
+                - Practice regularly
+                - Review your mistakes
+                - Ask for help when needed
+                - Stay consistent
+                """)
             
-            # About Tab
             with gr.TabItem("ℹ️ About"):
                 gr.Markdown("""
                 ## About SEA Prep Pro
                 
-                **SEA Prep Pro** is a completely free AI-powered tutoring system designed specifically for 
-                Trinidad and Tobago students preparing for the Secondary Entrance Assessment (SEA) exam.
+                **SEA Prep Pro** is a completely free AI-powered tutoring system for Trinidad and Tobago students.
                 
-                ### 🎯 Features:
-                - **100% Free** - No subscriptions, no API keys required
-                - **AI-Powered** - Smart question generation and evaluation
-                - **Adaptive Learning** - Questions adjust to your skill level
-                - **Progress Tracking** - Monitor your improvement over time
-                - **Trinidad & Tobago Focus** - Contextually relevant content
+                ### Features:
+                - ✅ 100% Free - No payments ever
+                - 🔒 No API Keys Required
+                - 🤖 Smart Question Generation
+                - 📊 Progress Tracking
+                - 🇹🇹 Trinidad & Tobago Focus
                 
-                ### 📚 Subjects Covered:
-                - **Mathematics**: Fractions, Geometry, Algebra, Word Problems
-                - **English**: Grammar, Vocabulary, Comprehension, Writing
+                ### Subjects:
+                - **Mathematics**: Fractions, Geometry, Algebra
+                - **English**: Grammar, Vocabulary, Comprehension
                 
-                ### 🚀 How It Works:
+                ### How to Use:
                 1. Select a subject and topic
-                2. Choose difficulty level (1-5)
-                3. Generate practice questions
-                4. Submit answers for instant feedback
-                5. Track your progress and improve!
-                
-                ### 💝 Why It's Free:
-                This project was created to provide equal access to quality educational resources 
-                for all Trinidad and Tobago students, regardless of their financial situation.
+                2. Choose difficulty level
+                3. Generate questions
+                4. Submit answers
+                5. Track your progress
                 
-                ### 👨‍💻 Developer:
-                Created with ❤️ for Trinidad and Tobago students
-                
-                ***
-                
-                <center>
-                <span class="free-badge">EDUCATION FOR ALL</span>
-                <span class="free-badge">MADE IN TRINIDAD & TOBAGO</span>
-                <span class="free-badge">OPEN SOURCE</span>
-                </center>
+                **Made with ❤️ for Trinidad and Tobago students**
                 """)
         
-        # State variables
-        current_question = gr.State({"id": None})
+        # State
+        current_q = gr.State()
         
-        # Generate question function
-        def generate_q(subject_val, topic_val, difficulty_val):
-            question = ai_tutor.generate_question(subject_val, topic_val, difficulty_val)
-            
+        # Functions
+        def update_topics(subject):
+            topics = tutor.subjects.get(subject, {}).get("topics", [])
+            return gr.Dropdown.update(choices=topics, value=topics[0] if topics else "")
+        
+        def generate(subject, topic, difficulty):
+            q = tutor.generate_question(subject, topic, difficulty)
             display = f"""
-            **Subject:** {question['subject']}  
-            **Topic:** {question['topic']}  
-            **Difficulty:** {question['difficulty_label']} ({question['difficulty']}/5)  
+            **Subject:** {q['subject']}  
+            **Topic:** {q['topic']}  
+            **Difficulty:** {q['difficulty']}  
             
             ---
             
             **Question:**
-            {question['text']}
+            {q['text']}
             """
-            
-            return display, question, "", ""
+            return display, q, ""
         
-        # Submit answer function
-        def submit_a(answer, question_state):
-            if not question_state or not question_state.get("id"):
-                return "Please generate a question first!", "", question_state
-            
-            result = ai_tutor.submit_answer(question_state["id"], answer)
+        def submit(answer, question):
+            if not question:
+                return "Please generate a question first!", question
             
-            feedback_class = "feedback-correct" if result["correct"] else "feedback-incorrect"
-            feedback = f"""
-            <div class='{feedback_class}'>
-            **Result:** {result['feedback']}  
-            **Score:** {result['score']:.1%}  
-            **Correct Answer:** {result['correct_answer']}
-            </div>
-            """
-            
-            explanation = f"**Explanation:** {result['explanation']}"
-            
-            return feedback, explanation, question_state
+            result = tutor.submit_answer(question["id"], answer)
+            return f"**{result['feedback']}**  \n**Score:** {result['score']:.1%}", question
         
-        # Get stats function
         def get_stats_func():
-            stats = ai_tutor.get_student_stats()
-            return stats
-        
-        # Get tip function
-        def get_tip():
-            return ai_tutor.get_random_tip()
-        
-        # Get recommendations
-        def get_recommendations():
-            stats = ai_tutor.get_student_stats()
-            if stats["weak_topics"]:
-                topic = stats["weak_topics"][0]["topic"]
-                return f"**Focus on:** {topic}  \n**Reason:** Lower accuracy in this area  \n**Action:** Practice 5-10 {topic} questions daily"
-            else:
-                return "**Great job!** Keep practicing all topics to maintain your skills."
+            return tutor.get_stats()
         
-        # Clear answer function
-        def clear_answer():
+        def clear():
             return "", ""
         
         # Event handlers
-        generate_btn.click(
-            generate_q,
-            inputs=[subject, topic, difficulty],
-            outputs=[question_text, current_question, feedback_display, explanation_display]
-        )
-        
-        submit_btn.click(
-            submit_a,
-            inputs=[answer_input, current_question],
-            outputs=[feedback_display, explanation_display, current_question]
-        )
-        
-        refresh_stats.click(
-            get_stats_func,
-            outputs=stats_display
-        )
-        
-        clear_btn.click(
-            clear_answer,
-            outputs=[answer_input, feedback_display]
-        )
-        
-        # Progress tab functions
-        demo.load(
-            lambda: [get_stats_func(), get_recommendations(), get_tip()],
-            outputs=[progress_stats, recommendations, tip_display]
-        )
-        
-        new_tip_btn.click(
-            get_tip,
-            outputs=tip_display
-        )
+        subject.change(update_topics, subject, topic)
+        generate_btn.click(generate, [subject, topic, difficulty], [question_display, current_q, feedback])
+        submit_btn.click(submit, [answer_input, current_q], [feedback, current_q])
+        refresh_btn.click(get_stats_func, outputs=stats)
+        clear_btn.click(clear, outputs=[answer_input, feedback])
         
         # Initialize
-        demo.load(
-            get_stats_func,
-            outputs=stats_display
-        )
+        demo.load(get_stats_func, outputs=stats)
     
     return demo
 
-# Create and launch app
+# Launch
 if __name__ == "__main__":
-    app = create_app()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        debug=True
-    )
+    app = create_ui()
+    app.launch(debug=True)