add new features

app.py

@@ -3,8 +3,8 @@ import streamlit as st
 from datetime import datetime, date, time, timedelta
 from pathlib import Path
 from utils.sample_data import SAMPLE_COURSES, SAMPLE_SESSIONS
-from session_page_alt import display_session_content
-# from session_page import display_session_content
+# from session_page_alt import display_session_content
+from session_page import display_session_content
 from db import (
     courses_collection2,
     faculty_collection,

file_upload_vectorize.py

@@ -25,7 +25,7 @@ resources_collection = db['resources']
 # Configure APIs
 openai.api_key = OPENAI_KEY
 genai.configure(api_key=GEMINI_KEY)
-model = genai.GenerativeModel('gemini-pro')
+model = genai.GenerativeModel('gemini-1.5-flash')
 
 def upload_resource(course_id, session_id, file_name, file_content, material_type):
     # material_data = {

gen_mcqs.py

@@ -206,6 +206,7 @@
 #         return None
 
 import ast
+from typing import Dict, List
 from pymongo import MongoClient
 from datetime import datetime
 import openai
@@ -305,6 +306,27 @@ def generate_mcqs(context, num_questions, session_title, session_description):
         print(f"Error generating MCQs: , error: {e}")
         return None
 
+def save_pre_class_quiz(course_id: str, session_id: str, title: str, questions: List[Dict], user_id: str, duration: int):
+    """Save pre-class quiz to database"""
+    try:
+        quiz_data = {
+            "user_id": user_id,
+            "course_id": course_id,
+            "session_id": session_id,
+            "title": title,
+            "questions": questions,
+            "created_at": datetime.now(),
+            "status": "active",
+            "submissions": [],
+            "duration_minutes": duration,
+            "quiz_type": "pre_class"
+        }
+        result = quizzes_collection.insert_one(quiz_data)
+        return result.inserted_id
+    except Exception as e:
+        print(f"Error saving quiz: {e}")
+        return None
+
 # New function to save quiz to database
 def save_quiz(course_id, session_id, title, questions, user_id):
     """Save quiz to database"""
@@ -412,26 +434,45 @@ def submit_quiz_answers(quiz_id, student_id, student_answers):
         if not quiz:
             return None
         
+        total_questions = len(quiz['questions'])
+        # Debug logging
+        print("\nScoring Debug:")
+        print(f"Total questions: {total_questions}")
+
         # Calculate score
         correct_answers = 0
-        total_questions = len(quiz['questions'])
         
         for q_idx, question in enumerate(quiz['questions']):
             student_answer = student_answers.get(str(q_idx))
+            correct_option = question['correct_option']
+
+            # Debug logging
+            print(f"\nQuestion {q_idx + 1}:")
+            print(f"Student answer: {student_answer}")
+            print(f"Correct option: {correct_option}")
+
             if student_answer:  # Only check if answer was provided
                 # Extract the option letter (A, B, C, D) from the full answer string
-                answer_letter = student_answer.split(')')[0].strip()
-                if answer_letter == question['correct_option']:
+                # answer_letter = student_answer.split(')')[0].strip()
+                # if answer_letter == question['correct_option']:
+                #     correct_answers += 1
+                if student_answer == correct_option:
                     correct_answers += 1
+                    print(f"✓ Correct! Total correct: {correct_answers}")
+                else:
+                    print("✗ Incorrect")
         
         score = (correct_answers / total_questions) * 100
+        print(f"\nFinal Score: {score}% ({correct_answers}/{total_questions} correct)")
         
         # Store submission
         submission_data = {
             "student_id": student_id,
             "answers": student_answers,
             "score": score,
-            "submitted_at": datetime.utcnow()
+            "submitted_at": datetime.utcnow(),
+            "correct_answers_count": correct_answers,
+            "total_questions": total_questions
         }
         
         # Update quiz with submission

inclass_questions.py

@@ -0,0 +1,738 @@
+from datetime import datetime, timedelta
+from typing import Dict, List
+from bson import ObjectId
+import pandas as pd
+import streamlit as st
+import json
+import google.generativeai as genai
+from dotenv import load_dotenv
+import os
+from pymongo import MongoClient
+import plotly.express as px
+
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+GEMINI_API_KEY = os.getenv('GEMINI_KEY')
+genai.configure(api_key=GEMINI_API_KEY)
+model = genai.GenerativeModel("gemini-1.5-flash")
+
+client = MongoClient(MONGO_URI)
+db = client['novascholar_db']
+courses_collection = db['courses']
+
+
+def generate_interval_questions(context: str, num_questions: int) -> List[Dict]:
+    """Generate all interval questions at once"""
+    prompt = f"""
+    Generate {num_questions} quick check-in questions based on the following context.
+    Return ONLY a JSON array with this exact structure:
+    [
+        {{
+            "question_text": "Your question here",
+            "type": "mcq OR short_answer",
+            "options": ["option1", "option2", "option3", "option4"],
+            "correct_option": "correct answer",
+            "explanation": "brief explanation"
+        }}
+    ]
+
+    Requirements:
+    - Each question should be answerable in 30-60 seconds
+    - Test understanding of different aspects of the material
+    - For MCQ, include exactly 4 options
+    - Questions should build in complexity
+    - **MAKE SURE THE NUMBER OF SHORT ANSWER QUESTIONS ARE MORE THAN MCQS**
+    - **MAKE SURE THE NUMBER OF MCQS DOES NOT EXCEED 2**
+    
+    Context: {context}
+    """
+    try:
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.GenerationConfig(
+                temperature=0.3,
+                response_mime_type="application/json"
+            )
+        )
+        
+        if not response.text:
+            raise ValueError("Empty response from model")
+        
+        questions = json.loads(response.text)
+        return questions
+        
+    except Exception as e:
+        st.error(f"Error generating questions: {e}")
+        return None
+
+class IntervalQuestionManager:
+    def __init__(self, session_id: str, course_id: str):
+        self.session_id = session_id
+        self.course_id = course_id
+        self.questions = []
+        self.current_index = 0
+        self.interval_minutes = 10
+        # self.start_time = self._get_start_time()
+        self.start_time = None
+        # self.questions = self._load_existing_questions()
+        self._initialize_from_db()
+    
+    # def _get_start_time(self):
+    #     """Retrieve start time from database"""
+    #     try:
+    #         session_data = courses_collection.find_one(
+    #             {
+    #                 "course_id": self.course_id,
+    #                 "sessions.session_id": self.session_id
+    #             },
+    #             {"sessions.$": 1}
+    #         )
+    #         if session_data and session_data.get('sessions'):
+    #             session = session_data['sessions'][0]
+    #             interval_data = session.get('in_class', {}).get('interval_questions', {})
+    #             if interval_data and 'start_time' in interval_data:
+    #                 return interval_data['start_time']
+    #         return None
+    #     except Exception as e:
+    #         st.error(f"Error getting start time: {e}")
+    #         return None
+        
+    # def _load_existing_questions(self) -> List[Dict]:
+    #     """Load existing interval questions from database"""
+    #     try:
+    #         session_data = courses_collection.find_one(
+    #             {
+    #                 "course_id": self.course_id,
+    #                 "sessions.session_id": self.session_id
+    #             },
+    #             {"sessions.$": 1}
+    #         )
+            
+    #         if session_data and session_data.get('sessions'):
+    #             session = session_data['sessions'][0]
+    #             interval_data = session.get('in_class', {}).get('interval_questions', {})
+    #             if interval_data and interval_data.get('questions'):
+    #                 print("Found existing questions:", len(interval_data['questions']))
+    #                 return interval_data['questions']
+    #         return []
+            
+    #     except Exception as e:
+    #         st.error(f"Error loading questions: {e}")
+    #         return []
+    
+    def _initialize_from_db(self):
+        """Load existing questions and settings from database"""
+        try:
+            session_data = courses_collection.find_one(
+                {
+                    "course_id": self.course_id,
+                    "sessions.session_id": self.session_id
+                },
+                {"sessions.$": 1}
+            )
+            
+            if session_data and session_data.get('sessions'):
+                session = session_data['sessions'][0]
+                interval_data = session.get('in_class', {}).get('interval_questions', {})
+                
+                if interval_data:
+                    self.questions = interval_data.get('questions', [])
+                    self.interval_minutes = interval_data.get('interval_minutes', 10)
+                    self.start_time = interval_data.get('start_time')
+                    print(f"Loaded {len(self.questions)} questions, interval: {self.interval_minutes} mins")
+                    
+        except Exception as e:
+            st.error(f"Error initializing from database: {e}")
+    
+    def initialize_questions(self, context: str, num_questions: int, interval_minutes: int):
+        if self.questions:  # If questions already exist, don't regenerate
+            return True
+        
+        """Initialize all questions and save to database"""
+        questions = generate_interval_questions(context, num_questions)
+        if not questions:
+            return False
+
+        self.questions = []
+        self.interval_minutes = interval_minutes
+            
+        for i, q in enumerate(questions):
+            question_doc = {
+                "_id": ObjectId(),
+                "question_text": q["question_text"],
+                "type": q["type"],
+                "options": q.get("options", []),
+                "correct_option": q.get("correct_option", ""),
+                "explanation": q.get("explanation", ""),
+                "display_after": i * interval_minutes,  # When to display this question
+                "active": False,
+                "submissions": []
+            }
+            self.questions.append(question_doc)
+        
+        # Save to database
+        result = courses_collection.update_one(
+            {
+                "course_id": self.course_id,
+                "sessions.session_id": self.session_id
+            },
+            {
+                "$set": {
+                    "sessions.$.in_class.interval_questions": {
+                        "questions": self.questions,
+                        "interval_minutes": self.interval_minutes,
+                        "start_time": None
+                    }
+                }
+            }
+        )
+        
+        return result.modified_count > 0
+    
+    # def start_questions(self):
+    #     """Start the interval questions"""
+    #     try:
+    #         self.start_time = datetime.now()
+            
+    #         # Update start time in database
+    #         result = courses_collection.update_one(
+    #             {
+    #                 "course_id": self.course_id,
+    #                 "sessions.session_id": self.session_id
+    #             },
+    #             {
+    #                 "$set": {
+    #                     "sessions.$.in_class.interval_questions.start_time": self.start_time
+    #                 }
+    #             }
+    #         )
+            
+    #         # Activate first question
+    #         if self.questions:
+    #             self.questions[0]["active"] = True
+                
+    #             # Update first question's active status in database
+    #             courses_collection.update_one(
+    #                 {
+    #                     "course_id": self.course_id,
+    #                     "sessions.session_id": self.session_id,
+    #                     "sessions.in_class.questions._id": self.questions[0]["_id"]
+    #                 },
+    #                 {
+    #                     "$set": {
+    #                         "sessions.$.in_class.questions.$.active": True,
+    #                         "sessions.$.in_class.questions.$.started_at": self.start_time
+    #                     }
+    #                 }
+    #             )
+    #         if result.modified_count > 0:
+    #             st.success("Questions started successfully!")
+    #         else:
+    #             st.error("Could not start questions. Please try again.")
+    #     except Exception as e:
+    #         st.error(f"Error starting questions: {str(e)}")
+    def start_questions(self):
+        """Start the interval questions"""
+        try:
+            self.start_time = datetime.now()
+            
+            result = courses_collection.update_one(
+                {
+                    "course_id": self.course_id,
+                    "sessions.session_id": self.session_id
+                },
+                {
+                    "$set": {
+                        "sessions.$.in_class.interval_questions.start_time": self.start_time
+                    }
+                }
+            )
+            
+            if result.modified_count > 0:
+                st.success("Questions started successfully!")
+            else:
+                st.error("Could not start questions. Please try again.")
+                
+        except Exception as e:
+            st.error(f"Error starting questions: {str(e)}")
+
+# def start_questions(self):
+#     """Start the interval questions"""
+#     self.start_time = datetime.now()
+#     courses_collection.update_one(
+#         {
+#             "course_id": self.course_id,
+#             "sessions.session_id": self.session_id
+#         },
+#         {
+#             "$set": {
+#                 "sessions.$.in_class.interval_questions.start_time": self.start_time
+#             }
+#         }
+#     )
+
+    # def get_current_question(self) -> Dict:
+    #     # """Get the currently active question based on elapsed time"""
+    #     # if not self.start_time:
+    #     #     return None
+            
+    #     # elapsed_minutes = (datetime.now() - self.start_time).total_seconds() / 60
+        
+    #     # # Find the latest question that should be displayed
+    #     # for question in reversed(self.questions):
+    #     #     if elapsed_minutes >= question["display_after"]:
+    #     #         return question
+                
+    #     # return None
+
+    #     """Get current question based on elapsed time"""
+    #     try:
+    #         if not self.start_time:
+    #             return None
+
+    #         questions = self.questions
+    #         if not questions: 
+    #             # Get questions from database
+    #             session_data = courses_collection.find_one(
+    #                 {
+    #                     "course_id": self.course_id,
+    #                     "sessions.session_id": self.session_id
+    #                 },
+    #                 {"sessions.$": 1}
+    #             )
+
+    #             if not session_data or not session_data.get('sessions'):
+    #                 return None
+
+    #             session = session_data['sessions'][0]
+    #             interval_data = session.get('in_class', {}).get('interval_questions', {})
+                
+    #             if not interval_data:
+    #                 return None
+
+    #             questions = interval_data.get('questions', [])
+    #             interval_minutes = interval_data.get('interval_minutes', 10)
+
+    #         # Calculate elapsed time
+    #         elapsed_minutes = (datetime.now() - self.start_time).total_seconds() / 60
+    #         question_index = int(elapsed_minutes // interval_minutes)
+
+    #         # Debug logging
+    #         print(f"Elapsed minutes: {elapsed_minutes}")
+    #         print(f"Question index: {question_index}")
+    #         print(f"Total questions: {len(questions)}")
+
+    #         # Return current question if valid index
+    #         if 0 <= question_index < len(questions):
+    #             return questions[question_index]
+    #         return None
+
+    #     except Exception as e:
+    #         st.error(f"Error getting current question: {e}")
+    #         return None
+    def get_current_question(self) -> Dict:
+        """Get current question based on elapsed time"""
+        try:
+            if not self.start_time or not self.questions:
+                return None
+
+            elapsed_minutes = (datetime.now() - self.start_time).total_seconds() / 60
+            question_index = int(elapsed_minutes // self.interval_minutes)
+
+            # Debug logging
+            print(f"Elapsed minutes: {elapsed_minutes}")
+            print(f"Question index: {question_index}")
+            print(f"Total questions: {len(self.questions)}")
+            print(f"Interval minutes: {self.interval_minutes}")
+
+            if 0 <= question_index < len(self.questions):
+                return self.questions[question_index]
+            return None
+
+        except Exception as e:
+            st.error(f"Error getting current question: {e}")
+            return None
+
+def display_response_distribution(course_id: str, session_id: str, question_id: str):
+    """Display real-time distribution of student responses"""
+    try:
+        session_data = courses_collection.find_one(
+            {
+                "course_id": course_id,
+                "sessions.session_id": session_id
+            },
+            {"sessions.$": 1}
+        )
+        
+        if not session_data or not session_data.get('sessions'):
+            st.warning("No responses found.")
+            return
+            
+        session = session_data['sessions'][0]
+        question = next(
+            (q for q in session['in_class']['interval_questions']['questions'] 
+             if str(q['_id']) == question_id),
+            None
+        )
+        
+        if not question:
+            st.warning("Question not found.")
+            return
+
+        submissions = question.get('submissions', [])
+        
+        if not submissions:
+            st.info("No responses received yet.")
+            return
+        
+        # Calculate response distribution
+        if question['type'] == 'mcq':
+            responses = {}
+            for submission in submissions:
+                answer = submission['answer']
+                responses[answer] = responses.get(answer, 0) + 1
+            
+            # Create DataFrame for visualization
+            df = pd.DataFrame(list(responses.items()), columns=['Option', 'Count'])
+            df['Percentage'] = df['Count'] / len(submissions) * 100
+            
+            # Display metrics
+            total_responses = len(submissions)
+            st.metric("Total Responses", total_responses)
+            
+            # Display bar chart
+            fig = px.bar(df, 
+                        x='Option', 
+                        y='Count',
+                        title='Response Distribution',
+                        text='Percentage')
+            fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
+            st.plotly_chart(fig)
+            
+            # Display detailed table
+            st.dataframe(df)
+
+        else:  # Short answer responses
+            st.markdown("##### Responses Received")
+            # for submission in submissions:
+            #     st.markdown(f"- {submission['answer']}")
+                
+            st.metric("Total Responses", len(submissions))
+            
+    except Exception as e:
+        st.error(f"Error displaying responses: {str(e)}")
+
+def display_interval_question(course_id, session, question: Dict, user_type: str):
+    """Display the interval question with different views for faculty/students"""
+    if not question:
+        return
+        
+    st.markdown("#### Quick Questions ⚡")
+    
+    try:
+        if user_type == "faculty":
+            with st.container():
+                st.markdown("##### Current Active Question")
+                st.markdown(f"**Question:** {question['question_text']}")
+                if question['type'] == 'mcq':
+                    display_response_distribution(course_id, session['session_id'], str(question['_id']))
+                    
+                # Add controls to end question period
+                col1, col2 = st.columns([3,1])
+                with col2:
+                    if st.button("End Question"):
+                        end_question_period(course_id, session['session_id'], str(question['_id']))
+                        st.rerun()
+            
+            # Display all questions overview
+            st.markdown("##### All Questions Overview")
+            
+            # Get all questions from the session
+            session_data = courses_collection.find_one(
+                {
+                    "course_id": course_id,
+                    "sessions.session_id": session['session_id']
+                },
+                {"sessions.$": 1}
+            )
+            
+            if session_data and session_data.get('sessions'):
+                interval_questions = session_data['sessions'][0].get('in_class', {}).get('interval_questions', {})
+                all_questions = interval_questions.get('questions', [])
+                
+                for idx, q in enumerate(all_questions, 1):
+                    with st.expander(f"Question {idx}", expanded=False):
+                        st.markdown(f"**Type:** {q['type'].upper()}")
+                        st.markdown(f"**Question:** {q['question_text']}")
+
+                        if q['type'] == 'mcq':
+                            st.markdown("**Options:**")
+                            for opt in q['options']:
+                                if opt == q['correct_option']:
+                                    st.markdown(f"✅ {opt}")
+                                else:
+                                    st.markdown(f"- {opt}")
+                        
+                        st.markdown(f"**Explanation:** {q['explanation']}")
+                        
+                        # Show when this question will be displayed
+                        display_time = timedelta(minutes=q['display_after'])
+                        st.info(f"Will be displayed after: {display_time}")
+                        
+                        # Show submission count if any
+                        submission_count = len(q.get('submissions', []))
+                        if submission_count > 0:
+                            st.metric("Responses received", submission_count)
+                    
+        else:  # Student view
+            # Check if student has already submitted
+            # existing_submission = next(
+            #     (sub for sub in question.get('submissions', [])
+            #      if sub['student_id'] == st.session_state.user_id),
+            #     None
+            # )
+            # Check for existing submission
+            existing_submission = _check_existing_submission(
+                course_id, 
+                session['session_id'], 
+                str(question['_id']), 
+                st.session_state.user_id
+            )
+            if existing_submission:
+                st.success("Response submitted!")
+                st.markdown(f"Your answer: **{existing_submission['answer']}**")
+                
+            else:
+                with st.form(key=f"question_form_{question['_id']}"):
+                    st.markdown(f"**Question:** {question['question_text']}")
+                    
+                    if question['type'] == 'mcq':
+                        response = st.radio(
+                            "Select your answer:",
+                            options=question['options'],
+                            key=f"mcq_{question['_id']}"
+                        )
+                    else:
+                        response = st.text_area(
+                            "Your answer:",
+                            key=f"text_{question['_id']}"
+                        )
+                        
+                    if st.form_submit_button("Submit"):
+                        if response:
+                            submit_response(
+                                course_id,
+                                session['session_id'],
+                                str(question['_id']),
+                                st.session_state.user_id,
+                                response
+                            )
+                            st.rerun()
+                        else:
+                            st.error("Please provide an answer before submitting.")
+
+    except Exception as e:
+        st.error(f"Error displaying question: {str(e)}")
+
+def _check_existing_submission(course_id: str, session_id: str, question_id: str, student_id: str) -> Dict:
+    """Check if student has already submitted an answer"""
+    try:
+        session_data = courses_collection.find_one(
+            {
+                "course_id": course_id,
+                "sessions.session_id": session_id,
+                "sessions.in_class.questions._id": ObjectId(question_id)
+            },
+            {"sessions.$": 1}
+        )
+        
+        if session_data and session_data.get('sessions'):
+            session = session_data['sessions'][0]
+            question = next(
+                (q for q in session['in_class']['questions'] 
+                 if str(q['_id']) == question_id),
+                None
+            )
+            
+            if question:
+                return next(
+                    (sub for sub in question.get('submissions', [])
+                     if sub['student_id'] == student_id),
+                    None
+                )
+        return None
+    except Exception as e:
+        st.error(f"Error checking submission: {e}")
+        return None
+
+def end_question_period(course_id: str, session_id: str, question_id: str):
+    """End the question period and mark the question as inactive"""
+    try:
+        result = courses_collection.update_one(
+            {
+                "course_id": course_id,
+                "sessions.session_id": session_id,
+                "sessions.in_class.questions._id": ObjectId(question_id)
+            },
+            {
+                "$set": {
+                    "sessions.$.in_class.questions.$.active": False,
+                    "sessions.$.in_class.questions.$.ended_at": datetime.utcnow()
+                }
+            }
+        )
+        
+        if result.modified_count > 0:
+            st.success("Question period ended successfully!")
+            st.rerun()
+        else:
+            st.warning("Could not end question period. Question may not exist.")
+            
+    except Exception as e:
+        st.error(f"Error ending question period: {e}")
+
+
+# def submit_response(course_id: str, session_id: str, question_id: str, student_id: str, response: str):
+#     """Submit a student's response to a question"""
+#     try:
+#         # First find the specific session and question
+#         session_query = {
+#             "course_id": course_id,
+#             "sessions": {
+#                 "$elemMatch": {
+#                     "session_id": session_id,
+#                     "in_class.interval_questions.questions._id": ObjectId(question_id)
+#                 }
+#             }
+#         }
+
+#         # Check for existing submission
+#         session_doc = courses_collection.find_one(session_query)
+#         if not session_doc:
+#             st.error("Question not found")
+#             return
+
+#         session = next((s for s in session_doc['sessions'] if s['session_id'] == session_id), None)
+#         if not session:
+#             st.error("Session not found")
+#             return
+
+#         question = next((q for q in session['in_class']['questions'] 
+#                        if str(q['_id']) == question_id), None)
+#         if not question:
+#             st.error("Question not found")
+#             return
+
+#         # Check for existing submission
+#         if any(sub['student_id'] == student_id for sub in question.get('submissions', [])):
+#             st.warning("You have already submitted an answer for this question.")
+#             return
+        
+#         # Add new submission
+#         result = courses_collection.update_one(
+#             {
+#                 "course_id": course_id,
+#                 "sessions.session_id": session_id,
+#                 "sessions.in_class.interval_questions.questions._id": ObjectId(question_id)
+#             },
+#             {
+#                 "$push": {
+#                     "sessions.$[session].in_class.interval_questions.questions.$[question].submissions": {
+#                         "student_id": student_id,
+#                         "answer": response,
+#                         "submitted_at": datetime.utcnow()
+#                     }
+#                 }
+#             },
+#             array_filters=[
+#                 {"session.session_id": session_id},
+#                 {"question._id": ObjectId(question_id)}
+#             ]
+#         )
+#         if result.modified_count > 0:
+#             st.success("Response submitted successfully!")
+#             st.rerun()
+#         else:
+#             st.error("Could not submit response. Question may not exist or be inactive.")
+            
+#     except Exception as e:
+#         st.error(f"Error submitting response: {str(e)}")
+def submit_response(course_id: str, session_id: str, question_id: str, student_id: str, response: str):
+    """Submit a student's response to a question"""
+    try:
+        # Debug prints
+        print(f"Submitting response for question {question_id}")
+        print(f"Course: {course_id}, Session: {session_id}")
+
+        # First find the specific session and question with correct path
+        session_doc = courses_collection.find_one(
+            {
+                "course_id": course_id,
+                "sessions.session_id": session_id
+            },
+            {"sessions.$": 1}
+        )
+
+        if not session_doc:
+            print("Session document not found")
+            st.error("Session not found")
+            return
+
+        session = session_doc['sessions'][0]
+        
+        # Get interval questions
+        interval_questions = session.get('in_class', {}).get('interval_questions', {})
+        if not interval_questions:
+            print("No interval questions found")
+            st.error("No questions found")
+            return
+
+        questions = interval_questions.get('questions', [])
+        
+        # Find specific question
+        question = next(
+            (q for q in questions if str(q['_id']) == question_id),
+            None
+        )
+        if not question:
+            print(f"Question {question_id} not found in questions list")
+            st.error("Question not found")
+            return
+
+        # Check for existing submission
+        if any(sub['student_id'] == student_id for sub in question.get('submissions', [])):
+            st.warning("You have already submitted an answer for this question.")
+            return
+
+        # Add new submission with correct path
+        result = courses_collection.update_one(
+            {
+                "course_id": course_id,
+                "sessions.session_id": session_id,
+                "sessions.in_class.interval_questions.questions._id": ObjectId(question_id)
+            },
+            {
+                "$push": {
+                    "sessions.$[ses].in_class.interval_questions.questions.$[q].submissions": {
+                        "student_id": student_id,
+                        "answer": response,
+                        "submitted_at": datetime.utcnow()
+                    }
+                }
+            },
+            array_filters=[
+                {"ses.session_id": session_id},
+                {"q._id": ObjectId(question_id)}
+            ]
+        )
+        print(f"Update result: {result.modified_count}")
+
+        if result.modified_count > 0:
+            st.success("Response submitted successfully!")
+            st.rerun()
+        else:
+            st.error("Could not submit response. Please try again.")
+
+    except Exception as e:
+        print(f"Error details: {str(e)}")
+        st.error(f"Error submitting response: {str(e)}")

session_page.py

@@ -5,6 +5,7 @@ import requests
 import streamlit as st
 from datetime import datetime, timedelta
 from youtube_transcript_api import YouTubeTranscriptApi
+from session_page_alt import display_pre_test_results, pre_generate_questions, pre_save_subjective_test, submit_pre_subjective_test
 from utils.helpers import display_progress_bar, create_notification, format_datetime
 from file_upload_vectorize import upload_resource, extract_text_from_file, create_vector_store, resources_collection, model, assignment_submit
 from db import courses_collection2, chat_history_collection, students_collection, faculty_collection, vectors_collection
@@ -16,7 +17,7 @@ import plotly.express as px
 from dotenv import load_dotenv
 import os
 from pymongo import MongoClient
-from gen_mcqs import generate_mcqs, save_quiz, quizzes_collection, get_student_quiz_score, submit_quiz_answers
+from gen_mcqs import generate_mcqs, save_pre_class_quiz, save_quiz, quizzes_collection, get_student_quiz_score, submit_quiz_answers
 from create_course import courses_collection
 # from pre_class_analytics import NovaScholarAnalytics
 from pre_class_analytics2 import NovaScholarAnalytics
@@ -53,6 +54,7 @@ assignment_evaluation_collection = db["assignment_evaluation"]
 subjective_tests_collection = db["subjective_tests"]
 synoptic_store_collection = db["synoptic_store"]
 assignments_collection = db["assignments"]
+chat_time_collection = db["chat_time"]
 
 # for implementing Context Caching: 
 # PROJECT_ID = "novascholar-446709"
@@ -265,129 +267,263 @@ def display_preclass_content(session, student_id, course_id):
 
     # Chat input
     # Add a check, if materials are available, only then show the chat input
-    if(st.session_state.user_type == "student"):
-        if materials:
-            if prompt := st.chat_input("Ask a question about Pre-class Materials"):
-                # if len(st.session_state.messages) >= 20:
-                #     st.warning("Message limit (20) reached for this session.")
-                #     return
-
-                st.session_state.messages.append({"role": "user", "content": prompt})
-
-                # Display User Message
-                with st.chat_message("user"):
-                    st.markdown(prompt)
-
-                # Get document context
-                context = ""
-                print("Session ID is: ", session['session_id'])
-                materials = resources_collection.find({"session_id": session['session_id']})
-                print(materials)
-                context = ""
-                vector_data = None
-
-                # for material in materials:
-                #     print(material)
-                context = ""
-                for material in materials:
-                    resource_id = material['_id']
-                    print("Supposed Resource ID is: ", resource_id)
-                    vector_data = vectors_collection.find_one({"resource_id": resource_id})
-                    # print(vector_data)
-                    if vector_data and 'text' in vector_data:
-                        context += vector_data['text'] + "\n"
-
-                if not vector_data:
-                    st.error("No Pre-class materials found for this session.")
-                    return
-
-                try:
-                    # Generate response using Gemini
-                    # context_prompt = f"""
-                    # Based on the following context, answer the user's question:
+    # if(st.session_state.user_type == "student"):
+    #     if materials:
+    #         if prompt := st.chat_input("Ask a question about Pre-class Materials"):
+    #             # if len(st.session_state.messages) >= 20:
+    #             #     st.warning("Message limit (20) reached for this session.")
+    #             #     return
+
+    #             st.session_state.messages.append({"role": "user", "content": prompt})
+
+    #             # Display User Message
+    #             with st.chat_message("user"):
+    #                 st.markdown(prompt)
+
+    #             # Get document context
+    #             context = ""
+    #             print("Session ID is: ", session['session_id'])
+    #             materials = resources_collection.find({"session_id": session['session_id']})
+    #             print(materials)
+    #             context = ""
+    #             vector_data = None
+
+    #             # for material in materials:
+    #             #     print(material)
+    #             context = ""
+    #             for material in materials:
+    #                 resource_id = material['_id']
+    #                 print("Supposed Resource ID is: ", resource_id)
+    #                 vector_data = vectors_collection.find_one({"resource_id": resource_id})
+    #                 # print(vector_data)
+    #                 if vector_data and 'text' in vector_data:
+    #                     context += vector_data['text'] + "\n"
+
+    #             if not vector_data:
+    #                 st.error("No Pre-class materials found for this session.")
+    #                 return
+
+    #             try:
+    #                 # Generate response using Gemini
+    #                 # context_prompt = f"""
+    #                 # Based on the following context, answer the user's question:
                     
-                    # Context:
-                    # {context}
+    #                 # Context:
+    #                 # {context}
                     
-                    # Question: {prompt}
+    #                 # Question: {prompt}
                     
-                    # Please provide a clear and concise answer based only on the information provided in the context.
-                    # """
-                    # context_prompt = f"""
-                    # You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context. 
-
-                    # Context:
-                    # {context}
-
-                    # Instructions:
-                    # 1. Base your answers primarily on the given context. 
-                    # 2. If the answer to the user's question is not explicitly in the context but can be inferred or synthesized from the information provided, do so thoughtfully.
-                    # 3. Only use external knowledge or web assistance when:
-                    # - The context lacks sufficient information, and
-                    # - The question requires knowledge beyond what can be reasonably inferred from the context.
-                    # 4. Clearly state if you are relying on web assistance for any part of your answer.
-                    # 5. Do not respond with a negative. If the answer is not in the context, provide a thoughtful response based on the information available on the web about it.
-
-                    # Question: {prompt}
-
-                    # Please provide a clear and comprehensive answer based on the above instructions.
-                    # """
-                    context_prompt = f"""
-                    You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context and external sources.
-
-                    Context:
-                    {context}
-
-                    Instructions:
-                    1. Base your answers on the provided context wherever possible.
-                    2. If the answer to the user's question is not explicitly in the context:
-                    - Use external knowledge or web assistance to provide a clear and accurate response.
-                    3. Do not respond negatively. If the answer is not in the context, use web assistance or your knowledge to generate a thoughtful response.
-                    4. Clearly state if part of your response relies on web assistance.
-
-                    Question: {prompt}
-
-                    Please provide a clear and comprehensive answer based on the above instructions.
-                    """
-
-                    response = model.generate_content(context_prompt)
-                    if not response or not response.text:
-                        st.error("No response received from the model")
-                        return
+    #                 # Please provide a clear and concise answer based only on the information provided in the context.
+    #                 # """
+    #                 # context_prompt = f"""
+    #                 # You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context. 
+
+    #                 # Context:
+    #                 # {context}
+
+    #                 # Instructions:
+    #                 # 1. Base your answers primarily on the given context. 
+    #                 # 2. If the answer to the user's question is not explicitly in the context but can be inferred or synthesized from the information provided, do so thoughtfully.
+    #                 # 3. Only use external knowledge or web assistance when:
+    #                 # - The context lacks sufficient information, and
+    #                 # - The question requires knowledge beyond what can be reasonably inferred from the context.
+    #                 # 4. Clearly state if you are relying on web assistance for any part of your answer.
+    #                 # 5. Do not respond with a negative. If the answer is not in the context, provide a thoughtful response based on the information available on the web about it.
+
+    #                 # Question: {prompt}
+
+    #                 # Please provide a clear and comprehensive answer based on the above instructions.
+    #                 # """
+    #                 context_prompt = f"""
+    #                 You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context and external sources.
+
+    #                 Context:
+    #                 {context}
+
+    #                 Instructions:
+    #                 1. Base your answers on the provided context wherever possible.
+    #                 2. If the answer to the user's question is not explicitly in the context:
+    #                 - Use external knowledge or web assistance to provide a clear and accurate response.
+    #                 3. Do not respond negatively. If the answer is not in the context, use web assistance or your knowledge to generate a thoughtful response.
+    #                 4. Clearly state if part of your response relies on web assistance.
+
+    #                 Question: {prompt}
+
+    #                 Please provide a clear and comprehensive answer based on the above instructions.
+    #                 """
+
+    #                 response = model.generate_content(context_prompt)
+    #                 if not response or not response.text:
+    #                     st.error("No response received from the model")
+    #                     return
+
+    #                 assistant_response = response.text
+    #                 # Display Assistant Response
+    #                 with st.chat_message("assistant"):
+    #                     st.markdown(assistant_response)
+
+    #                 # Build the message
+    #                 new_message = {
+    #                     "prompt": prompt,
+    #                     "response": assistant_response,
+    #                     "timestamp": datetime.utcnow()
+    #                 }
+    #                 st.session_state.messages.append(new_message)
+    #                 # Update database
+    #                 try:
+    #                     chat_history_collection.update_one(
+    #                         {
+    #                             "user_id": student_id,
+    #                             "session_id": session['session_id']
+    #                         },
+    #                         {
+    #                             "$push": {"messages": new_message},
+    #                             "$setOnInsert": {
+    #                                 "user_id": student_id,
+    #                                 "session_id": session['session_id'],
+    #                                 "timestamp": datetime.utcnow()
+    #                             }
+    #                         },
+    #                         upsert=True
+    #                     )
+    #                 except Exception as db_error:
+    #                     st.error(f"Error saving chat history: {str(db_error)}")
+    #             except Exception as e:
+    #                 st.error(f"Error generating response: {str(e)}")
+
+    if 'chat_session_active' not in st.session_state:
+        st.session_state.chat_session_active = False
+    if 'chat_session_start' not in st.session_state:
+        st.session_state.chat_session_start = None
 
-                    assistant_response = response.text
-                    # Display Assistant Response
-                    with st.chat_message("assistant"):
-                        st.markdown(assistant_response)
+    # Chat input
+    # Add a check, if materials are available, only then show the chat input
+    if st.session_state.user_type == "student":
+        if materials:
+            # Start chat session button
+            chat_time = chat_time_collection.find_one(
+                {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id}
+            )
 
-                    # Build the message
-                    new_message = {
-                        "prompt": prompt,
-                        "response": assistant_response,
-                        "timestamp": datetime.utcnow()
-                    }
-                    st.session_state.messages.append(new_message)
+            # Calculate session status and time remaining
+            current_time = datetime.now()
+            chat_active = False
+            time_remaining = None
+
+            if chat_time and "start_time" in chat_time:
+                session_end_time = chat_time["start_time"] + timedelta(minutes=20)
+                time_remaining = session_end_time - current_time
+                chat_active = time_remaining.total_seconds() > 0
+
+            # Display appropriate interface based on session status
+            if not chat_time or "start_time" not in chat_time:
+                # New session case
+                if st.button("Start Chat Session (20 minutes)"):
+                    st.session_state.chat_session_start = current_time
+                    st.session_state.chat_session_active = True
+                    
                     # Update database
+                    chat_time_collection.update_one(
+                        {
+                            "session_id": session["session_id"],
+                            "user_id": student_id,
+                            "course_id": course_id
+                        },
+                        {
+                            "$set": {
+                                "start_time": current_time,
+                                "end_time": current_time + timedelta(minutes=20)
+                            }
+                        },
+                        upsert=True
+                    )
+                    st.rerun()
+
+            elif chat_active:
+                # Active session case
+                minutes = int(time_remaining.total_seconds() // 60)
+                seconds = int(time_remaining.total_seconds() % 60)
+                st.info(f"⏱️ Time remaining: {minutes:02d}:{seconds:02d}")
+
+                # Show chat input
+                if prompt := st.chat_input("Ask a question about Pre-class Materials"):
+                    st.session_state.messages.append({"role": "user", "content": prompt})
+
+                    # Display User Message
+                    with st.chat_message("user"):
+                        st.markdown(prompt)
+                    
                     try:
-                        chat_history_collection.update_one(
-                            {
-                                "user_id": student_id,
-                                "session_id": session['session_id']
-                            },
-                            {
-                                "$push": {"messages": new_message},
-                                "$setOnInsert": {
-                                    "user_id": student_id,
-                                    "session_id": session['session_id'],
-                                    "timestamp": datetime.utcnow()
-                                }
-                            },
-                            upsert=True
-                        )
-                    except Exception as db_error:
-                        st.error(f"Error saving chat history: {str(db_error)}")
-                except Exception as e:
-                    st.error(f"Error generating response: {str(e)}")
+                        context = get_chat_context(session['session_id'])
+                        try:
+                            context_prompt = f"""
+                            You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context and external sources.
+
+                            Context:
+                            {context}
+
+                            Instructions:
+                            1. Base your answers on the provided context wherever possible.
+                            2. If the answer to the user's question is not explicitly in the context:
+                            - Use external knowledge or web assistance to provide a clear and accurate response.
+                            3. Do not respond negatively. If the answer is not in the context, use web assistance or your knowledge to generate a thoughtful response.
+                            4. Clearly state if part of your response relies on web assistance.
+
+                            Question: {prompt}
+
+                            Please provide a clear and comprehensive answer based on the above instructions.
+                            """
+
+                            response = model.generate_content(context_prompt)
+                            if not response or not response.text:
+                                st.error("No response received from the model")
+                                return
+
+                            assistant_response = response.text
+                            # Display Assistant Response
+                            with st.chat_message("assistant"):
+                                st.markdown(assistant_response)
+
+                            # Build the message
+                            new_message = {
+                                "prompt": prompt,
+                                "response": assistant_response,
+                                "timestamp": datetime.utcnow(),
+                            }
+                            st.session_state.messages.append(new_message)
+
+                            # Update database
+                            try:
+                                chat_history_collection.update_one(
+                                    {
+                                        "user_id": student_id,
+                                        "session_id": session["session_id"],
+                                    },
+                                    {
+                                        "$push": {"messages": new_message},
+                                        "$setOnInsert": {
+                                            "user_id": student_id,
+                                            "session_id": session["session_id"],
+                                            "timestamp": datetime.utcnow(),
+                                        },
+                                    },
+                                    upsert=True,
+                                )
+                                chat_time_collection.update_one(
+                                    {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id},
+                                    {"$set": {"end_time": datetime.now()}},
+                                    upsert=True
+                                )
+                            except Exception as db_error:
+                                st.error(f"Error saving chat history: {str(db_error)}")
+                        except Exception as e:
+                            st.error(f"Error generating response: {str(e)}")
+                    except Exception as e:
+                        st.error(f"Error processing message: {str(e)}")
+            
+            else:
+                # Expired session case
+                st.info("Chat session has ended. Time limit (20 minutes) reached.")
 
     else:
         st.subheader("Upload Pre-class Material")
@@ -432,6 +568,9 @@ def display_preclass_content(session, student_id, course_id):
             st.session_state.messages = []
     
     if st.session_state.user_type == 'student':
+        display_pre_class_quiz_tab(student_id, course_id, session["session_id"])
+        display_pre_subjective_test_tab(student_id, course_id, session["session_id"]) 
+
         st.subheader("Create a Practice Quiz")
         questions = []
         quiz_id = ""
@@ -574,6 +713,93 @@ def display_preclass_content(session, student_id, course_id):
                                 # except Exception as db_error:
                                 #     st.error(f"Error saving submission: {str(db_error)}")
 
+def display_pre_class_quiz_tab(student_id, course_id, session_id):
+    """Display pre-class quizzes for students"""
+    st.markdown("### Pre-class Quizzes")
+
+    # Get available quizzes
+    quizzes = quizzes_collection.find({
+        "course_id": course_id,
+        "session_id": session_id,
+        "status": "active"
+    })
+
+    quizzes = list(quizzes)
+    if not quizzes:
+        st.info("No pre-class quizzes available.")
+        return
+
+    for quiz in quizzes:
+        with st.expander(f"📝 {quiz['title']}", expanded=True):
+            # Check if already taken
+            existing_score = get_student_quiz_score(quiz["_id"], student_id)
+
+            if existing_score is not None:
+                st.success(f"Quiz completed! Score: {existing_score:.1f}%")
+                
+                # Show review
+                st.subheader("Quiz Review")
+                for i, question in enumerate(quiz["questions"]):
+                    st.markdown(f"**Q{i+1}:** {question['question']}")
+                    for opt in question["options"]:
+                        if opt.startswith(question["correct_option"]):
+                            st.markdown(f"✅ {opt}")
+                        else:
+                            st.markdown(f"- {opt}")
+
+            else:
+                # Check time remaining
+                start_time = quiz.get('start_time')
+                if not start_time:
+                    if st.button("Start Quiz", key=f"start_{quiz['_id']}"):
+                        quizzes_collection.update_one(
+                            {"_id": quiz["_id"]},
+                            {"$set": {"start_time": datetime.now()}}
+                        )
+                        st.rerun()
+                else:
+                    time_remaining = (start_time + timedelta(minutes=quiz['duration_minutes'])) - datetime.now()
+                    
+                    if time_remaining.total_seconds() > 0:
+                        st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)}:{int(time_remaining.total_seconds() % 60):02d}")
+                        
+                        # Display quiz form
+                        with st.form(f"pre_class_quiz_{quiz['_id']}"):
+                            student_answers = {}
+                            for i, question in enumerate(quiz["questions"]):
+                                st.markdown(f"**Q{i+1}:** {question['question']}")
+                                options = [opt for opt in question["options"]]
+                                student_answers[str(i)] = st.radio(
+                                    f"Select answer:",
+                                    options=options,
+                                    key=f"q_{quiz['_id']}_{i}"
+                                )
+
+                            if st.form_submit_button("Submit Quiz"):
+                                score = submit_quiz_answers(
+                                    quiz["_id"], 
+                                    student_id, 
+                                    student_answers
+                                )
+                                if score is not None:
+                                    st.success(f"Quiz submitted! Score: {score:.1f}%")
+                                    st.rerun()
+                                else:
+                                    st.error("Error submitting quiz")
+                    else:
+                        st.error("Quiz time expired")
+
+
+def get_chat_context(session_id):
+    """Get context from session materials"""
+    materials = resources_collection.find({"session_id": session_id})
+    context = ""
+    for material in materials:
+        if 'text_content' in material:
+            context += f"{material['text_content']}\n"
+    return context
+
+
 import requests
 
 def get_supported_url_formats():
