Update session_page.py

session_page.py

@@ -18,9 +18,10 @@ import os
 from pymongo import MongoClient
 from gen_mcqs import generate_mcqs, save_quiz, quizzes_collection, get_student_quiz_score, submit_quiz_answers
 from create_course import courses_collection
-import traceback
+# from pre_class_analytics import NovaScholarAnalytics
 from pre_class_analytics2 import NovaScholarAnalytics
 import openai
+from openai import OpenAI
 import google.generativeai as genai
 from goals2 import GoalAnalyzer
 from openai import OpenAI
@@ -29,8 +30,6 @@ import numpy as np
 import re
 from analytics import derive_analytics, create_embeddings, cosine_similarity
 from bs4 import BeautifulSoup
-from rubrics import display_rubrics_tab
-from subjective_test_evaluation import evaluate_subjective_answers, display_evaluation_to_faculty
 
 load_dotenv()
 MONGO_URI = os.getenv('MONGO_URI')
@@ -41,7 +40,6 @@ db = client["novascholar_db"]
 polls_collection = db["polls"]
 subjective_tests_collection = db["subjective_tests"]
 synoptic_store_collection = db["synoptic_store"]
-subjective_test_analysis_collection = db['subjective_test_analysis']
 
 def get_current_user():
     if 'current_user' not in st.session_state:
@@ -134,6 +132,66 @@ def get_current_user():
     # user = get_current_user()
     
 def display_preclass_content(session, student_id, course_id):
+    # """Display pre-class materials for a session"""
+    # st.subheader("Pre-class Materials")
+    # print("Session ID is: ", session['session_id'])
+    # # Display pre-class materials
+    # materials = resources_collection.find({"session_id": session['session_id']})
+    # for material in materials:
+    #     with st.expander(f"{material['file_name']} ({material['material_type'].upper()})"):
+    #         file_type = material.get('file_type', 'unknown')
+    #         if file_type == 'application/pdf':
+    #             st.markdown(f"📑 [Open PDF Document]({material['file_name']})")
+    #             if st.button("View PDF", key=f"view_pdf_{material['_id']}"):
+    #                 st.text_area("PDF Content", material['text_content'], height=300)
+    #             if st.button("Download PDF", key=f"download_pdf_{material['_id']}"):
+    #                 st.download_button(
+    #                     label="Download PDF",
+    #                     data=material['file_content'],
+    #                     file_name=material['file_name'],
+    #                     mime='application/pdf'
+    #                 )
+    #             if st.button("Mark PDF as Read", key=f"pdf_{material['_id']}"):
+    #                 create_notification("PDF marked as read!", "success")
+    #         elif file_type == 'text/plain':
+    #             st.markdown(f"📄 [Open Text Document]({material['file_name']})")
+    #             if st.button("View Text", key=f"view_text_{material['_id']}"):
+    #                 st.text_area("Text Content", material['text_content'], height=300)
+    #             if st.button("Download Text", key=f"download_text_{material['_id']}"):
+    #                 st.download_button(
+    #                     label="Download Text",
+    #                     data=material['file_content'],
+    #                     file_name=material['file_name'],
+    #                     mime='text/plain'
+    #                 )
+    #             if st.button("Mark Text as Read", key=f"text_{material['_id']}"):
+    #                 create_notification("Text marked as read!", "success")
+    #         elif file_type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+    #             st.markdown(f"📄 [Open Word Document]({material['file_name']})")
+    #             if st.button("View Word", key=f"view_word_{material['_id']}"):
+    #                 st.text_area("Word Content", material['text_content'], height=300)
+    #             if st.button("Download Word", key=f"download_word_{material['_id']}"):
+    #                 st.download_button(
+    #                     label="Download Word",
+    #                     data=material['file_content'],
+    #                     file_name=material['file_name'],
+    #                     mime='application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+    #                 )
+    #             if st.button("Mark Word as Read", key=f"word_{material['_id']}"):
+    #                 create_notification("Word document marked as read!", "success")
+    #         elif file_type == 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
+    #             st.markdown(f"📊 [Open PowerPoint Presentation]({material['file_name']})")
+    #             if st.button("View PowerPoint", key=f"view_pptx_{material['_id']}"):
+    #                 st.text_area("PowerPoint Content", material['text_content'], height=300)
+    #             if st.button("Download PowerPoint", key=f"download_pptx_{material['_id']}"):
+    #                 st.download_button(
+    #                     label="Download PowerPoint",
+    #                     data=material['file_content'],
+    #                     file_name=material['file_name'],
+    #                     mime='application/vnd.openxmlformats-officedocument.presentationml.presentation'
+    #                 )
+    #             if st.button("Mark PowerPoint as Read", key=f"pptx_{material['_id']}"):
+    #                 create_notification("PowerPoint presentation marked as read!", "success")
     """Display pre-class materials for a session including external resources"""
     st.subheader("Pre-class Materials")
     print("Session ID is: ", session['session_id'])
