Update src/streamlit_app.py

src/streamlit_app.py

@@ -10,6 +10,7 @@ import plotly.graph_objects as go
 import pandas as pd
 from datetime import datetime, timedelta
 import streamlit.components.v1 as components
+import hashlib
 
 # Configure page
 st.set_page_config(
@@ -77,6 +78,37 @@ def load_custom_css():
         z-index: 1;
     }
     
+    /* Timer styling */
+    .timer-display {
+        background: linear-gradient(135deg, #FF6B6B, #FF8E8E);
+        color: white;
+        padding: 1rem 2rem;
+        border-radius: 20px;
+        text-align: center;
+        font-size: 2rem;
+        font-weight: 700;
+        margin-bottom: 2rem;
+        box-shadow: 0 10px 30px rgba(255, 107, 107, 0.3);
+        animation: pulse 2s infinite;
+    }
+    
+    @keyframes pulse {
+        0% { transform: scale(1); box-shadow: 0 10px 30px rgba(255, 107, 107, 0.3); }
+        50% { transform: scale(1.02); box-shadow: 0 15px 40px rgba(255, 107, 107, 0.5); }
+        100% { transform: scale(1); box-shadow: 0 10px 30px rgba(255, 107, 107, 0.3); }
+    }
+    
+    .timer-warning {
+        background: linear-gradient(135deg, #FF4757, #FF6B6B) !important;
+        animation: fastPulse 1s infinite !important;
+    }
+    
+    @keyframes fastPulse {
+        0% { transform: scale(1); }
+        50% { transform: scale(1.05); }
+        100% { transform: scale(1); }
+    }
+    
     /* Card Styling */
     .custom-card {
         background: white;
@@ -222,12 +254,6 @@ def load_custom_css():
         animation: slideInUp 0.6s ease-out;
     }
     
-    @keyframes pulse {
-        0% { transform: scale(1); }
-        50% { transform: scale(1.05); }
-        100% { transform: scale(1); }
-    }
-    
     .pulse-animation {
         animation: pulse 2s infinite;
     }
@@ -270,6 +296,11 @@ def load_custom_css():
         .question-card {
             padding: 1rem;
         }
+        
+        .timer-display {
+            font-size: 1.5rem;
+            padding: 0.75rem 1.5rem;
+        }
     }
     body, .main, .block-container {
         background: #f7f9fb !important;
@@ -371,106 +402,271 @@ class MathOlympiadExam:
             return None
     
     def generate_questions(self, grade: int, num_questions: int, difficulty: str = "medium") -> List[Dict]:
-        """Generate math olympiad questions with enhanced difficulty options"""
+        """Generate unique math olympiad questions with STRICT rules against visual questions - FIXED"""
         if not self.client:
             return []
             
         try:
             difficulty_map = {
-                1: "very basic arithmetic, counting 1-20, simple shapes recognition, basic patterns",
-                2: "addition and subtraction within 100, simple word problems, basic time and money", 
-                3: "multiplication tables up to 10, basic division, simple fractions, pattern recognition",
-                4: "advanced multiplication and division, fractions, basic decimals, area and perimeter",
-                5: "advanced arithmetic, introduction to algebra, geometry, data interpretation",
-                6: "pre-algebra, ratios and proportions, percentages, coordinate geometry, statistics",
-                7: "algebra fundamentals, advanced geometry, probability, scientific notation",
-                8: "linear equations, quadratic basics, trigonometry introduction, advanced geometry",
-                9: "advanced algebra, geometry proofs, probability and statistics, trigonometry",
-                10: "pre-calculus, advanced trigonometry, complex numbers, advanced problem solving"
+                1: "Basic counting 1-20, simple addition/subtraction within 20, comparing numbers, basic money problems",
+                2: "Addition/subtraction within 100, word problems about time/money, simple multiplication by 2,5,10",
+                3: "Multiplication tables to 12, basic division, simple fractions (1/2, 1/4), word problems with multiple steps",
+                4: "Multi-digit multiplication/division, equivalent fractions, decimals to tenths, perimeter calculations",
+                5: "Advanced arithmetic, basic algebra (find the missing number), percentages, area calculations, factors/multiples",
+                6: "Pre-algebra equations, ratios/proportions, basic statistics (mean/median), coordinate problems",
+                7: "Linear equations, integers, basic probability, algebraic expressions, geometric formulas",
+                8: "Systems of equations, exponents/roots, advanced probability, quadratic expressions, geometric theorems",
+                9: "Advanced algebra, trigonometry basics, sequences/series, complex word problems, mathematical proofs",
+                10: "Pre-calculus topics, advanced trigonometry, logarithms, complex problem solving, advanced geometry"
             }
-            
+
             difficulty_modifiers = {
-                "easy": "Make questions slightly easier than typical olympiad level, focusing on fundamental concepts",
-                "medium": "Standard olympiad difficulty with moderate complexity",
-                "hard": "Advanced olympiad level with complex multi-step problems"
+                "easy": "Focus on fundamental concepts with straightforward calculations",
+                "medium": "Standard olympiad difficulty with moderate complexity requiring 2-3 steps",
+                "hard": "Advanced multi-step problems requiring deep mathematical reasoning"
             }
             
             topics = difficulty_map.get(grade, "general math concepts")
             modifier = difficulty_modifiers.get(difficulty, "")
-            
-            prompt = f"""Generate exactly {num_questions} Math Olympiad-style multiple choice questions for Grade {grade} students.
 
-Topics focus: {topics}
-Difficulty: {modifier}
+            # STRICT forbidden keywords - expanded list
+            forbidden_keywords = [
+                "figure", "diagram", "shape", "block", "square", "triangle", "circle", "rectangle", "polygon",
+                "pattern below", "picture", "image", "graph", "chart", "visual", "draw", "sketch", "plot",
+                "look at", "observe", "see the", "shown", "displayed", "illustrated", "appears",
+                "geometric shape", "arrange", "tessellation", "symmetry", "reflection", "rotation",
+                "hexagon", "pentagon", "octagon", "parallelogram", "rhombus", "trapezoid",
+                "coordinate plane", "grid", "lattice", "dot", "point on", "line segment",
+                "angle", "vertex", "side", "face", "edge", "cube", "cylinder", "sphere",
+                "shaded", "colored", "pattern", "sequence of shapes", "visual pattern"
+            ]
 
-Format each question EXACTLY as follows:
-**Question X:** [Question text here]
-A) [Option A]
-B) [Option B] 
-C) [Option C]
-D) [Option D]
-**Correct Answer:** [Letter only - A, B, C, or D]
-**Explanation:** [Clear step-by-step solution]
-**Hint:** [Helpful hint for students]
+            seen_hashes = getattr(st.session_state, 'question_hashes', set())
 
-Make questions engaging and educational. Include varied problem types: word problems, visual problems, logical reasoning, and computational challenges."""
+            # ENHANCED prompt with VERY strict formatting requirements
+            base_prompt = f"""
+    Generate exactly {num_questions} UNIQUE Math Olympiad questions for Grade {grade}.
+
+    🚨 ABSOLUTE RESTRICTIONS - NEVER INCLUDE:
+    ❌ Any visual elements (shapes, figures, diagrams, patterns, images)
+    ❌ Questions requiring visual interpretation
+    ❌ Geometric shape identification or counting
+    ❌ Pattern completion with visual elements
+    ❌ Any reference to "figure", "diagram", "shape", "pattern below"
+    ❌ Coordinate plotting or graph reading
+    ❌ Any visual arrangement problems
+
+    ✅ ONLY ALLOWED - TEXT-BASED QUESTIONS:
+    ✅ Pure arithmetic calculations and word problems
+    ✅ Number sequences (like: 2, 4, 6, 8, ?)
+    ✅ Logic puzzles with numbers/text only
+    ✅ Real-world scenarios (money, time, travel, shopping)
+    ✅ Algebraic word problems
+    ✅ Statistical problems with given data
+    ✅ Mathematical reasoning without visuals
+
+    TOPICS: {topics}
+    DIFFICULTY: {modifier}
+
+    🎯 CRITICAL: Answer must be EXACTLY one letter: A, B, C, or D (no explanations in answer line)
+
+    FORMAT (EXACT - NO DEVIATIONS):
+    **Question 1:** [Engaging word problem - NO VISUALS]
+    A) [Option A with number/calculation]
+    B) [Option B with number/calculation]  
+    C) [Option C with number/calculation]
+    D) [Option D with number/calculation]
+    **Answer:** A
+    **Explanation:** [Step-by-step solution]
+    **Hint:** [Helpful tip for solving]
+
+    **Question 2:** [Next question...]
+    A) [Option A]
+    B) [Option B]
+    C) [Option C]
+    D) [Option D]
+    **Answer:** C
+    **Explanation:** [Step-by-step solution]
+    **Hint:** [Helpful tip for solving]
+
+    [Continue for all {num_questions} questions]
+
+    🔥 IMPORTANT FORMATTING RULES:
+    - Answer line must contain ONLY the letter (A, B, C, or D)
+    - No parentheses, explanations, or additional text in the answer
+    - Each option must start with the letter followed by closing parenthesis
+    - Keep questions practical and engaging with real scenarios
+
+    MAKE QUESTIONS PRACTICAL AND ENGAGING - Use real scenarios students can relate to!
+    """
+
+            max_attempts = 3
+            all_questions = []
+
+            for attempt in range(max_attempts):
+                try:
+                    response = self.client.chat.completions.create(
+                        model="openai/gpt-oss-120b",  # More reliable model
+                        messages=[
+                            {"role": "system", "content": "You are an expert Math Olympiad question creator. You MUST create only text-based word problems without any visual elements. The answer must be EXACTLY one letter: A, B, C, or D with no additional text or explanations."},
+                            {"role": "user", "content": base_prompt}
+                        ],
+                        temperature=0.7,  # Balanced creativity
+                        max_tokens=4000
+                    )
+
+                    new_questions = self._parse_questions_enhanced(response.choices[0].message.content)
+
+                    # STRICT filtering
+                    valid_questions = []
+                    for q in new_questions:
+                        q_text = q['question_text'].lower()
+                        
+                        # Check for forbidden keywords
+                        if any(forbidden in q_text for forbidden in forbidden_keywords):
+                            continue
+                        
+                        # Additional checks for visual elements
+                        if any(word in q_text for word in ['draw', 'sketch', 'plot', 'shown', 'displayed', 'appears']):
+                            continue
+                            
+                        # Check uniqueness
+                        q_hash = self._get_question_hash(q['question_text'] + str(q['options']))
+                        if q_hash not in seen_hashes:
+                            q['hash'] = q_hash
+                            valid_questions.append(q)
+                            seen_hashes.add(q_hash)
+
+                    all_questions.extend(valid_questions)
+
+                    if len(all_questions) >= num_questions:
+                        break
+
+                    # Add retry hint with more specific guidance
+                    base_prompt += f"\n\nNEED MORE QUESTIONS: Generated {len(all_questions)} so far. Create MORE PRACTICAL WORD PROBLEMS about real-life scenarios (shopping, travel, sports, cooking, etc.). REMEMBER: Answer must be EXACTLY one letter (A, B, C, or D)."
+
+                except Exception as e:
+                    st.error(f"Error in attempt {attempt + 1}: {e}")
+                    continue
+
+            st.session_state.question_hashes = seen_hashes
+            final_questions = all_questions[:num_questions]
+
+            if len(final_questions) < num_questions:
+                st.warning(f"⚠️ Generated {len(final_questions)} unique valid questions (requested {num_questions}). Some were filtered out for containing visual elements.")
+
+            return final_questions
 
-            response = self.client.chat.completions.create(
-                model="llama-3.3-70b-versatile",
-                messages=[
-                    {"role": "system", "content": "You are an expert Math Olympiad coach creating engaging, educational questions."},
-                    {"role": "user", "content": prompt}
-                ],
-                temperature=0.7,
-                max_tokens=3000
-            )
-            
-            return self._parse_questions(response.choices[0].message.content)
-            
         except Exception as e:
             st.error(f"Failed to generate questions: {e}")
             return []
     
-    def _parse_questions(self, content: str) -> List[Dict]:
-        """Enhanced question parsing with hints"""
+    def _get_question_hash(self, question_text: str) -> str:
+        """Generate hash for question to track uniqueness"""
+        # Remove numbers and normalize text for better uniqueness detection
+        normalized = re.sub(r'\d+', 'X', question_text.lower().strip())
+        normalized = re.sub(r'[^\w\s]', '', normalized)  # Remove punctuation
+        return hashlib.md5(normalized.encode()).hexdigest()
+    
+    
+    def _parse_questions_enhanced(self, content: str) -> List[Dict]:
+        """Enhanced question parsing with better error handling and validation"""
         questions = []
-        question_blocks = re.split(r'\*\*Question \d+:\*\*', content)[1:]
         
-        for i, block in enumerate(question_blocks, 1):
+        # Split by question markers
+        question_blocks = re.split(r'\*\*Question \d+:\*\*', content)
+        if len(question_blocks) < 2:
+            # Try alternative splitting
+            question_blocks = re.split(r'Question \d+:', content)
+        
+        for i, block in enumerate(question_blocks[1:], 1):
             try:
                 lines = [line.strip() for line in block.strip().split('\n') if line.strip()]
                 
-                if len(lines) < 6:
+                if len(lines) < 6:  # Need at least question + 4 options + answer
                     continue
                     
-                question_text = lines[0]
-                options = []
+                question_text = lines[0].strip()
+                if not question_text:
+                    continue
+                
+                # Parse options - FIXED: Create both dictionary and list properly
+                options_dict = {}
+                options_list = []
                 correct_answer = None
                 explanation = ""
                 hint = ""
                 
+                current_section = "options"
+                
                 for line in lines[1:]:
-                    if line.startswith(('A)', 'B)', 'C)', 'D)')):
-                        options.append(line)
-                    elif line.startswith('**Correct Answer:**'):
-                        correct_answer = line.replace('**Correct Answer:**', '').strip()
+                    line = line.strip()
+                    
+                    # Detect sections
+                    if line.startswith('**Answer:**') or line.startswith('**Correct Answer:**'):
+                        current_section = "answer"
+                        answer_part = line.replace('**Answer:**', '').replace('**Correct Answer:**', '').strip()
+                        if answer_part:
+                            # Extract only the letter from the answer (A, B, C, or D)
+                            answer_match = re.search(r'[ABCD]', answer_part.upper())
+                            if answer_match:
+                                correct_answer = answer_match.group()
+                        continue
                     elif line.startswith('**Explanation:**'):
-                        explanation = line.replace('**Explanation:**', '').strip()
+                        current_section = "explanation"
+                        exp_part = line.replace('**Explanation:**', '').strip()
+                        if exp_part:
+                            explanation = exp_part
+                        continue
                     elif line.startswith('**Hint:**'):
-                        hint = line.replace('**Hint:**', '').strip()
+                        current_section = "hint"
+                        hint_part = line.replace('**Hint:**', '').strip()
+                        if hint_part:
+                            hint = hint_part
+                        continue
+                    
+                    # Process based on current section
+                    if current_section == "options" and line.startswith(('A)', 'B)', 'C)', 'D)')):
+                        option_key = line[0]  # A, B, C, or D
+                        option_text = line[2:].strip()  # Remove "A) "
+                        options_dict[option_key] = option_text
+                        options_list.append(line)  # Keep full format "A) text"
+                    elif current_section == "answer":
+                        # Try to extract single letter answer
+                        if line.strip() in ['A', 'B', 'C', 'D']:
+                            correct_answer = line.strip()
+                        elif not correct_answer:
+                            # Fallback: extract first letter found
+                            answer_match = re.search(r'[ABCD]', line.upper())
+                            if answer_match:
+                                correct_answer = answer_match.group()
+                    elif current_section == "explanation" and line:
+                        if explanation:
+                            explanation += " " + line
+                        else:
+                            explanation = line
+                    elif current_section == "hint" and line:
+                        if hint:
+                            hint += " " + line
+                        else:
+                            hint = line
                 
-                if len(options) == 4 and correct_answer:
+                # Validate question - ensure we have exactly 4 options and a valid answer
+                if len(options_dict) == 4 and correct_answer and correct_answer in options_dict:
                     questions.append({
                         'question_number': i,
                         'question_text': question_text,
-                        'options': options,
+                        'options': options_list,  # List format for compatibility: ['A) text', 'B) text', ...]
+                        'options_dict': options_dict,  # Dictionary format: {'A': 'text', 'B': 'text', ...}
                         'correct_answer': correct_answer,
-                        'explanation': explanation,
-                        'hint': hint,
+                        'explanation': explanation or "Work through the problem step by step.",
+                        'hint': hint or "Read the question carefully and identify what you need to find.",
                         'user_answer': None,
                         'time_taken': 0,
                         'difficulty': self._estimate_difficulty(question_text)
                     })
+                else:
+                    st.warning(f"Question {i} validation failed: options={len(options_dict)}, answer='{correct_answer}', keys={list(options_dict.keys())}")
                     
             except Exception as e:
                 st.warning(f"Error parsing question {i}: {e}")
@@ -480,8 +676,8 @@ Make questions engaging and educational. Include varied problem types: word prob
     
     def _estimate_difficulty(self, question_text: str) -> str:
         """Estimate question difficulty based on content"""
-        hard_keywords = ['prove', 'complex', 'advanced', 'multiple steps', 'system of']
-        easy_keywords = ['basic', 'simple', 'find', 'calculate', 'what is']
+        hard_keywords = ['system', 'equation', 'quadratic', 'prove', 'theorem', 'complex', 'advanced']
+        easy_keywords = ['add', 'subtract', 'simple', 'basic', 'find the', 'what is', 'how many']
         
         text_lower = question_text.lower()
         
@@ -518,8 +714,8 @@ def initialize_session_state():
             'badges': [],
             'streak': 0
         }
-    if 'seen_questions' not in st.session_state:
-        st.session_state.seen_questions = set()
+    if 'question_hashes' not in st.session_state:
+        st.session_state.question_hashes = set()
 
 @st.cache_resource
 def get_exam_system():
@@ -532,12 +728,49 @@ def render_hero_section():
         <div class="hero-title">🧮 MathGenius Academy</div>
         <div class="hero-subtitle">Master Mathematics Through Interactive Olympiad Training</div>
         <div style="margin-top: 1rem;">
-            <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 25px; margin: 0 0.5rem;">🎯 Adaptive Learning</span>
+            <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 25px; margin: 0 0.5rem;">🎯 Practical Problems</span>
             <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 25px; margin: 0 0.5rem;">📊 Progress Tracking</span>
             <span style="background: rgba(255,255,255,0.2); padding: 0.5rem 1rem; border-radius: 25px; margin: 0 0.5rem;">🏆 Achievement System</span>
         </div>
     </div>
-    """, unsafe_allow_html=True)
+    """, unsafe_allow_html = True)
+
+def render_timer_display():
+    """Render enhanced timer display with better positioning"""
+    if st.session_state.exam_mode == 'timed' and st.session_state.start_time:
+        total_time = len(st.session_state.questions) * 60  # 1 minute per question
+        elapsed = time.time() - st.session_state.start_time
+        remaining = max(0, total_time - elapsed)
+        
+        mins, secs = divmod(int(remaining), 60)
+        
+        # Add warning class if time is running low
+        warning_class = "timer-warning" if remaining <= 60 else ""
+        
+        timer_html = f"""
+        <div class="timer-display {warning_class}">
+            <div style="display: flex; align-items: center; justify-content: center; gap: 1rem;">
+                <div style="font-size: 3rem;">⏰</div>
+                <div>
+                    <div style="font-size: 2.5rem; font-weight: 800;">{mins:02d}:{secs:02d}</div>
+                    <div style="font-size: 1rem; opacity: 0.9;">Time Remaining</div>
+                </div>
+            </div>
+        </div>
+        """
+        
+        st.markdown(timer_html, unsafe_allow_html=True)
+        
+        # Auto-submit when time is up
+        if remaining <= 0:
+            st.error("⏰ Time's up! Auto-submitting your exam...")
+            st.session_state.exam_completed = True
+            time.sleep(1)
+            st.rerun()
+        
+        # Show warning when time is low
+        elif remaining <= 60:
+            st.warning(f"⚠️ Only {int(remaining)} seconds left!")
 
 def render_dashboard():
     """Render user dashboard with statistics"""