@@ -771,12 +997,12 @@ def upload_video_source(course_id, session_id, video_url):
         """)
         return None
 
-def upload_preclass_materials(session_id, course_id):
+def upload_preclass_materials(session_id, course_id, student_id):
     """Upload pre-class materials and manage external resources for a session"""
     st.subheader("Pre-class Materials Management")
     
     # Create tabs for different functionalities
-    upload_tab, videos_tab, web_resources ,external_tab= st.tabs(["Upload Materials","Upload Video Sources","Web Resources", "Resources by Perplexity"])
+    upload_tab, videos_tab, web_resources ,external_tab, pre_class_tab, pre_class_evaluate, pre_class_quiz = st.tabs(["Upload Materials","Upload Video Sources","Web Resources", "Resources by Perplexity", "Pre-class Questions", "Pre-class Evaluation", "Pre-class Quiz"])
     
     with upload_tab:
         # Original file upload functionality
@@ -790,6 +1016,23 @@ def upload_preclass_materials(session_id, course_id):
                     if st.button("Upload Material"):
                         upload_resource(course_id, session_id, file_name, uploaded_file, material_type)
                         st.success("Material uploaded successfully!")
+        
+        # Display pre-class materials
+        # Group resources by their types
+        grouped_resources = defaultdict(list)
+        materials = resources_collection.find({"session_id": session_id})
+        for material in materials:
+            grouped_resources[material['material_type']].append(material)
+
+        # Display grouped resources
+        for material_type, resources in grouped_resources.items():
+            st.markdown(f"##### {material_type.capitalize()} Resources")
+            for material in resources:
+                resource_info = f"- **{material['file_name']}** ({material['file_type']})"
+                if 'source_url' in material:
+                    resource_info += f" - [URL]({material['source_url']})"
+                st.markdown(resource_info)
+    
     with videos_tab:
         # Upload video sources
         st.info("Upload video sources for this session.")
@@ -805,7 +1048,7 @@ def upload_preclass_materials(session_id, course_id):
         st.info("""
         Share online resources with your students. Supported links include:
         - Google Colab notebooks