@@ -614,29 +672,41 @@ def display_post_class_content(session, student_id, course_id):
                     )
                     
                     if questions:
-                        # Store in session state
-                        st.session_state.generated_questions = questions
-                        st.session_state.test_title = test_title
+                        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 in enumerate(questions, 1):
-                            st.markdown(f"**Question {i}:** {q['question']}")
-                            # with st.expander(f"View Synoptic {i}"):
-                            #     st.markdown(s)
+                            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("Save Test"):
-                            test_id = 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.")
+                            # Save button outside the form
+                            if st.button("Save Test"):
+                                test_id = save_subjective_test(
+                                    course_id,
+                                    session['session_id'],
+                                    test_title,
+                                    questions,
+                                    synoptic
+                                )
+                                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:
@@ -644,9 +714,11 @@ def display_post_class_content(session, student_id, course_id):
 
         # 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")
-            for i, q in enumerate(st.session_state.generated_questions, 1):
-                st.markdown(f"**Questison {i}:** {q['question']}")
+            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("Save Test"):
                 test_id = save_subjective_test(
@@ -654,11 +726,13 @@ def display_post_class_content(session, student_id, course_id):
                     session['session_id'],
                     st.session_state.test_title,
                     st.session_state.generated_questions,
+                    st.session_state.generated_synoptic
                 )
                 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.")
@@ -795,7 +869,186 @@ def display_post_class_content(session, student_id, course_id):
                         st.markdown("### Feedback")
                         st.info("Feedback will be provided here once the assignment is graded.")
         else:
-            st.warning("No assignments found for this session.")                            
+            st.warning("No assignments found for this session.")            
+                
+# def display_preclass_analytics(session, course_id):
+#     """Display pre-class analytics for faculty based on chat interaction metrics"""
+#     st.subheader("Pre-class Analytics")
+    
+#     # Get all enrolled students
+#     # enrolled_students = list(students_collection.find({"enrolled_courses": session['course_id']}))
+#     enrolled_students = list(students_collection.find({
+#         "enrolled_courses.course_id": course_id
+#     }))
+#     # total_students = len(enrolled_students)
+    
+#     total_students = students_collection.count_documents({
+#         "enrolled_courses": {
+#             "$elemMatch": {"course_id": course_id}
+#         }
+#     })
+
+
+#     if total_students == 0:
+#         st.warning("No students enrolled in this course.")
+#         return
+    
+#     # Get chat history for all students in this session
+#     chat_data = list(chat_history_collection.find({
+#         "session_id": session['session_id']
+#     }))
+    
+#     # Create a DataFrame to store student completion data
+#     completion_data = []
+#     incomplete_students = []
+    
+#     for student in enrolled_students:
+#         student_id = student['_id']
+#         student_name = student.get('full_name', 'Unknown')
+#         student_sid = student.get('SID', 'Unknown')
+        
+#         # Find student's chat history
+#         student_chat = next((chat for chat in chat_data if chat['user_id'] == student_id), None)
+        
+#         if student_chat:
+#             messages = student_chat.get('messages', [])
+#             message_count = len(messages)
+#             status = "Completed" if message_count >= 20 else "Incomplete"
+
+#             # Format chat history for display
+#             chat_history = []
+#             for msg in messages:
+#                 timestamp_str = msg.get('timestamp', '')
+#                 if isinstance(timestamp_str, str):
+#                     timestamp = datetime.fromisoformat(timestamp_str)
+#                 else:
+#                     timestamp = timestamp_str
+#                 # timestamp = msg.get('timestamp', '').strftime("%Y-%m-%d %H:%M:%S")
+#                 chat_history.append({
+#                     # 'timestamp': timestamp,
+#                     'timestamp': timestamp.strftime("%Y-%m-%d %H:%M:%S"),
+#                     'prompt': msg.get('prompt'),
+#                     'response': msg.get('response')
+#                 })
+            
+#             message_count = len(student_chat.get('messages', []))
+#             status = "Completed" if message_count >= 20 else "Incomplete"
+#             if status == "Incomplete":
+#                 incomplete_students.append({
+#                     'name': student_name,
+#                     'sid': student_sid,
+#                     'message_count': message_count
+#                 })
+#         else:
+#             message_count = 0
+#             status = "Not Started"
+#             chat_history = []
+#             incomplete_students.append({
+#                 'name': student_name,
+#                 'sid': student_sid,
+#                 'message_count': 0
+#             })
+            
+#         completion_data.append({
+#             'Student Name': student_name,
+#             'SID': student_sid,
+#             'Messages': message_count,
+#             'Status': status,
+#             'Chat History': chat_history
+#         })
+    
+#     # Create DataFrame
+#     df = pd.DataFrame(completion_data)
+    
+#     # Display summary metrics
+#     col1, col2, col3 = st.columns(3)
+    
+#     completed_count = len(df[df['Status'] == 'Completed'])
+#     incomplete_count = len(df[df['Status'] == 'Incomplete'])
+#     not_started_count = len(df[df['Status'] == 'Not Started'])
+    
+#     with col1:
+#         st.metric("Completed", completed_count)
+#     with col2:
+#         st.metric("Incomplete", incomplete_count)
+#     with col3:
+#         st.metric("Not Started", not_started_count)
+    
+#     # Display completion rate progress bar
+#     completion_rate = (completed_count / total_students) * 100
+#     st.markdown("### Overall Completion Rate")
+#     st.progress(completion_rate / 100)
+#     st.markdown(f"**{completion_rate:.1f}%** of students have completed pre-class materials")
+
+#     # Create tabs for different views
+#     tab1, tab2 = st.tabs(["Student Overview", "Detailed Chat History"])
+    
+#     with tab1:
+#         # Display completion summary table
+#         st.markdown("### Student Completion Details")
+#         summary_df = df[['Student Name', 'SID', 'Messages', 'Status']].copy()
+#         st.dataframe(
+#             summary_df.style.apply(lambda x: ['background-color: #90EE90' if v == 'Completed' 
+#                                             else 'background-color: #FFB6C1' if v == 'Incomplete'
+#                                             else 'background-color: #FFE4B5' 
+#                                             for v in x],
+#                                  subset=['Status'])
+#         )
+        
+#     with tab2:
+#         # Display detailed chat history
+#         st.markdown("### Student Chat Histories")
+        
+#         # Add student selector
+#         selected_student = st.selectbox(
+#             "Select a student to view chat history:",
+#             options=df['Student Name'].tolist()
+#         )
+        
+#         # Get selected student's data
+#         student_data = df[df['Student Name'] == selected_student].iloc[0]
+#         print(student_data)
+#         chat_history = student_data['Chat History']
+#         # Refresh chat history when a new student is selected
+#         if 'selected_student' not in st.session_state or st.session_state.selected_student != selected_student:
+#             st.session_state.selected_student = selected_student
+#             st.session_state.selected_student_chat_history = chat_history
+#         else:
+#             chat_history = st.session_state.selected_student_chat_history
+#         # Display student info and chat statistics
+#         st.markdown(f"**Student ID:** {student_data['SID']}")
+#         st.markdown(f"**Status:** {student_data['Status']}")
+#         st.markdown(f"**Total Messages:** {student_data['Messages']}")
+        
+#         # Display chat history in a table
+#         if chat_history:
+#             chat_df = pd.DataFrame(chat_history)
+#             st.dataframe(
+#                 chat_df.style.apply(lambda x: ['background-color: #E8F0FE' if v == 'response' else 'background-color: #FFFFFF' for v in x], subset=['prompt']), use_container_width=True
+#             )
+#         else:
+#             st.info("No chat history available for this student.")
+    
+#     # Display students who haven't completed
+#     if incomplete_students:
+#         st.markdown("### Students Requiring Follow-up")
+#         incomplete_df = pd.DataFrame(incomplete_students)
+#         st.markdown(f"**{len(incomplete_students)} students** need to complete the pre-class materials:")
+        
+#         # Create a styled table for incomplete students
+#         st.table(
+#             incomplete_df.style.apply(lambda x: ['background-color: #FFFFFF' 
+#                                                for _ in range(len(x))]))
+        
+#         # Export option for incomplete students list
+#         csv = incomplete_df.to_csv(index=False).encode('utf-8')
+#         st.download_button(
+#             "Download Follow-up List",
+#             csv,
+#             "incomplete_students.csv",
+#             "text/csv",
+#             key='download-csv'
+#         )
 
 def display_inclass_analytics(session, course_id):
     """Display in-class analytics for faculty"""
@@ -911,6 +1164,9 @@ def display_inclass_analytics(session, course_id):
                 "_id": {"$nin": respondents}
             }))
             