@@ -596,21 +829,9 @@ def render_dashboard():
                 paper_bgcolor='rgba(0,0,0,0)',
             )
             st.plotly_chart(fig, use_container_width=True)
-        
-        with col2:
-            st.markdown("#### 🎯 Grade Distribution")
-            grade_counts = df['grade'].value_counts().sort_index()
-            fig = px.bar(x=grade_counts.index, y=grade_counts.values,
-                        title='Exams by Grade Level',
-                        color_discrete_sequence=['#764ba2'])
-            fig.update_layout(
-                plot_bgcolor='rgba(0,0,0,0)',
-                paper_bgcolor='rgba(0,0,0,0)',
-            )
-            st.plotly_chart(fig, use_container_width=True)
 
 def render_question_card(question, question_index, total_questions):
-    """Render an individual question with enhanced UI"""
+    """Render an individual question with enhanced UI - FIXED"""
     progress = ((question_index + 1) / total_questions) * 100
     
     st.markdown(f"""
@@ -635,17 +856,51 @@ def render_question_card(question, question_index, total_questions):
     </div>
     """, unsafe_allow_html=True)
     
-    # Options with enhanced styling
-    option_labels = [opt.split(')', 1)[1].strip() for opt in question['options']]
-    option_keys = [opt.split(')', 1)[0].strip() for opt in question['options']]
+    # FIXED: Handle both list and dictionary options formats
+    if isinstance(question['options'], list):
+        # List format: ['A) text', 'B) text', ...]
+        option_keys = []
+        option_labels = []
+        for opt in question['options']:
+            if ')' in opt:
+                key, label = opt.split(')', 1)
+                option_keys.append(key.strip())
+                option_labels.append(label.strip())
+        
+        # Create format function for radio buttons
+        def format_option(key):
+            try:
+                idx = option_keys.index(key)
+                return f"{key}) {option_labels[idx]}"
+            except (ValueError, IndexError):
+                return f"{key}) Option not found"
+        
+        selected = st.radio(
+            "Choose your answer:",
+            options=option_keys,
+            format_func=format_option,
+            key=f"q_{question_index}",
+            index=None
+        )
+    
+    elif isinstance(question['options'], dict):
+        # Dictionary format: {'A': 'text', 'B': 'text', ...}
+        option_keys = list(question['options'].keys())
+        
+        def format_option_dict(key):
+            return f"{key}) {question['options'].get(key, 'Option not found')}"
+        
+        selected = st.radio(
+            "Choose your answer:",
+            options=option_keys,
+            format_func=format_option_dict,
+            key=f"q_{question_index}",
+            index=None
+        )
     