-        - Google Slides presentations
+        - Google Slides   presentations
         - Online documentation
         - Educational websites
         - Any web-based learning resource
@@ -926,21 +1169,196 @@ def upload_preclass_materials(session_id, course_id):
                     - URL: [{resource['url']}]({resource['url']})
                     """)
 
-    # Display pre-class materials
-    # Group resources by their types
-    grouped_resources = defaultdict(list)
-    materials = resources_collection.find({"session_id": session_id})
-    for material in materials:
-        grouped_resources[material['material_type']].append(material)
+    with pre_class_tab:
+        if st.session_state.user_type == "faculty":
+            faculty_id = st.session_state.user_id
+            st.subheader("Create Pre class Subjective Test")
+
+            # Create a form for test generation
+            with st.form("pre_create_subjective_test_form"):
+                test_title = st.text_input("Test Title")
+                num_subjective_questions = st.number_input(
+                    "Number of Pre class Subjective Questions", min_value=1, value=5
+                )
+                generation_method = st.radio(
+                    "Question Generation Method", ["Generate from Pre-class Materials"]
+                )
+                generate_test_btn = st.form_submit_button("Generate Test for Pre Class")
+
+            # Handle test generation outside the form
+            if generate_test_btn:
+                if not test_title:
+                    st.error("Please enter a test title.")
+                    return
 
-    # Display grouped resources
-    for material_type, resources in grouped_resources.items():
-        st.markdown(f"##### {material_type.capitalize()} Resources")
-        for material in resources:
-            resource_info = f"- **{material['file_name']}** ({material['file_type']})"
-            if 'source_url' in material:
-                resource_info += f" - [URL]({material['source_url']})"
-            st.markdown(resource_info)
+                context = ""
+                if generation_method == "Generate from Pre-class Materials":
+                    materials = resources_collection.find(
+                        {"session_id": session["session_id"]}
+                    )
+                    for material in materials:
+                        if "text_content" in material:
+                            context += material["text_content"] + "\n"
+
+                with st.spinner("Generating questions and synoptic..."):
+                    try:
+                        # Store generated content in session state to persist between rerenders
+                        questions = pre_generate_questions(
+                            context if context else None,
+                            num_subjective_questions,
+                            session["title"],
+                            session.get("description", ""),
+                        )
+
+                        if questions:
+                            synoptic = generate_synoptic(
+                                questions,
+                                context if context else None,
+                                session["title"],
+                                num_subjective_questions,
+                            )
+
+                            if synoptic:
+                                # Store in session state
+                                st.session_state.generated_questions = questions
+                                st.session_state.generated_synoptic = synoptic
+                                st.session_state.test_title = test_title
+
+                                # Display preview
+                                st.subheader(
+                                    "Preview Subjective Questions and Synoptic"
+                                )
+                                for i, (q, s) in enumerate(zip(questions, synoptic), 1):
+                                    st.markdown(f"**Question {i}:** {q['question']}")
+                                    with st.expander(f"View Synoptic {i}"):
+                                        st.markdown(s)
+
+                                # Save button outside the form
+                                if st.button("Pre Save Test"):
+                                    test_id = pre_save_subjective_test(
+                                        course_id,
+                                        session["session_id"],
+                                        test_title,
+                                        questions,
+                                    )
+                                    if test_id:
+                                        st.success(
+                                            "Subjective test saved successfully!"
+                                        )
+                                    else:
+                                        st.error("Error saving subjective test.")
+                            else:
+                                st.error(
+                                    "Error generating synoptic answers. Please try again."
+                                )
+                        else:
+                            st.error("Error generating questions. Please try again.")
+                    except Exception as e:
+                        st.error(f"An error occurred: {str(e)}")
+
+            # Display previously generated test if it exists in session state
+            elif hasattr(st.session_state, "generated_questions") and hasattr(
+                st.session_state, "generated_synoptic"
+            ):
+                st.subheader("Preview Subjective Questions and Synoptic")
+                for i, (q, s) in enumerate(
+                    zip(
+                        st.session_state.generated_questions,
+                        st.session_state.generated_synoptic,
+                    ),
+                    1,
+                ):
+                    st.markdown(f"**Question {i}:** {q['question']}")
+                    with st.expander(f"View Synoptic {i}"):
+                        st.markdown(s)
+
+                if st.button("Pre Save Test"):
+                    test_id = pre_save_subjective_test(
+                        course_id,
+                        session["session_id"],
+                        st.session_state.test_title,
+                        st.session_state.generated_questions,
+                    )
+                    if test_id:
+                        st.success("Subjective test saved successfully!")
+                        # Clear session state after successful save
+                        del st.session_state.generated_questions
+                        del st.session_state.generated_synoptic
+                        del st.session_state.test_title
+                    else:
+                        st.error("Error saving subjective test.")
+
+
+    with pre_class_evaluate:
+        from subjective_test_evaluation import pre_display_evaluation_to_faculty
+        pre_display_evaluation_to_faculty(session["session_id"], student_id, course_id)
+
+    with pre_class_quiz:
+        if st.session_state.user_type == "faculty":
+            st.subheader("Create Pre-class Quiz")
+            with st.form("create_pre_class_quiz_form"):
+                quiz_title = st.text_input("Quiz Title")
+                num_questions = st.number_input(
+                    "Number of Questions", 
+                    min_value=1, 
+                    max_value=20, 
+                    value=5
+                )
+                duration = st.number_input(
+                    "Quiz Duration (minutes)", 
+                    min_value=5,
+                    max_value=60,
+                    value=15
+                )
+
+                # Generate quiz button
+                if st.form_submit_button("Generate Pre-class Quiz"):
+                    if not quiz_title:
+                        st.error("Please enter a quiz title")
+                        return
+
+                    # Get pre-class materials
+                    materials = resources_collection.find({"session_id": session_id})
+                    context = ""
+                    for material in materials:
+                        if 'text_content' in material:
+                            context += material['text_content'] + "\n"
+
+                    if not context:
+                        st.error("No pre-class materials found")
+                        return
+
+                    # Generate questions
+                    questions = generate_mcqs(
+                        context=context,
+                        num_questions=num_questions,
+                        session_title=session['title'],
+                        session_description=session.get('description', '')
+                    )
+
+                    if questions:
+                        # Preview questions
+                        st.subheader("Preview Questions")
+                        for i, q in enumerate(questions, 1):
+                            st.markdown(f"**Q{i}:** {q['question']}")
+                            for opt in q['options']:
+                                st.markdown(f"- {opt}")
+                            st.markdown(f"*Correct: {q['correct_option']}*")
+
+                        # Save quiz
+                        quiz_id = save_pre_class_quiz(
+                            course_id=course_id,
+                            session_id=session_id,
+                            title=quiz_title,
+                            questions=questions,
+                            user_id=st.session_state.user_id,
+                            duration=duration
+                        )
+
+                        if quiz_id:
+                            st.success("Pre-class quiz created successfully!")
+                        else:
+                            st.error("Error saving quiz")
 
 def extract_external_content(url, content_type):
     """Extract content from external resources based on their type"""
@@ -1445,26 +1863,26 @@ def display_session_outline(session, outline, course_id):
         # st.markdown('</div>', unsafe_allow_html=True)
 
         # Add save/download options
-        if st.button("💾 Save Outline"):
-            try:
-                courses_collection.update_one(
-                    {"course_id": course_id, "sessions.session_id": session['session_id']},
-                    {"$set": {"sessions.$.session_outline": st.session_state.session_outline}}
-                )
-                st.success("Outline saved successfully!")
-            except Exception as e:
-                st.error(f"Error saving outline: {str(e)}")
-
-        # Download option
-        if st.download_button(
-            "📥 Download Outline",
-            data=json.dumps(st.session_state.session_outline, indent=2),
-            file_name="session_outline.json",
-            mime="application/json"
-        ):
-            st.success("Outline downloaded successfully!")
-
-
+        # if st.button("💾 Save Outline"):
+        #     try:
+        #         courses_collection.update_one(
+        #             {"course_id": course_id, "sessions.session_id": session['session_id']},
+        #             {"$set": {"sessions.$.session_outline": st.session_state.session_outline}}
+        #         )
+        #         st.success("Outline saved successfully!")
+        #     except Exception as e:
+        #         st.error(f"Error saving outline: {str(e)}")
+
+        # # Download option
+        # if st.download_button(
+        #     "📥 Download Outline",
+        #     data=json.dumps(st.session_state.session_outline, indent=2),
+        #     file_name="session_outline.json",
+        #     mime="application/json"
+        # ):
+        #     st.success("Outline downloaded successfully!")
+
+from inclass_questions import IntervalQuestionManager, display_interval_question, display_response_distribution
 def display_in_class_content(session, user_type, course_id, user_id):
     # """Display in-class activities and interactions"""
     """Display in-class activities and interactions"""
@@ -1526,16 +1944,116 @@ def display_in_class_content(session, user_type, course_id, user_id):
                     outline = generate_session_outline(session['session_id'], course_id)
                     if outline:
                         display_session_outline(session, outline, course_id)
-                        st.rerun()
+                        # st.rerun()
                         print("Session outline is: ", outline)
                         # Save outline to database
-                        # courses_collection.update_one(
-                        #     {"course_id": course_id, "sessions.session_id": session['session_id']},
-                        #     {"$set": {"sessions.$.session_outline": outline}}
-                        # )
+                        st.success("Session outline generated and saved successfully!")
+                        courses_collection.update_one(
+                            {"course_id": course_id, "sessions.session_id": session['session_id']},
+                            {"$set": {"sessions.$.session_outline": outline}}
+                        )
         else:
             display_session_outline(session, st.session_state.session_outline, course_id)
 
+
+    # Initialize question manager in session state
+    if 'interval_questions' not in st.session_state:
+        st.session_state.interval_questions = IntervalQuestionManager(session['session_id'], course_id)
+    
+    # Faculty controls for interval questions
+    if user_type == 'faculty':
+        display_complete = False
+        st.markdown(f"<div style='margin-top: 10px;'></div>", unsafe_allow_html=True)
+        st.markdown("#### 📝 In-class Questions")
+        
+        # Question setup
+        if not st.session_state.interval_questions.questions:
+            with st.form("setup_interval_questions"):
+                num_questions = st.number_input(
+                    "Number of Questions",
+                    min_value=2,
+                    max_value=10,
+                    value=5
+                )
+                interval = st.number_input(
+                    "Minutes Between Questions",
+                    min_value=5,
+                    max_value=20,
+                    value=10
+                )
+                if st.form_submit_button("Generate Questions"):
+                    context = get_current_context(session)
+                    if st.session_state.interval_questions.initialize_questions(
+                        context, 
+                        num_questions, 
+                        interval
+                    ):
+                        st.success("Questions generated successfully!")
+                
+                    # Display all questions overview
+                    st.markdown("##### All Questions Overview")
+                    
+                    # Get all questions from the session
+                    session_data = courses_collection.find_one(
+                        {
+                            "course_id": course_id,
+                            "sessions.session_id": session['session_id']
+                        },
+                        {"sessions.$": 1}
+                    )
+                    
+                    if session_data and session_data.get('sessions'):
+                        interval_questions = session_data['sessions'][0].get('in_class', {}).get('interval_questions', {})
+                        all_questions = interval_questions.get('questions', [])
+                        
+                        for idx, q in enumerate(all_questions, 1):
+                            with st.expander(f"Question {idx}", expanded=False):
+                                st.markdown(f"**Type:** {q['type'].upper()}")
+                                st.markdown(f"**Question:** {q['question_text']}")
+
+                                if q['type'] == 'mcq':
+                                    st.markdown("**Options:**")
+                                    for opt in q['options']:
+                                        if opt == q['correct_option']:
+                                            st.markdown(f"✅ {opt}")
+                                        else:
+                                            st.markdown(f"- {opt}")
+                                
+                                st.markdown(f"**Explanation:** {q['explanation']}")
+                                
+                                # Show when this question will be displayed
+                                display_time = timedelta(minutes=q['display_after'])
+                                st.info(f"Will be displayed after: {display_time}")
+                                
+                                # Show submission count if any
+                                submission_count = len(q.get('submissions', []))
+                                if submission_count > 0:
+                                    st.metric("Responses received", submission_count)
+                                
+                                display_complete = True
+                                
+            if display_complete and st.button("Save and Start Questions"):
+                st.rerun()
+
+        # Start questions button
+        elif not st.session_state.interval_questions.start_time:
+            if st.button("Start Interval Questions"):
+                st.session_state.interval_questions.start_questions()
+                st.rerun()
+
+        # Display current question status
+        else:
+            current_q = st.session_state.interval_questions.get_current_question()
+            if current_q:
+                st.markdown(f"**Current Question:** {current_q['question_text']}")
+                display_response_distribution(course_id, session['session_id'], str(current_q['_id']))
+
+    # Student view
+    else:
+        current_q = st.session_state.interval_questions.get_current_question()
+        if current_q:
+            display_interval_question(course_id, session, current_q, user_type)
+
     # Initialize Live Polls feature
     live_polls = LivePollFeature()
     
@@ -2676,6 +3194,56 @@ def display_preclass_analytics2(session, course_id):
             # st.markdown('</div>', unsafe_allow_html=True)
 
         # Display student metrics in a grid
+        # st.markdown('<div class="analytics-grid">', unsafe_allow_html=True)
+        # for student in analytics["student_analytics"]:
+        #     # Apply filters
+        #     if (concept_understanding != "All" and 
+        #         student["engagement_metrics"]["concept_understanding"].replace("_", " ").title() != concept_understanding):
+        #         continue
+                
+        #     participation = student["engagement_metrics"]["participation_level"] * 100
+        #     if participation_level != "All":
+        #         if participation_level == "High (>80%)" and participation <= 80:
+        #             continue
+        #         elif participation_level == "Medium (50-80%)" and (participation < 50 or participation > 80):
+        #             continue
+        #         elif participation_level == "Low (<50%)" and participation >= 50:
+        #             continue
+                    
+        #     if struggling_topic != "All" and struggling_topic not in student["struggling_topics"]:
+        #         continue
+
+        #     st.markdown(f"""
+        #         <div class="student-metrics-card">
+        #             <div class="header">
+        #                 <span class="student-id">Student {student["student_id"][-6:]}</span>
+        #             </div>
+        #             <div class="metrics-grid">
+        #                 <div class="metric-box">
+        #                     <div class="label">Participation</div>
+        #                     <div class="value">{student["engagement_metrics"]["participation_level"]*100:.1f}%</div>
+        #                 </div>
+        #                 <div class="metric-box">
+        #                     <div class="label">Understanding</div>
+        #                     <div class="value">{student["engagement_metrics"]["concept_understanding"].replace('_', ' ').title()}</div>
+        #                 </div>
+        #                 <div class="struggling-topics">
+        #                     <div class="label">Struggling Topics: </div>
+        #                     <div class="value">{", ".join(student["struggling_topics"]) if student["struggling_topics"] else "None"}</div>
+        #                 </div>
+        #                 <div class="recommendation-text">
+        #                     {student["personalized_recommendation"]}
+        #                 </div>
+        #             </div>
+        #         </div>
+        #     """, unsafe_allow_html=True)
+        # st.markdown('</div>', unsafe_allow_html=True)
+        st.markdown('<div class="analytics-grid">', unsafe_allow_html=True)
+        
+        student_ids = [student["student_id"] for student in analytics["student_analytics"]]
+        student_names = {str(student["_id"]): student["full_name"] for student in students_collection.find({"_id": {"$in": [ObjectId(sid) for sid in student_ids]}})}
+
+            # Display student metrics in a grid
         st.markdown('<div class="analytics-grid">', unsafe_allow_html=True)
         for student in analytics["student_analytics"]:
             # Apply filters