+            
+
+
             if non_participants:
                 st.markdown("#### Students Who Haven't Participated")
                 non_participant_data = [{
@@ -949,23 +1205,24 @@ def display_inclass_analytics(session, course_id):
 def display_postclass_analytics(session, course_id):
     """Display post-class analytics for faculty"""
     st.subheader("Post-class Analytics")
-
+    
     # Get all assignments for this session
     session_data = courses_collection2.find_one(
         {"sessions.session_id": session['session_id']},
         {"sessions.$": 1}
     )
-
+    
     if not session_data or 'sessions' not in session_data:
         st.warning("No assignments found for this session.")
         return
-
+    
     assignments = session_data['sessions'][0].get('post_class', {}).get('assignments', [])
-
+    
     for assignment in assignments:
         with st.expander(f"📝 Assignment: {assignment.get('title', 'Untitled')}"):
             # Get submission analytics
             submissions = assignment.get('submissions', [])
+            # total_students = students_collection.count_documents({"courses": session['course_id']})
             total_students = students_collection.count_documents({
                 "enrolled_courses": {
                     "$elemMatch": {"course_id": course_id}
@@ -974,7 +1231,7 @@ def display_postclass_analytics(session, course_id):
             # Calculate submission metrics
             submitted_count = len(submissions)
             submission_rate = (submitted_count / total_students) * 100 if total_students > 0 else 0
-
+            
             # Display metrics
             col1, col2, col3 = st.columns(3)
             with col1:
@@ -983,25 +1240,43 @@ def display_postclass_analytics(session, course_id):
                 st.metric("Submission Rate", f"{submission_rate:.1f}%")
             with col3:
                 st.metric("Pending Submissions", total_students - submitted_count)
-
+            
             # Display submission timeline
             if submissions:
                 submission_dates = [sub.get('submitted_at') for sub in submissions if 'submitted_at' in sub]
                 if submission_dates:
                     df = pd.DataFrame(submission_dates, columns=['Submission Date'])
-                    fig = px.histogram(df, x='Submission Date',
-                                       title='Submission Timeline',
-                                       labels={'Submission Date': 'Date', 'count': 'Number of Submissions'})
+                    fig = px.histogram(df, x='Submission Date', 
+                                     title='Submission Timeline',
+                                     labels={'Submission Date': 'Date', 'count': 'Number of Submissions'})
                     st.plotly_chart(fig)
+            
+            # Display submission status breakdown
+            status_counts = {
+                'pending': total_students - submitted_count,
+                'submitted': submitted_count,
+                'late': len([sub for sub in submissions if sub.get('is_late', False)])
+            }
+            
+            st.markdown("### Submission Status Breakdown")
+            status_df = pd.DataFrame(list(status_counts.items()), 
+                                   columns=['Status', 'Count'])
+            st.bar_chart(status_df.set_index('Status'))
+            
+            # List of students who haven't submitted
+            if status_counts['pending'] > 0:
+                st.markdown("### Students with Pending Submissions")
+                # submitted_ids = [sub.get('student_id') for sub in submissions]
+                submitted_ids = [ObjectId(sub.get('student_id')) for sub in submissions]
+                print(submitted_ids)
+                pending_students = students_collection.find({
+                    "enrolled_courses.course_id": course_id,
+                    "_id": {"$nin": submitted_ids}
+                })
+                print(pending_students)
+                for student in pending_students:
+                    st.markdown(f"- {student.get('full_name', 'Unknown Student')} (SID: {student.get('SID', 'Unknown SID')})")
 
-            # Display subjective test analysis
-            st.subheader("Subjective Test Analysis")
-            for submission in submissions:
-                if 'analysis' in submission:
-                    st.markdown(f"**Student ID:** {submission['student_id']}")
-                    st.markdown(submission['analysis']['content_analysis'])
-                    st.markdown("---")
-    
 def get_chat_history(user_id, session_id):
     query = {
         "user_id": ObjectId(user_id),
@@ -1658,6 +1933,34 @@ def display_session_analytics(session, course_id):
 
     # Display Post-class Analytics
     display_postclass_analytics(session, course_id)
+    
+# def upload_preclass_materials(session_id, course_id):
+#     """Upload pre-class materials for a session"""
+#     st.subheader("Upload Pre-class Materials")
+    
+#     # File upload section
+#     uploaded_file = st.file_uploader("Upload Material", type=['txt', 'pdf', 'docx'])
+#     if uploaded_file is not None:
+#         with st.spinner("Processing document..."):
+#             file_name = uploaded_file.name
+#             file_content = extract_text_from_file(uploaded_file)
+#             if file_content:
+#                 material_type = st.selectbox("Select Material Type", ["pdf", "docx", "txt"])
+#                 if st.button("Upload Material"):
+#                     upload_resource(course_id, session_id, file_name, uploaded_file, material_type)
+
+#                     # Search for the newly uploaded resource's _id in resources_collection
+#                     resource_id = resources_collection.find_one({"file_name": file_name})["_id"]
+#                     create_vector_store(file_content, resource_id)
+#                     st.success("Material uploaded successfully!")
+                    
+#     # Display existing materials
+#     materials = resources_collection.find({"course_id": course_id, "session_id": session_id})
+#     for material in materials:
+#         st.markdown(f"""
+#         * **{material['file_name']}** ({material['material_type']})  
+#             Uploaded on: {material['uploaded_at'].strftime('%Y-%m-%d %H:%M')}
+#         """)
 
 def upload_preclass_materials(session_id, course_id):
     """Upload pre-class materials and manage external resources for a session"""
@@ -1888,11 +2191,75 @@ def display_quiz_tab(student_id, course_id, session_id):
                         else:
                             st.error("Error submitting quiz. Please try again.")
 
+def display_subjective_test_tab(student_id, course_id, session_id):
+    """Display subjective tests for students"""
+    st.header("Subjective Tests")
+    
+    try:
+        subjective_tests = list(subjective_tests_collection.find({
+            "course_id": course_id,
+            "session_id": session_id,
+            "status": "active"
+        }))
+
+        if not subjective_tests:
+            st.info("No subjective tests available for this session.")
+            return
+
+        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"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 Test"):
+                            if all(answer.strip() for answer in student_answers):
+                                success = submit_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.")
+                                
+    except Exception as e:
+        st.error(f"An error occurred while loading the tests. Please try again later.")
+        print(f"Error in display_subjective_test_tab: {str(e)}", flush=True)
+
 def display_session_content(student_id, course_id, session, username, user_type):
     st.title(f"{session['title']}")
 
     # Check if the date is a string or a datetime object
     if isinstance(session['date'], str):
+        # Convert date string to datetime object
         session_date = datetime.fromisoformat(session['date'])
     else:
         session_date = session['date']
@@ -1902,7 +2269,10 @@ def display_session_content(student_id, course_id, session, username, user_type)
     st.markdown(f"**Date:** {format_datetime(session_date)}")
     st.markdown(f"**Course Name:** {course_name}")
 
+    # Find the course_id of the session in 
+
     if user_type == 'student':
+        # Create all tabs at once for students
         tabs = st.tabs([
             "Pre-class Work",
             "In-class Work", 
@@ -1922,14 +2292,18 @@ def display_session_content(student_id, course_id, session, username, user_type)
             with tabs[3]:
                 display_quiz_tab(student_id, course_id, session['session_id'])
             with tabs[4]:
-                display_subjective_test_tab(student_id, course_id, session['session_id'])  # Added this line
+                display_subjective_test_tab(student_id, course_id, session['session_id'])
             with tabs[5]:
-                #display_group_work_tab(session, student_id)
-                st.info("End term content will be available soon.")
+                st.subheader("Group Work")
+                st.info("Group work content will be available soon.")
             with tabs[6]:
                 st.subheader("End Terms")
                 st.info("End term content will be available soon.")
+        else:
+            st.error("Error creating tabs. Please try again.")
+    
     else:  # faculty user
+        # Create all tabs at once for faculty
         tabs = st.tabs([
             "Pre-class Work",
             "In-class Work",
@@ -1937,9 +2311,7 @@ def display_session_content(student_id, course_id, session, username, user_type)
             "Pre-class Analytics",
             "In-class Analytics",
             "Post-class Analytics",
-            "Rubrics",
-            "End Terms",
-            "Evaluate Subjective Tests"  # New tab for evaluation
+            "End Terms"
         ])
         with tabs[0]:
             upload_preclass_materials(session['session_id'], course_id)
@@ -1954,13 +2326,9 @@ def display_session_content(student_id, course_id, session, username, user_type)
         with tabs[5]:
             display_postclass_analytics(session, course_id)
         with tabs[6]:
-            display_rubrics_tab(session, course_id)
-        with tabs[7]:
             st.subheader("End Terms")
             st.info("End term content will be available soon.")
-        with tabs[8]:  # New tab for evaluation
-            display_evaluation_to_faculty(session['session_id'], student_id, course_id)
-            
+
 def parse_model_response(response_text):
     """Enhanced parser for model responses with better error handling.
     
@@ -2058,21 +2426,124 @@ def generate_questions(context, num_questions, session_title, session_descriptio
         print(f"Error generating questions: {str(e)}")
         return None
 
-def save_subjective_test(course_id, session_id, title, questions):
-    """Save subjective test to database with proper ID handling"""
+def generate_synoptic(questions, context, session_title, num_questions):
+    """Generate synoptic answers for the questions with improved error handling and response validation.
+    
+    Args:
+        questions (list): List of question dictionaries
+        context (str): Additional context for answer generation
+        session_title (str): Title of the session
+        num_questions (int): Expected number of questions
+        
+    Returns:
+        list: List of synoptic answers or None if generation fails
+    """
     try:
-        # Ensure proper string format for IDs
-        # course_id = course_id
-        # session_id = session_id
+        # First, let's validate our input
+        if not questions or not isinstance(questions, list):
+            raise ValueError("Questions must be provided as a non-empty list")
+            
+        # Format questions for better prompt clarity
+        formatted_questions = "\n".join(
+            f"{i+1}. {q['question']}" 
+            for i, q in enumerate(questions)
+        )
         
-        # Format questions
+        # Construct a more structured prompt
+        prompt = f"""You are a subject matter expert creating detailed model answers for {num_questions} questions about {session_title}.
+
+        Here are the questions:
+        {formatted_questions}
+        {f'Additional context: {context}' if context else ''}
+
+        Please provide {num_questions} comprehensive answers following this JSON format:
+        {{
+            "answers": [
+                {{
+                    "answer": "Your detailed answer for question 1...",
+                    "key_points": ["Point 1", "Point 2", "Point 3"]
+                }},
+                {{
+                    "answer": "Your detailed answer for question 2...",
+                    "key_points": ["Point 1", "Point 2", "Point 3"]
+                }}
+            ]
+        }}
+
+        Requirements for each answer:
+        1. Minimum 150 words
+        2. Include specific examples and evidence
+        3. Reference key concepts and terminology
+        4. Demonstrate critical analysis
+        5. Structure with clear introduction, body, and conclusion
+
+        IMPORTANT: Return ONLY the JSON object with the answers array. No additional text.
+        """
+
+        # Generate response
+        response = model.generate_content(prompt)
+        
+        # Parse and validate the response
+        parsed_response = parse_model_response(response.text)
+        
+        # Additional validation of parsed response
+        if not isinstance(parsed_response, (dict, list)):
+            raise ValueError("Response must be a dictionary or list")
+            
+        # Handle both possible valid response formats
+        if isinstance(parsed_response, dict):
+            answers = parsed_response.get('answers', [])
+        else:  # If it's a list
+            answers = parsed_response
+        
+        # Validate answer count
+        if len(answers) != num_questions:
+            raise ValueError(f"Expected {num_questions} answers, got {len(answers)}")
+        
+        # Extract just the answer texts for consistency with existing code
+        final_answers = []
+        for ans in answers:
+            if isinstance(ans, dict):
+                answer_text = ans.get('answer', '')
+                key_points = ans.get('key_points', [])
+                formatted_answer = f"{answer_text}\n\nKey Points:\n" + "\n".join(f"• {point}" for point in key_points)
+                final_answers.append(formatted_answer)
+            else:
+                final_answers.append(str(ans))
+        
+        # Final validation of the answers
+        for i, answer in enumerate(final_answers):
+            if not answer or len(answer.split()) < 50:  # Basic length check
+                raise ValueError(f"Answer {i+1} is too short or empty")
+        
+        # Save the synoptic to the synoptic_store collection
+        synoptic_data = {
+            "session_title": session_title,
+            "questions": questions,
+            "synoptic": final_answers,
+            "created_at": datetime.utcnow()
+        }
+        synoptic_store_collection.insert_one(synoptic_data)
+        
+        return final_answers
+
+    except Exception as e:
+        # Log the error for debugging
+        print(f"Error in generate_synoptic: {str(e)}")
+        print(f"Response text: {response.text if 'response' in locals() else 'No response generated'}")
+        return None
+
+def save_subjective_test(course_id, session_id, title, questions, synoptic):
+    """Save subjective test to database"""
+    try:
+        # Format questions to include metadata
         formatted_questions = []
         for q in questions:
             formatted_question = {
                 "question": q["question"],
-                "expected_points": [],
-                "difficulty_level": "medium",
-                "suggested_time": "5 minutes"
+                "expected_points": q.get("expected_points", []),
+                "difficulty_level": q.get("difficulty_level", "medium"),
+                "suggested_time": q.get("suggested_time", "5 minutes")
             }
             formatted_questions.append(formatted_question)
 
@@ -2081,6 +2552,7 @@ def save_subjective_test(course_id, session_id, title, questions):
             "session_id": session_id,
             "title": title,
             "questions": formatted_questions,
+            "synoptic": synoptic,
             "created_at": datetime.utcnow(),
             "status": "active",
             "submissions": []
@@ -2089,40 +2561,148 @@ def save_subjective_test(course_id, session_id, title, questions):
         result = subjective_tests_collection.insert_one(test_data)
         return result.inserted_id
     except Exception as e:
-        print(f"Error saving test: {e}")
+        print(f"Error saving subjective test: {e}")
         return None
 
-def submit_subjective_test(test_id, student_id, answers):
-    """Submit test answers with proper ID handling"""
+def submit_subjective_test(test_id, student_id, student_answers):
+    """Submit subjective test answers and trigger analysis"""
     try:
-        # Ensure IDs are strings
-        test_id = str(test_id)
-        student_id = str(student_id)
-        
-        # Create submission document
-        submission = {
+        submission_data = {
             "student_id": student_id,
-            "answers": answers,
-            "submitted_at": datetime.utcnow(),
-            "status": "submitted"
+            "answers": student_answers,
+            "submitted_at": datetime.utcnow()
         }
         
-        # Update test document with new submission
         result = subjective_tests_collection.update_one(
-            {"_id": ObjectId(test_id)},
-            {"$push": {"submissions": submission}}
+            {"_id": test_id},
+            {
+                "$push": {
+                    "submissions": submission_data
+                }
+            }
         )
         
-        return result.modified_count > 0
+        if result.modified_count > 0:
+            try:
+                # Trigger grading and analysis
+                analysis = analyze_subjective_answers(test_id, student_id)
+                if analysis:
+                    # Update the submission with the analysis and score
+                    subjective_tests_collection.update_one(
+                        {"_id": test_id, "submissions.student_id": student_id},
+                        {
+                            "$set": {
+                                "submissions.$.analysis": analysis,
+                                "submissions.$.score": analysis.get('correctness_score')
+                            }
+                        }
+                    )
+                    return True
+                else:
+                    print("Error: Analysis failed")
+                    return False
+            except Exception as e:
+                print(f"Warning: Grading failed but submission was saved: {e}")
+                return True  # We still return True since the submission itself was successful
+            
+        print("Error: No document was modified")
+        return False
+        
     except Exception as e:
-        print(f"Error submitting test: {e}")
+        print(f"Error submitting subjective test: {str(e)}")
         return False
 
+def analyze_subjective_answers(test_id, student_id):
+    """Analyze subjective test answers for correctness and improvements"""
+    try:
+        # Get test and submission details
+        test_doc = subjective_tests_collection.find_one({"_id": test_id})
+        if not test_doc:
+            print(f"Test document not found for test_id: {test_id}")
+            return None
+            
+        submission = next(
+            (sub for sub in test_doc.get('submissions', []) if sub['student_id'] == student_id),
+            None
+        )
+        
+        if not submission:
+            print(f"No submission found for student_id: {student_id}")
+            return None
+        
+        # Get questions and answers
+        questions = test_doc.get('questions', [])
+        student_answers = submission.get('answers', [])
+        
+        if not questions or not student_answers:
+            print("No questions or answers found")
+            return None
+            
+        # Retrieve the synoptic from the synoptic_store collection
+        synoptic_doc = synoptic_store_collection.find_one({"session_title": test_doc.get('title')})
+        synoptic = synoptic_doc.get('synoptic', '') if synoptic_doc else ''
+        
+        # Analyze each question separately
+        all_analyses = []
+        total_score = 0
+        
+        for i, (question, answer) in enumerate(zip(questions, student_answers), 1):
+            # Format content for individual question
+            analysis_content = f"Question {i}: {question['question']}\nAnswer: {answer}\n\n"
+            
+            # Get analysis for this question
+            individual_analysis = derive_analytics(
+                goal="Analyze and Grade",
+                reference_text=analysis_content,
+                openai_api_key=OPENAI_API_KEY,
+                context=test_doc.get('context', ''),
+                synoptic=synoptic[i-1] if isinstance(synoptic, list) else synoptic
+            )
+            
+            if individual_analysis:
+                # Extract score for this question
+                try:
+                    score_match = re.search(r'(\d+)(?:/10)?', individual_analysis)
+                    if score_match:
+                        question_score = int(score_match.group(1))
+                        if 1 <= question_score <= 10:
+                            total_score += question_score
+                except:
+                    question_score = 0
+                
+                # Format individual analysis
+                formatted_analysis = f"\n\n## Question {i} Analysis\n\n{individual_analysis}"
+                all_analyses.append(formatted_analysis)
+        
+        if not all_analyses:
+            print("Error: No analyses generated")
+            return None
+            
+        # Calculate average score
+        average_score = round(total_score / len(questions)) if questions else 0
+        
+        # Combine all analyses
+        combined_analysis = "\n".join(all_analyses)
+        
+        # Format final results
+        analysis_results = {
+            "content_analysis": combined_analysis,
+            "analyzed_at": datetime.utcnow(),
+            "correctness_score": average_score
+        }
+        
+        return analysis_results
+        
+    except Exception as e:
+        print(f"Error in analyze_subjective_answers: {str(e)}")
+        return None
+
 def display_subjective_test_tab(student_id, course_id, session_id):
     """Display subjective tests for students"""
     st.header("Subjective Tests")
-
+    
     try:
+        # Query for active tests
         subjective_tests = list(subjective_tests_collection.find({
             "course_id": course_id,
             "session_id": session_id,
@@ -2141,7 +2721,7 @@ def display_subjective_test_tab(student_id, course_id, session_id):
                      if sub['student_id'] == str(student_id)), 
                     None
                 )
-
+                
                 if existing_submission:
                     st.success("Test completed! Your answers have been submitted.")
                     st.subheader("Your Answers")
@@ -2149,19 +2729,9 @@ def display_subjective_test_tab(student_id, course_id, session_id):
                         st.markdown(f"**Question {i+1}:** {test['questions'][i]['question']}")
                         st.markdown(f"**Your Answer:** {ans}")
                         st.markdown("---")
-
+                    
                     # Display analysis
-                    analysis = subjective_test_analysis_collection.find_one({
-                        "test_id": test['_id'],
-                        "student_id": str(student_id)
-                    })
-                    if analysis:
-                        st.subheader("Answer Analysis")
-                        st.markdown("### Evidence-Based Feedback")
-                        st.markdown(analysis.get('content_analysis', 'No analysis available'))
-                        analyzed_at = analysis.get('analyzed_at')
-                        if analyzed_at:
-                            st.caption(f"Analysis performed at: {analyzed_at.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+                    display_subjective_analysis(test['_id'], str(student_id), test.get('context', ''))
                 else:
                     st.write("Please write your answers:")
                     with st.form(key=f"subjective_test_form_{test['_id']}"):
@@ -2192,27 +2762,43 @@ def display_subjective_test_tab(student_id, course_id, session_id):
     except Exception as e:
         print(f"Error in display_subjective_test_tab: {str(e)}", flush=True)
         st.error("An error occurred while loading the tests. Please try again later.")
+    
+def display_subjective_analysis(test_id, student_id, context):
+    """Display subjective test analysis to students and faculty"""
+    try:
+        test_doc = subjective_tests_collection.find_one({"_id": test_id})
+        submission = next(
+            (sub for sub in test_doc.get('submissions', []) if sub['student_id'] == student_id),
+            None
+        )
         
-def review_and_edit_analysis(test_id, student_id):
-    """Allow faculty to review and edit the generated analysis before storing it"""
-    analysis = st.session_state.get('llm_analysis')
-    if not analysis:
-        st.error("No analysis available for review.")
-        return
-
-    st.header("Review and Edit Analysis")
-    content_analysis = st.text_area("Content Analysis", value=analysis['content_analysis'], height=300)
-    correctness_score = st.number_input("Correctness Score", value=analysis['correctness_score'], min_value=0, max_value=10)
-
-    if st.button("Save Analysis"):
-        # Store the edited analysis in MongoDB
-        analysis_results = {
-            "test_id": test_id,
-            "student_id": student_id,
-            "content_analysis": content_analysis,
-            "analyzed_at": datetime.utcnow(),
-            "correctness_score": correctness_score
-        }
-        subjective_test_analysis_collection.insert_one(analysis_results)
-        st.success("Analysis saved successfully!")
-        del st.session_state['llm_analysis']  # Clear the temporary analysis
+        if not submission:
+            st.warning("No submission found for analysis.")
+            return
+            
+        # Get or generate analysis
+        analysis = submission.get('analysis')
+        if not analysis:
+            analysis = analyze_subjective_answers(test_id, student_id, context)
+            if not analysis:
+                st.error("Could not generate analysis.")
+                return
+        
+        # Display analysis results
+        st.subheader("Answer Analysis")
+        
+        # Content analysis
+        st.markdown("### Evidence-Based Feedback")
+        st.markdown(analysis.get('content_analysis', 'No analysis available'))
+        
+        # Improvement suggestions
+        # st.markdown("### Suggested Improvements")
+        # st.markdown(analysis.get('suggested_improvements', 'No suggestions available'))
+        
+        # Analysis timestamp
+        analyzed_at = analysis.get('analyzed_at')
+        if analyzed_at:
+            st.caption(f"Analysis performed at: {analyzed_at.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+            
+    except Exception as e:
+        st.error(f"Error displaying analysis: {e}")