-    selected = st.radio(
-        "Choose your answer:",
-        options=option_keys,
-        format_func=lambda x, labels=option_labels, keys=option_keys: f"{x}) {labels[keys.index(x)]}",
-        key=f"q_{question_index}",
-        index=None
-    )
+    else:
+        st.error("Invalid options format in question data")
+        return None
     
     # Hint system
     if st.button(f"💡 Need a hint?", key=f"hint_{question_index}"):
@@ -657,30 +912,12 @@ def render_question_card(question, question_index, total_questions):
     return selected
 
 def render_exam_interface():
-    """Render the main exam interface"""
+    """Render the main exam interface with improved timer - FIXED"""
     questions = st.session_state.questions
     total_questions = len(questions)
     
-    if st.session_state.exam_mode == 'timed':
-        # Timer display
-        if st.session_state.start_time:
-            elapsed = time.time() - st.session_state.start_time
-            remaining = max(0, (total_questions * 120) - elapsed)  # 2 minutes per question
-            
-            mins, secs = divmod(int(remaining), 60)
-            st.markdown(f"""
-            <div style="text-align: center; margin-bottom: 1rem;">
-                <div style="background: linear-gradient(135deg, #FF6B6B, #FF8E8E); color: white; 
-                           padding: 1rem; border-radius: 15px; display: inline-block; font-size: 1.5rem; font-weight: 600;">
-                    ⏰ {mins:02d}:{secs:02d}
-                </div>
-            </div>
-            """, unsafe_allow_html=True)
-            
-            if remaining <= 0:
-                st.error("⏰ Time's up! Submitting your exam...")
-                st.session_state.exam_completed = True
-                st.rerun()
+    # Display timer at the top for timed mode
+    render_timer_display()
     
     # Question navigation
     if total_questions > 1:
@@ -695,6 +932,7 @@ def render_exam_interface():
     # Current question
     current_q = st.session_state.current_question
     if current_q < total_questions:
+        # FIXED: Call render_question_card as a standalone function
         selected = render_question_card(questions[current_q], current_q, total_questions)
         questions[current_q]['user_answer'] = selected
         
@@ -742,7 +980,7 @@ def calculate_badges(score, total, grade):
     return badges
 
 def render_results_section():
-    """Render enhanced results with animations and insights - REMOVED ACTION BUTTONS"""
+    """Render enhanced results with animations and insights"""
     st.markdown("---")
     st.markdown("### 🎉 Exam Results")
     
@@ -835,7 +1073,7 @@ def render_results_section():
             if not is_correct and question.get('hint'):
                 st.info(f"💡 **Hint for next time:** {question['hint']}")
     
-    # Performance insights
+    # Performance insights with bullet points
     exam_system = get_exam_system()
     if exam_system.client:
         st.markdown("#### 🧠 AI Performance Analysis")
@@ -854,12 +1092,12 @@ def render_results_section():
         </div>
         """, unsafe_allow_html=True)
     
-    # Show completion message instead of action buttons
+    # Show completion message
     st.markdown("#### 🎓 Exam Complete!")
     st.info("Great job completing the exam! Use the sidebar to generate a new exam or check out the Dashboard tab to view your progress.")
 
 def generate_enhanced_summary(grade, questions, score, total, exam_system):
-    """Generate enhanced AI-powered performance summary"""
+    """Generate enhanced AI-powered performance summary in bullet points"""
     try:
         # Analyze performance patterns
         correct_questions = [q for q in questions if q['user_answer'] == q['correct_answer']]
@@ -885,19 +1123,32 @@ PERFORMANCE SUMMARY:
 SAMPLE INCORRECT QUESTIONS:
 {chr(10).join([f"- {q['question_text'][:100]}..." for q in incorrect_questions[:2]])}
 
-Please provide a concise summary (max 4-5 sentences) with:
-- 1-2 key strengths
-- 1 main area to improve
-- 1 motivational message
-Use simple, encouraging language for a Grade {grade} student. Avoid long lists or detailed study plans."""
+Please provide a summary in BULLET POINTS with emojis using this exact format:
+
+🎯 **Strengths:**
+• [strength 1 with emoji]
+• [strength 2 with emoji]
+
+📈 **Areas to Improve:**
+• [area to improve 1 with emoji]
+• [area to improve 2 with emoji]
+
+💡 **Quick Tips:**
+• [tip 1 with emoji]
+• [tip 2 with emoji]
+
+🌟 **Motivation:**
+• [encouraging message with emoji]
+
+Use Grade {grade} appropriate language and keep each bullet point short and encouraging. Include relevant emojis for each point."""
 
         response = exam_system.client.chat.completions.create(
-            model="llama-3.3-70b-versatile",
+            model="openai/gpt-oss-120b",
             messages=[
-                {"role": "system", "content": "You are an expert Math Olympiad mentor providing detailed, encouraging feedback to help students improve."},
+                {"role": "system", "content": "You are an expert Math Olympiad mentor providing detailed, encouraging feedback in bullet points with emojis."},
                 {"role": "user", "content": prompt}
             ],
-            temperature=0.3,
+            temperature=0,
             max_tokens=1000
         )
         
@@ -905,9 +1156,20 @@ Use simple, encouraging language for a Grade {grade} student. Avoid long lists o
         
     except Exception as e:
         return f"""