@@ -2695,10 +3263,12 @@ def display_preclass_analytics2(session, course_id):
             if struggling_topic != "All" and struggling_topic not in student["struggling_topics"]:
                 continue
 
+            student_name = student_names.get(student["student_id"], "Unknown Student")
+
             st.markdown(f"""
                 <div class="student-metrics-card">
                     <div class="header">
-                        <span class="student-id">Student {student["student_id"][-6:]}</span>
+                        <span class="student-id">Student: {student_name}</span>
                     </div>
                     <div class="metrics-grid">
                         <div class="metric-box">
@@ -2901,7 +3471,7 @@ def display_session_content(student_id, course_id, session, username, user_type)
             "Evaluate Subjective Tests"
         ])
         with tabs[0]:
-            upload_preclass_materials(session['session_id'], course_id)
+            upload_preclass_materials(session['session_id'], course_id, student_id)
         with tabs[1]:
             display_in_class_content(session, user_type, course_id, user_type)
         with tabs[2]:
@@ -3278,6 +3848,120 @@ def display_subjective_test_tab(student_id, course_id, session_id):
         st.error("An error occurred while loading the tests. Please try again later.")
         print(f"Error in display_subjective_test_tab: {str(e)}")
         
+
+pre_subjective_test_evaluation_collection = db["pre_subjective_test_evaluation"]
+pre_subjective_tests_collection = db["pre_subjective_tests"]
+
+def display_pre_subjective_test_tab(student_id, course_id, session_id):
+    """Display subjective tests and results for students"""
+    st.markdown("### Pre-class Subjective Questions ")
+
+    try:
+        print("course_id", course_id, "session_id", session_id, "student_id", student_id)
+        subjective_tests = list(
+            pre_subjective_tests_collection.find(
+                {"course_id": course_id,"session_id" : str(session_id),  "status": "active"}
+            )
+        )
+        print("subjective_tests", subjective_tests)
+
+        if not subjective_tests:
+            print("bruh")
+            st.info("No pre subjective questions available for this session.")
+            return
+
+        # Create tabs for Tests and Results
+        test_tab, results_tab = st.tabs(["Available Tests", "Test Results"])
+
+        with test_tab:
+            for test in subjective_tests:
+                with st.expander(f"📝 {test['title']}", expanded=True):
+                    # Check for existing submission
+                    existing_submission = next(
+                        (
+                            sub
+                            for sub in test.get("submissions", [])
+                            if sub["student_id"] == str(student_id)
+                        ),
+                        None,
+                    )
+
+                    if existing_submission:
+                        st.success("Test completed! Your answers have been submitted.")
+                        st.subheader("Your Answers")
+                        for i, ans in enumerate(existing_submission["answers"]):
+                            st.markdown(
+                                f"**Question {i+1}:** {test['questions'][i]['question']}"
+                            )
+                            st.markdown(f"**Your Answer:** {ans}")
+                            st.markdown("---")
+                    else:
+                        st.write("Please write your answers:")
+                        with st.form(key=f"pre_subjective_test_form_{test['_id']}"):
+                            student_answers = []
+                            for i, question in enumerate(test["questions"]):
+                                st.markdown(
+                                    f"**Question {i+1}:** {question['question']}"
+                                )
+                                answer = st.text_area(
+                                    "Your answer:",
+                                    key=f"q_{test['_id']}_{i}",
+                                    height=200,
+                                )
+                                student_answers.append(answer)
+
+                            if st.form_submit_button("Submit Pre Test"):
+                                if all(answer.strip() for answer in student_answers):
+                                    success = submit_pre_subjective_test(
+                                        test["_id"], str(student_id), student_answers
+                                    )
+                                    if success:
+                                        st.success("Test submitted successfully!")
+                                        st.rerun()
+                                    else:
+                                        st.error(
+                                            "Error submitting test. Please try again."
+                                        )
+                                else:
+                                    st.error(
+                                        "Please answer all questions before submitting."
+                                    )
+
+        with results_tab:
+            # Display results for completed tests
+            completed_tests = [
+                test
+                for test in subjective_tests
+                if any(
+                    sub["student_id"] == str(student_id)
+                    for sub in test.get("submissions", [])
+                )
+            ]
+
+            if not completed_tests:
+                st.info("You haven't completed any tests yet.")
+                return
+
+            # Create a selectbox for choosing which test results to view
+            test_options = {
+                f"{test['title']} (Submitted: {next(sub['submitted_at'].strftime('%Y-%m-%d') for sub in test['submissions'] if sub['student_id'] == str(student_id))})": test[
+                    "_id"
+                ]
+                for test in completed_tests
+            }
+
+            selected_test = st.selectbox(
+                "Select a test to view results:", options=list(test_options.keys())
+            )
+
+            if selected_test:
+                test_id = test_options[selected_test]
+                display_pre_test_results(test_id, student_id)
+
+    except Exception as e:
+        st.error("An error occurred while loading the tests. Please try again later.")
+        print(f"Error in display_subjective_test_tab: {str(e)}")
+
 def display_test_results(test_id, student_id):
     """
     Display test results and analysis for a student

session_page_alt.py

@@ -18,6 +18,7 @@ import os
 from pymongo import MongoClient
 from gen_mcqs import (
     generate_mcqs,
+    save_pre_class_quiz,
     save_quiz,
     save_surprise_quiz,
     quizzes_collection,
@@ -282,6 +283,11 @@ def display_preclass_content(session, student_id, course_id):
     if 'messages' not in st.session_state:
         st.session_state.messages = []
 
+    if 'chat_session_active' not in st.session_state:
+        st.session_state.chat_session_active = False
+    if 'chat_session_start' not in st.session_state:
+        st.session_state.chat_session_start = None
+
     # Chat input
     # Add a check, if materials are available, only then show the chat input
     if st.session_state.user_type == "student":
@@ -290,104 +296,58 @@ def display_preclass_content(session, student_id, course_id):
             chat_time = chat_time_collection.find_one(
                 {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id}
             )
-            start_time = chat_time["start_time"] if chat_time and "start_time" in chat_time else None
-            print("Start Time is: ", start_time)
-            if start_time is None:
+
+            # Calculate session status and time remaining
+            current_time = datetime.now()
+            chat_active = False
+            time_remaining = None
+
+            if chat_time and "start_time" in chat_time:
+                session_end_time = chat_time["start_time"] + timedelta(minutes=20)
+                time_remaining = session_end_time - current_time
+                chat_active = time_remaining.total_seconds() > 0
+
+            # Display appropriate interface based on session status
+            if not chat_time or "start_time" not in chat_time:
+                # New session case
                 if st.button("Start Chat Session (20 minutes)"):
-                    st.session_state.chat_session_start = datetime.now()
+                    st.session_state.chat_session_start = current_time
+                    st.session_state.chat_session_active = True
+                    
+                    # Update database
                     chat_time_collection.update_one(
-                        {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id},
-                        {"$set": {"start_time": st.session_state.chat_session_start}},
+                        {
+                            "session_id": session["session_id"],
+                            "user_id": student_id,
+                            "course_id": course_id
+                        },
+                        {
+                            "$set": {
+                                "start_time": current_time,
+                                "end_time": current_time + timedelta(minutes=20)
+                            }
+                        },
                         upsert=True
                     )
-                    st.session_state.chat_session_active = True
                     st.rerun()
-            # else:
-            #     st.info("Chat session is now disabled.")
 
-            # Check if chat session is active and within time limit
-            chat_time = chat_time_collection.find_one(
-                {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id}
-            )
-            cond = False
-            if chat_time is None or "start_time" not in chat_time or (chat_time["start_time"] + timedelta(minutes=20)) <= datetime.now():
-                cond = True
-
-            if st.session_state.chat_session_active and st.session_state.chat_session_start and not cond:
-                current_time = datetime.now()
-                time_elapsed = current_time - chat_time["start_time"]
-                time_remaining = timedelta(minutes=20) - time_elapsed
-
-                if time_remaining.total_seconds() > 0:
-                    # Display remaining time
-                    st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)} minutes and {int(time_remaining.total_seconds() % 60)} seconds")
-                    
-                    # Show chat input
-                    if prompt := st.chat_input("Ask a question about Pre-class Materials"):
-                        st.session_state.messages.append({"role": "user", "content": prompt})
-
-                        # Display User Message
-                        with st.chat_message("user"):
-                            st.markdown(prompt)
-
-                        # Get document context
-                        context = ""
-                        print("Session ID is: ", session["session_id"])
-                        materials = resources_collection.find(
-                            {"session_id": session["session_id"]}
-                        )
-                        print(materials)
-                        context = ""
-                        vector_data = None
-
-                        # for material in materials:
-                        #     print(material)
-                        context = ""
-                        for material in materials:
-                            resource_id = material["_id"]
-                            print("Supposed Resource ID is: ", resource_id)
-                            vector_data = vectors_collection.find_one(
-                                {"resource_id": resource_id}
-                            )
-                            # print(vector_data)
-                            if vector_data and "text" in vector_data:
-                                context += vector_data["text"] + "\n"
+            elif chat_active:
+                # Active session case
+                minutes = int(time_remaining.total_seconds() // 60)
+                seconds = int(time_remaining.total_seconds() % 60)
+                st.info(f"⏱️ Time remaining: {minutes:02d}:{seconds:02d}")
 
-                        if not vector_data:
-                            st.error("No Pre-class materials found for this session.")
-                            return
+                # Show chat input
+                if prompt := st.chat_input("Ask a question about Pre-class Materials"):
+                    st.session_state.messages.append({"role": "user", "content": prompt})
 
+                    # Display User Message
+                    with st.chat_message("user"):
+                        st.markdown(prompt)
+                    
+                    try:
+                        context = get_chat_context(session['session_id'])
                         try:
-                            # Generate response using Gemini
-                            # context_prompt = f"""
-                            # Based on the following context, answer the user's question:
-
-                            # Context:
-                            # {context}
-
-                            # Question: {prompt}
-
-                            # Please provide a clear and concise answer based only on the information provided in the context.
-                            # """
-                            # context_prompt = f"""
-                            # You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context.
-
-                            # Context:
-                            # {context}
-
-                            # Instructions:
-                            # 1. Base your answers primarily on the given context.
-                            # 2. If the answer to the user's question is not explicitly in the context but can be inferred or synthesized from the information provided, do so thoughtfully.
-                            # 3. Only use external knowledge or web assistance when:
-                            # - The context lacks sufficient information, and
-                            # - The question requires knowledge beyond what can be reasonably inferred from the context.
-                            # 4. Clearly state if you are relying on web assistance for any part of your answer.
-                            # 5. Do not respond with a negative. If the answer is not in the context, provide a thoughtful response based on the information available on the web about it.
-
-                            # Question: {prompt}
-
-                            # Please provide a clear and comprehensive answer based on the above instructions.
-                            # """
                             context_prompt = f"""
                             You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context and external sources.
 
@@ -450,10 +410,178 @@ def display_preclass_content(session, student_id, course_id):
                                 st.error(f"Error saving chat history: {str(db_error)}")
                         except Exception as e:
                             st.error(f"Error generating response: {str(e)}")
-                else:
-                    st.warning("Chat session has expired. The 20-minute time limit has been reached.")
-                    st.session_state.chat_session_active = False
-                    st.session_state.chat_session_start = None
+                    except Exception as e:
+                        st.error(f"Error processing message: {str(e)}")
+            
+            else:
+                # Expired session case
+                st.info("Chat session has ended. Time limit (20 minutes) reached.")
+
+
+            # start_time = chat_time["start_time"] if chat_time and "start_time" in chat_time else None
+            # print("Start Time is: ", start_time)
+            # if start_time is None:
+            #     if st.button("Start Chat Session (20 minutes)"):
+            #         st.session_state.chat_session_start = datetime.now()
+            #         chat_time_collection.update_one(
+            #             {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id},
+            #             {"$set": {"start_time": st.session_state.chat_session_start}},
+            #             upsert=True
+            #         )
+            #         st.session_state.chat_session_active = True
+            #         st.rerun()
+            # else:
+            #     st.info("Chat session is now disabled.")
+
+            # # Check if chat session is active and within time limit
+            # chat_time = chat_time_collection.find_one(
+            #     {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id}
+            # )
+            # cond = False
+            # if chat_time is None or "start_time" not in chat_time or (chat_time["start_time"] + timedelta(minutes=20)) <= datetime.now():
+            #     cond = True
+
+            # if st.session_state.chat_session_active and st.session_state.chat_session_start and not cond:
+            #     current_time = datetime.now()
+            #     time_elapsed = current_time - chat_time["start_time"]
+            #     time_remaining = timedelta(minutes=20) - time_elapsed
+
+            #     if time_remaining.total_seconds() > 0:
+            #         # Display remaining time
+            #         st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)} minutes and {int(time_remaining.total_seconds() % 60)} seconds")
+                    
+            #         # Show chat input
+            #         if prompt := st.chat_input("Ask a question about Pre-class Materials"):
+            #             st.session_state.messages.append({"role": "user", "content": prompt})
+
+            #             # Display User Message
+            #             with st.chat_message("user"):
+            #                 st.markdown(prompt)
+
+            #             # Get document context
+            #             context = ""
+            #             print("Session ID is: ", session["session_id"])
+            #             materials = resources_collection.find(
+            #                 {"session_id": session["session_id"]}
+            #             )
+            #             print(materials)
+            #             context = ""
+            #             vector_data = None
+
+            #             # for material in materials:
+            #             #     print(material)
+            #             context = ""
+            #             for material in materials:
+            #                 resource_id = material["_id"]
+            #                 print("Supposed Resource ID is: ", resource_id)
+            #                 vector_data = vectors_collection.find_one(
+            #                     {"resource_id": resource_id}
+            #                 )
+            #                 # print(vector_data)
+            #                 if vector_data and "text" in vector_data:
+            #                     context += vector_data["text"] + "\n"
+
+            #             if not vector_data:
+            #                 st.error("No Pre-class materials found for this session.")
+            #                 return
+
+            #             try:
+            #                 # Generate response using Gemini
+            #                 # context_prompt = f"""
+            #                 # Based on the following context, answer the user's question:
+
+            #                 # Context:
+            #                 # {context}
+
+            #                 # Question: {prompt}
+
+            #                 # Please provide a clear and concise answer based only on the information provided in the context.
+            #                 # """
+            #                 # context_prompt = f"""
+            #                 # You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context.
+
+            #                 # Context:
+            #                 # {context}
+
+            #                 # Instructions:
+            #                 # 1. Base your answers primarily on the given context.
+            #                 # 2. If the answer to the user's question is not explicitly in the context but can be inferred or synthesized from the information provided, do so thoughtfully.
+            #                 # 3. Only use external knowledge or web assistance when:
+            #                 # - The context lacks sufficient information, and
+            #                 # - The question requires knowledge beyond what can be reasonably inferred from the context.
+            #                 # 4. Clearly state if you are relying on web assistance for any part of your answer.
+            #                 # 5. Do not respond with a negative. If the answer is not in the context, provide a thoughtful response based on the information available on the web about it.
+
+            #                 # Question: {prompt}
+
+            #                 # Please provide a clear and comprehensive answer based on the above instructions.
+            #                 # """
+            #                 context_prompt = f"""
+            #                 You are a highly intelligent and resourceful assistant capable of synthesizing information from the provided context and external sources.
+
+            #                 Context:
+            #                 {context}
+
+            #                 Instructions:
+            #                 1. Base your answers on the provided context wherever possible.
+            #                 2. If the answer to the user's question is not explicitly in the context:
+            #                 - Use external knowledge or web assistance to provide a clear and accurate response.
+            #                 3. Do not respond negatively. If the answer is not in the context, use web assistance or your knowledge to generate a thoughtful response.
+            #                 4. Clearly state if part of your response relies on web assistance.
+
+            #                 Question: {prompt}
+
+            #                 Please provide a clear and comprehensive answer based on the above instructions.
+            #                 """
+
+            #                 response = model.generate_content(context_prompt)
+            #                 if not response or not response.text:
+            #                     st.error("No response received from the model")
+            #                     return
+
+            #                 assistant_response = response.text
+            #                 # Display Assistant Response
+            #                 with st.chat_message("assistant"):
+            #                     st.markdown(assistant_response)
+
+            #                 # Build the message
+            #                 new_message = {
+            #                     "prompt": prompt,
+            #                     "response": assistant_response,
+            #                     "timestamp": datetime.utcnow(),
+            #                 }
+            #                 st.session_state.messages.append(new_message)
+
+            #                 # Update database
+            #                 try:
+            #                     chat_history_collection.update_one(
+            #                         {
+            #                             "user_id": student_id,
+            #                             "session_id": session["session_id"],
+            #                         },
+            #                         {
+            #                             "$push": {"messages": new_message},
+            #                             "$setOnInsert": {
+            #                                 "user_id": student_id,
+            #                                 "session_id": session["session_id"],
+            #                                 "timestamp": datetime.utcnow(),
+            #                             },
+            #                         },
+            #                         upsert=True,
+            #                     )
+            #                     chat_time_collection.update_one(
+            #                         {"session_id": session["session_id"], "user_id": student_id, "course_id": course_id},
+            #                         {"$set": {"end_time": datetime.now()}},
+            #                         upsert=True
+            #                     )
+            #                 except Exception as db_error:
+            #                     st.error(f"Error saving chat history: {str(db_error)}")
+            #             except Exception as e:
+            #                 st.error(f"Error generating response: {str(e)}")
+            #     else:
+            #         st.warning("Chat session has expired. The 20-minute time limit has been reached.")
+            #         st.session_state.chat_session_active = False
+            #         st.session_state.chat_session_start = None
 
     else:
         st.subheader("Upload Pre-class Material")
@@ -498,6 +626,10 @@ def display_preclass_content(session, student_id, course_id):
             st.session_state.messages = []
     
     if st.session_state.user_type == 'student':
+        
+        display_pre_class_quiz_tab(student_id, course_id, session["session_id"])
+        display_pre_subjective_test_tab(student_id, course_id, session["session_id"]) 
+
         st.subheader("Create a Practice Quiz")
         questions = []
         quiz_id = ""
@@ -640,12 +772,19 @@ def display_preclass_content(session, student_id, course_id):
                                 # except Exception as db_error:
                                 #     st.error(f"Error saving submission: {str(db_error)}")
 
-    if st.session_state.user_type == "student":
-        # display_pre_subjective_test_tab(session, course_id, session_id)
-        display_pre_subjective_test_tab(
-                    student_id, course_id, session["session_id"]
-                )  # Added this line
-        pass
+    # if st.session_state.user_type == "student":
+    #     # display_pre_subjective_test_tab(session, course_id, session_id)
+    #     display_pre_subjective_test_tab(student_id, course_id, session["session_id"])  # Added this line
+    #     pass
+
+def get_chat_context(session_id):
+    """Get context from session materials"""
+    materials = resources_collection.find({"session_id": session_id})
+    context = ""
+    for material in materials:
+        if 'text_content' in material:
+            context += f"{material['text_content']}\n"
+    return context
 
 import requests
 
@@ -849,7 +988,7 @@ def upload_preclass_materials(session_id, course_id, student_id):
     st.subheader("Pre-class Materials Management")
     
     # Create tabs for different functionalities
-    upload_tab, videos_tab, web_resources ,external_tab, pre_class_evaluate = st.tabs(["Upload Materials","Upload Video Sources","Web Resources", "Resources by Perplexity", "Pre-class Evaluation"])
+    upload_tab, videos_tab, web_resources ,external_tab, pre_class_tab, pre_class_evaluate, pre_class_quiz = st.tabs(["Upload Materials","Upload Video Sources","Web Resources", "Resources by Perplexity", "Pre-class Questions", "Pre-class Evaluation", "Pre-class Quiz"])
     
     with upload_tab:
         # Original file upload functionality
@@ -863,6 +1002,23 @@ def upload_preclass_materials(session_id, course_id, student_id):
                     if st.button("Upload Material"):
                         upload_resource(course_id, session_id, file_name, uploaded_file, material_type)
                         st.success("Material uploaded successfully!")
+        
+        # Display pre-class materials
+        # Group resources by their types
+        grouped_resources = defaultdict(list)
+        materials = resources_collection.find({"session_id": session_id})
+        for material in materials:
+            grouped_resources[material['material_type']].append(material)
+
+        # Display grouped resources
+        for material_type, resources in grouped_resources.items():
+            st.markdown(f"##### {material_type.capitalize()} Resources")
+            for material in resources:
+                resource_info = f"- **{material['file_name']}** ({material['file_type']})"
+                if 'source_url' in material:
+                    resource_info += f" - [URL]({material['source_url']})"
+                st.markdown(resource_info)
+    
     with videos_tab:
         # Upload video sources
         st.info("Upload video sources for this session.")
@@ -878,7 +1034,7 @@ def upload_preclass_materials(session_id, course_id, student_id):
         st.info("""
         Share online resources with your students. Supported links include:
         - Google Colab notebooks
-        - Google Slides presentations
+        - Google Slides   presentations
         - Online documentation
         - Educational websites
         - Any web-based learning resource
@@ -999,25 +1155,274 @@ def upload_preclass_materials(session_id, course_id, student_id):
                     - URL: [{resource['url']}]({resource['url']})
                     """)
 
+    with pre_class_tab:
+        if st.session_state.user_type == "faculty":
+            faculty_id = st.session_state.user_id
+            st.subheader("Create Pre class Subjective Test")
+
+            # Create a form for test generation
+            with st.form("pre_create_subjective_test_form"):
+                test_title = st.text_input("Test Title")
+                num_subjective_questions = st.number_input(
+                    "Number of Pre class Subjective Questions", min_value=1, value=5
+                )
+                generation_method = st.radio(
+                    "Question Generation Method", ["Generate from Pre-class Materials"]
+                )
+                generate_test_btn = st.form_submit_button("Generate Test for Pre Class")
+
+            # Handle test generation outside the form
+            if generate_test_btn:
+                if not test_title:
+                    st.error("Please enter a test title.")
+                    return
+
+                context = ""
+                if generation_method == "Generate from Pre-class Materials":
+                    materials = resources_collection.find(
+                        {"session_id": session["session_id"]}
+                    )
+                    for material in materials:
+                        if "text_content" in material:
+                            context += material["text_content"] + "\n"
+
+                with st.spinner("Generating questions and synoptic..."):
+                    try:
+                        # Store generated content in session state to persist between rerenders
+                        questions = pre_generate_questions(
+                            context if context else None,
+                            num_subjective_questions,
+                            session["title"],
+                            session.get("description", ""),
+                        )
+
+                        if questions:
+                            synoptic = generate_synoptic(
+                                questions,
+                                context if context else None,
+                                session["title"],
+                                num_subjective_questions,
+                            )
+
+                            if synoptic:
+                                # Store in session state
+                                st.session_state.generated_questions = questions
+                                st.session_state.generated_synoptic = synoptic
+                                st.session_state.test_title = test_title
+
+                                # Display preview
+                                st.subheader(
+                                    "Preview Subjective Questions and Synoptic"
+                                )
+                                for i, (q, s) in enumerate(zip(questions, synoptic), 1):
+                                    st.markdown(f"**Question {i}:** {q['question']}")
+                                    with st.expander(f"View Synoptic {i}"):
+                                        st.markdown(s)
+
+                                # Save button outside the form
+                                if st.button("Pre Save Test"):
+                                    test_id = pre_save_subjective_test(
+                                        course_id,
+                                        session["session_id"],
+                                        test_title,
+                                        questions,
+                                    )
+                                    if test_id:
+                                        st.success(
+                                            "Subjective test saved successfully!"
+                                        )
+                                    else:
+                                        st.error("Error saving subjective test.")
+                            else:
+                                st.error(
+                                    "Error generating synoptic answers. Please try again."
+                                )
+                        else:
+                            st.error("Error generating questions. Please try again.")
+                    except Exception as e:
+                        st.error(f"An error occurred: {str(e)}")
+
+            # Display previously generated test if it exists in session state
+            elif hasattr(st.session_state, "generated_questions") and hasattr(
+                st.session_state, "generated_synoptic"
+            ):
+                st.subheader("Preview Subjective Questions and Synoptic")
+                for i, (q, s) in enumerate(
+                    zip(
+                        st.session_state.generated_questions,
+                        st.session_state.generated_synoptic,
+                    ),
+                    1,
+                ):
+                    st.markdown(f"**Question {i}:** {q['question']}")
+                    with st.expander(f"View Synoptic {i}"):
+                        st.markdown(s)
+
+                if st.button("Pre Save Test"):
+                    test_id = pre_save_subjective_test(
+                        course_id,
+                        session["session_id"],
+                        st.session_state.test_title,
+                        st.session_state.generated_questions,
+                    )
+                    if test_id:
+                        st.success("Subjective test saved successfully!")
+                        # Clear session state after successful save
+                        del st.session_state.generated_questions
+                        del st.session_state.generated_synoptic
+                        del st.session_state.test_title
+                    else:
+                        st.error("Error saving subjective test.")
+
+
     with pre_class_evaluate:
         from subjective_test_evaluation import pre_display_evaluation_to_faculty
         pre_display_evaluation_to_faculty(session["session_id"], student_id, course_id)
+    
+    with pre_class_quiz:
+        if st.session_state.user_type == "faculty":
+            st.subheader("Create Pre-class Quiz")
+            with st.form("create_pre_class_quiz_form"):
+                quiz_title = st.text_input("Quiz Title")
+                num_questions = st.number_input(
+                    "Number of Questions", 
+                    min_value=1, 
+                    max_value=20, 
+                    value=5
+                )
+                duration = st.number_input(
+                    "Quiz Duration (minutes)", 
+                    min_value=5,
+                    max_value=60,
+                    value=15
+                )
 
-    # Display pre-class materials
-    # Group resources by their types
-    grouped_resources = defaultdict(list)
-    materials = resources_collection.find({"session_id": session_id})
-    for material in materials:
-        grouped_resources[material['material_type']].append(material)
+                # Generate quiz button
+                if st.form_submit_button("Generate Pre-class Quiz"):
+                    if not quiz_title:
+                        st.error("Please enter a quiz title")
+                        return
+
+                    # Get pre-class materials
+                    materials = resources_collection.find({"session_id": session_id})
+                    context = ""
+                    for material in materials:
+                        if 'text_content' in material:
+                            context += material['text_content'] + "\n"
+
+                    if not context:
+                        st.error("No pre-class materials found")
+                        return
+
+                    # Generate questions
+                    questions = generate_mcqs(
+                        context=context,
+                        num_questions=num_questions,
+                        session_title=session['title'],
+                        session_description=session.get('description', '')
+                    )
+
+                    if questions:
+                        # Preview questions
+                        st.subheader("Preview Questions")
+                        for i, q in enumerate(questions, 1):
+                            st.markdown(f"**Q{i}:** {q['question']}")
+                            for opt in q['options']:
+                                st.markdown(f"- {opt}")
+                            st.markdown(f"*Correct: {q['correct_option']}*")
+
+                        # Save quiz
+                        quiz_id = save_pre_class_quiz(
+                            course_id=course_id,
+                            session_id=session_id,
+                            title=quiz_title,
+                            questions=questions,
+                            user_id=st.session_state.user_id,
+                            duration=duration
+                        )
+
+                        if quiz_id:
+                            st.success("Pre-class quiz created successfully!")
+                        else:
+                            st.error("Error saving quiz")
+
+
+def display_pre_class_quiz_tab(student_id, course_id, session_id):
+    """Display pre-class quizzes for students"""
+    st.markdown("### Pre-class Quizzes")
+
+    # Get available quizzes
+    quizzes = quizzes_collection.find({
+        "course_id": course_id,
+        "session_id": session_id,
+        "status": "active"
+    })
+
+    quizzes = list(quizzes)
+    if not quizzes:
+        st.info("No pre-class quizzes available.")
+        return
+
+    for quiz in quizzes:
+        with st.expander(f"📝 {quiz['title']}", expanded=True):
+            # Check if already taken
+            existing_score = get_student_quiz_score(quiz["_id"], student_id)
+
+            if existing_score is not None:
+                st.success(f"Quiz completed! Score: {existing_score:.1f}%")
+                
+                # Show review
+                st.subheader("Quiz Review")
+                for i, question in enumerate(quiz["questions"]):
+                    st.markdown(f"**Q{i+1}:** {question['question']}")
+                    for opt in question["options"]:
+                        if opt.startswith(question["correct_option"]):
+                            st.markdown(f"✅ {opt}")
+                        else:
+                            st.markdown(f"- {opt}")
+
+            else:
+                # Check time remaining
+                start_time = quiz.get('start_time')
+                if not start_time:
+                    if st.button("Start Quiz", key=f"start_{quiz['_id']}"):
+                        quizzes_collection.update_one(
+                            {"_id": quiz["_id"]},
+                            {"$set": {"start_time": datetime.now()}}
+                        )
+                        st.rerun()
+                else:
+                    time_remaining = (start_time + timedelta(minutes=quiz['duration_minutes'])) - datetime.now()
+                    
+                    if time_remaining.total_seconds() > 0:
+                        st.info(f"Time remaining: {int(time_remaining.total_seconds() // 60)}:{int(time_remaining.total_seconds() % 60):02d}")
+                        
+                        # Display quiz form
+                        with st.form(f"pre_class_quiz_{quiz['_id']}"):
+                            student_answers = {}
+                            for i, question in enumerate(quiz["questions"]):
+                                st.markdown(f"**Q{i+1}:** {question['question']}")
+                                options = [opt for opt in question["options"]]
+                                student_answers[str(i)] = st.radio(
+                                    f"Select answer:",
+                                    options=options,
+                                    key=f"q_{quiz['_id']}_{i}"
+                                )
+
+                            if st.form_submit_button("Submit Quiz"):
+                                score = submit_quiz_answers(
+                                    quiz["_id"], 
+                                    student_id, 
+                                    student_answers
+                                )
+                                if score is not None:
+                                    st.success(f"Quiz submitted! Score: {score:.1f}%")
+                                    st.rerun()
+                                else:
+                                    st.error("Error submitting quiz")
+                    else:
+                        st.error("Quiz time expired")
 
-    # Display grouped resources
-    for material_type, resources in grouped_resources.items():
-        st.markdown(f"##### {material_type.capitalize()} Resources")
-        for material in resources:
-            resource_info = f"- **{material['file_name']}** ({material['file_type']})"
-            if 'source_url' in material:
-                resource_info += f" - [URL]({material['source_url']})"
-            st.markdown(resource_info)
 
 def extract_external_content(url, content_type):
     """Extract content from external resources based on their type"""
@@ -1292,7 +1697,7 @@ def display_in_class_content(session, user_type, course_id, user_id):
     if user_type == "faculty":
         faculty_id = st.session_state.user_id
 
-        st.subheader("Create Surprise Quiz")
+        st.markdown("#### Create Surprise Quiz")
 
         questions = []
         with st.form("create_surprise_quiz_form"):
@@ -1307,7 +1712,7 @@ def display_in_class_content(session, user_type, course_id, user_id):
             # Option to choose quiz generation method
             generation_method = st.radio(
                 "Question Generation Method",
-                ["Generate from Pre-class Materials", "Generate Random Questions"],
+                ["Generate from Pre-class Materials"],
             )
 
             submit_quiz = st.form_submit_button("Generate Surprise Quiz")
@@ -2477,6 +2882,12 @@ def display_preclass_analytics2(session, course_id):
 
         # Display student metrics in a grid
         st.markdown('<div class="analytics-grid">', unsafe_allow_html=True)
+
+        student_ids = [student["student_id"] for student in analytics["student_analytics"]]
+        student_names = {str(student["_id"]): student["full_name"] for student in students_collection.find({"_id": {"$in": [ObjectId(sid) for sid in student_ids]}})}
+
+            # Display student metrics in a grid
+        st.markdown('<div class="analytics-grid">', unsafe_allow_html=True)
         for student in analytics["student_analytics"]:
             # Apply filters
             if (concept_understanding != "All" and 
@@ -2495,10 +2906,12 @@ def display_preclass_analytics2(session, course_id):
             if struggling_topic != "All" and struggling_topic not in student["struggling_topics"]:
                 continue
 
+            student_name = student_names.get(student["student_id"], "Unknown Student")
+
             st.markdown(f"""
                 <div class="student-metrics-card">
                     <div class="header">
-                        <span class="student-id">Student {student["student_id"][-6:]}</span>
+                        <span class="student-id">Student: {student_name}</span>
                     </div>
                     <div class="metrics-grid">
                         <div class="metric-box">
@@ -3270,7 +3683,7 @@ def display_subjective_test_tab(student_id, course_id, session_id):
 
 def display_pre_subjective_test_tab(student_id, course_id, session_id):
     """Display subjective tests and results for students"""
-    st.header("Pre Subjective Tests")
+    st.markdown("### Pre-class Subjective Questions ")
 
     try:
         print("course_id", course_id, "session_id", session_id, "student_id", student_id)
@@ -3283,7 +3696,7 @@ def display_pre_subjective_test_tab(student_id, course_id, session_id):
 
         if not subjective_tests:
             print("bruh")
-            st.info("No pre subjective tests available for this session.")
+            st.info("No pre subjective questions available for this session.")
             return
 
         # Create tabs for Tests and Results