-        **Performance Summary:**
-        You scored {score} out of {total} ({percentage:.1f}%).
-        Great job! You showed strong skills in several areas. Focus on reviewing the questions you missed. Keep practicing and you'll get even better! 🌟
+        🎯 **Strengths:**
+        • ✨ You completed {score} out of {total} questions correctly ({percentage:.1f}%)
+        • 💪 You showed good problem-solving skills
+        
+        📈 **Areas to Improve:**
+        • 📚 Review the questions you missed for better understanding
+        • ⏰ Work on time management if needed
+        
+        💡 **Quick Tips:**
+        • 🔍 Read each question carefully before answering
+        • 💭 Use hints when you're unsure
+        
+        🌟 **Motivation:**
+        • 🎉 Great effort! Keep practicing and you'll improve even more!
         """
 
 def reset_exam():
@@ -953,10 +1215,10 @@ def render_sidebar():
             ["practice", "timed", "challenge"],
             format_func=lambda x: {
                 "practice": "🎯 Practice Mode",
-                "timed": "⏰ Timed Mode", 
+                "timed": "⏰ Timed Mode (1 min/question)", 
                 "challenge": "🔥 Challenge Mode"
             }[x],
-            help="Practice: No time limit | Timed: 2 min/question | Challenge: Extra hard questions"
+            help="Practice: No time limit | Timed: 1 minute per question | Challenge: Extra hard questions"
         )
         st.session_state.exam_mode = exam_mode
         
@@ -966,6 +1228,10 @@ def render_sidebar():
         else:
             num_questions = st.slider("📊 Questions:", 3, 15, 5, help="Choose number of questions")
         
+        # Show timer info for timed mode
+        if exam_mode == "timed":
+            st.info(f"⏰ Total time: {num_questions} minutes ({num_questions} questions × 1 min each)")
+        
         # Difficulty level
         difficulty = st.select_slider(
             "⚡ Difficulty:",
@@ -983,7 +1249,7 @@ def render_sidebar():
             if not exam_system.client:
                 st.error("🚫 API not available!")
             else:
-                with st.spinner(f"🎭 Creating your {exam_mode} exam..."):
+                with st.spinner(f"🎭 Creating your {exam_mode} exam with unique questions..."):
                     # Add loading animation
                     progress_bar = st.progress(0)
                     for i in range(100):
@@ -994,21 +1260,13 @@ def render_sidebar():
                     questions = exam_system.generate_questions(grade, num_questions, challenge_difficulty)
                     
                     if questions:
-                        # Filter out previously seen questions
-                        if 'seen_questions' in st.session_state:
-                            new_questions = [q for q in questions if q['question_text'] not in st.session_state.seen_questions]
-                            st.session_state.questions = new_questions
-                            # Update seen_questions with the new questions
-                            st.session_state.seen_questions.update(q['question_text'] for q in new_questions)
-                        else:
-                            st.session_state.questions = questions
-                        
+                        st.session_state.questions = questions
                         st.session_state.exam_completed = False
                         st.session_state.grade_selected = grade
                         st.session_state.current_question = 0
                         st.session_state.start_time = time.time() if exam_mode == "timed" else None
                         
-                        st.success(f"✨ Generated {len(st.session_state.questions)} questions!")
+                        st.success(f"✨ Generated {len(st.session_state.questions)} unique questions!")
                         st.balloons()
                     else:
                         st.error("❌ Failed to generate exam. Try again!")
@@ -1068,26 +1326,26 @@ def render_welcome_screen():
         st.markdown("""
         <div style="background: linear-gradient(135deg, #667eea, #764ba2); color: white; padding: 1.5rem; border-radius: 15px; text-align: center; height: 200px; display: flex; flex-direction: column; justify-content: center;">
             <div style="font-size: 3rem; margin-bottom: 1rem;">🎯</div>
-            <h4 style="margin: 0.5rem 0; color: white;">Adaptive Learning</h4>
-            <p style="margin: 0; color: rgba(255,255,255,0.9);">Questions adjust to your skill level</p>
+            <h4 style="margin: 0.5rem 0; color: white;">Unique Questions</h4>
+            <p style="margin: 0; color: rgba(255,255,255,0.9);">Always new, never repeated</p>
         </div>
         """, unsafe_allow_html=True)
     
     with col2:
         st.markdown("""
         <div style="background: linear-gradient(135deg, #667eea, #764ba2); color: white; padding: 1.5rem; border-radius: 15px; text-align: center; height: 200px; display: flex; flex-direction: column; justify-content: center;">
-            <div style="font-size: 3rem; margin-bottom: 1rem;">📊</div>
-            <h4 style="margin: 0.5rem 0; color: white;">Progress Tracking</h4>
-            <p style="margin: 0; color: rgba(255,255,255,0.9);">See your improvement over time</p>
+            <div style="font-size: 3rem; margin-bottom: 1rem;">📝</div>
+            <h4 style="margin: 0.5rem 0; color: white;">Text-Based Only</h4>
+            <p style="margin: 0; color: rgba(255,255,255,0.9);">Pure math, no visual puzzles</p>
         </div>
         """, unsafe_allow_html=True)
     
     with col3:
         st.markdown("""
         <div style="background: linear-gradient(135deg, #667eea, #764ba2); color: white; padding: 1.5rem; border-radius: 15px; text-align: center; height: 200px; display: flex; flex-direction: column; justify-content: center;">
-            <div style="font-size: 3rem; margin-bottom: 1rem;">🏆</div>
-            <h4 style="margin: 0.5rem 0; color: white;">Achievement System</h4>
-            <p style="margin: 0; color: rgba(255,255,255,0.9);">Earn badges and unlock new levels</p>
+            <div style="font-size: 3rem; margin-bottom: 1rem;">⏰</div>
+            <h4 style="margin: 0.5rem 0; color: white;">Smart Timer</h4>
+            <p style="margin: 0; color: rgba(255,255,255,0.9);">1 minute per question</p>
         </div>
         """, unsafe_allow_html=True)
     
@@ -1103,7 +1361,7 @@ def render_welcome_screen():
         1. **🎯 Choose Your Grade**: Select your current grade level from the sidebar
         2. **📝 Pick Your Mode**: 
            - 🟢 **Practice Mode**: No time pressure, perfect for learning
-           - ⏰ **Timed Mode**: Challenge yourself with time limits
+           - ⏰ **Timed Mode**: 1 minute per question challenge
            - 🔥 **Challenge Mode**: Extra difficult questions for advanced learners
         3. **⚡ Set Difficulty**: Easy, Medium, or Hard - pick what feels right
         4. **📊 Choose Questions**: 3-20 questions depending on your time
@@ -1151,15 +1409,18 @@ def main():
         else:
             st.markdown("### 🧮 Math Olympiad Challenge")
             
-            if st.session_state.exam_mode == "timed" and st.session_state.start_time:
-                # Show exam info
-                col1, col2, col3 = st.columns(3)
-                with col1:
-                    st.info(f"📚 Grade {st.session_state.grade_selected}")
-                with col2:
+            # Show exam info
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.info(f"📚 Grade {st.session_state.grade_selected}")
+            with col2:
+                if st.session_state.exam_mode == "timed":
+                    total_time = len(st.session_state.questions)
+                    st.info(f"⏱️ {st.session_state.exam_mode.title()} Mode ({total_time} min)")
+                else:
                     st.info(f"⏱️ {st.session_state.exam_mode.title()} Mode")
-                with col3:
-                    st.info(f"📝 {len(st.session_state.questions)} Questions")
+            with col3:
+                st.info(f"📝 {len(st.session_state.questions)} Questions")
             
             render_exam_interface()
     
@@ -1243,14 +1504,14 @@ def main():
                 <div class="custom-card">
                     <h4 style="color: #667eea;">🤖 AI-Powered Learning</h4>
                     <ul style="color: #444;">
-                        <li><strong>Adaptive Questions:</strong> Problems that match your skill level</li>
+                        <li><strong>Unique Questions:</strong> Never see the same question twice</li>
                         <li><strong>Smart Difficulty:</strong> Automatic adjustment based on performance</li>
-                        <li><strong>Personalized Feedback:</strong> Detailed insights and recommendations</li>
+                        <li><strong>Text-Only Focus:</strong> Pure mathematical reasoning, no visual puzzles</li>
                     </ul>
                     <h4 style="color: #667eea;">🎮 Multiple Game Modes</h4>
                     <ul style="color: #444;">
                         <li><strong>Practice Mode:</strong> Learn at your own pace</li>
-                        <li><strong>Timed Mode:</strong> Build speed and confidence</li>
+                        <li><strong>Timed Mode:</strong> 1 minute per question challenge</li>
                         <li><strong>Challenge Mode:</strong> Push your limits with hard problems</li>
                     </ul>
                 </div>
@@ -1265,7 +1526,7 @@ def main():
                     <h4 style="color: #667eea;">📊 Progress & Analytics</h4>
                     <ul style="color: #444;">
                         <li><strong>Performance Tracking:</strong> Monitor improvement over time</li>
-                        <li><strong>Detailed Statistics:</strong> Accuracy, trends, and insights</li>
+                        <li><strong>Detailed Insights:</strong> Bullet-point feedback with emojis</li>
                         <li><strong>Visual Charts:</strong> Interactive graphs and analysis</li>
                     </ul>
                     <h4 style="color: #667eea;">🏆 Achievement System</h4>
@@ -1324,8 +1585,8 @@ def main():
                 <ul style="color: #444;">
                     <li>Basic arithmetic operations</li>
                     <li>Simple word problems</li>
-                    <li>Pattern recognition</li>
-                    <li>Basic geometry shapes</li>
+                    <li>Number patterns and sequences</li>
+                    <li>Basic geometry concepts</li>
                     <li>Counting and number sense</li>
                 </ul>
             </div>
@@ -1362,25 +1623,25 @@ def main():
         # FAQ Section
         with st.expander("❓ Frequently Asked Questions"):
             st.markdown("""
-            **Q: How are the questions generated?**
+            **Q: How are questions made unique?**
             
-            A: We use advanced AI to create unique, grade-appropriate questions that follow Math Olympiad standards.
+            A: We use advanced AI with hash tracking to ensure you never see the same question twice, even across different sessions.
             
-            **Q: Can I retake exams?**
+            **Q: Why text-based questions only?**
             
-            A: Yes! You can generate unlimited exams to practice and improve your skills.
+            A: We focus purely on mathematical reasoning and calculations, avoiding visual puzzles that don't translate well to text interfaces.
             
-            **Q: How is my progress tracked?**
+            **Q: How does the timer work in timed mode?**
             
-            A: We track your accuracy, response times, difficulty preferences, and improvement trends over time.
+            A: You get exactly 1 minute per question. For 5 questions, you get 5 minutes total. The timer is prominently displayed above the questions.
             
             **Q: What if I get stuck on a question?**
             
             A: Use the hint feature! We provide helpful hints to guide your thinking without giving away the answer.
             
-            **Q: Is there a time limit?**
+            **Q: How is my progress tracked?**
             
-            A: Only in Timed Mode. Practice and Challenge modes let you work at your own pace.
+            A: We track your accuracy, response times, difficulty preferences, and improvement trends with detailed analytics.
             
             **Q: How do I earn badges?**
             
@@ -1393,7 +1654,7 @@ def main():
         <div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 20px; color: white;">
             <h3 style="color: white; margin-bottom: 1rem;">Ready to become a Math Genius? 🧮</h3>
             <p style="color: rgba(255,255,255,0.9); margin: 0;">
-                Join thousands of students improving their mathematical skills every day!
+                Join thousands of students improving their mathematical skills with unique, challenging questions every day!
             </p>
         </div>
         """, unsafe_allow_html=True)
@@ -1402,4 +1663,5 @@ def main():
         st.markdown("**Made with ❤️ for young mathematicians everywhere!**")
 
 if __name__ == "__main__":
-    main()
+    main()
+