feat: Complete ExamIDE with test cases, auto-judging, scoring, PDF reports, room expiry & Docker

- Backend: FastAPI with multi-language code execution (Python, JS, Java, C++)
- Frontend: Streamlit with teacher dashboard and student workspace
- Test Cases: Example (visible) + hidden test cases per question
- Auto-Judging: LeetCode-style judging with per-case verdicts
- Scoring: Score = (passed/total) * 100 per question, best score tracked
- PDF Reports: ReportLab-based reports with scores, violations, grades
- Room Expiry: Auto-revoke room codes after exam ends (blocks join/save/submit)
- Violations: Tab-switch detection with severity ratings
- Docker: docker-compose with backend + frontend containers
- MongoDB Atlas: TLS/SRV support with certifi + dnspython

.dockerignore

@@ -0,0 +1,33 @@
+# Virtual environments
+.venv
+venv
+.env.local
+
+# Python cache
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+
+# IDE files
+.idea
+.vscode
+*.swp
+*.swo
+
+# Git
+.git
+.gitignore
+
+# Logs and temp files
+*.log
+conn_test_log.txt
+conn_test_log_2.txt
+connection_test_output.txt
+
+# Docs (not needed in container)
+docs/
+
+# OS files
+Thumbs.db
+.DS_Store

.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Environment variables (SENSITIVE - never commit)
+.env
+.env.local
+.env.production
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Logs & temp
+*.log
+conn_test_log.txt
+conn_test_log_2.txt
+connection_test_output.txt
+
+# Test files
+test_report.pdf
+verify_api.py

Dockerfile.backend

@@ -0,0 +1,45 @@
+# ============================================================================
+# Online Exam IDE — Backend Dockerfile
+# ============================================================================
+# Multi-language code execution: Python, Node.js, Java (JDK), C++ (g++)
+# ============================================================================
+
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies for multi-language code execution
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    # Node.js for JavaScript execution
+    nodejs \
+    npm \
+    # C++ compiler
+    g++ \
+    # Java JDK for Java execution
+    default-jdk \
+    # DNS utils (needed for MongoDB Atlas SRV records)
+    dnsutils \
+    # Cleanup
+    && rm -rf /var/lib/apt/lists/*
+
+# Create app directory
+WORKDIR /app
+
+# Copy requirements and install Python dependencies
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy backend source code
+COPY backend/ .
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Dockerfile.frontend

@@ -0,0 +1,31 @@
+# ============================================================================
+# Online Exam IDE — Frontend Dockerfile  
+# ============================================================================
+# Streamlit-based frontend
+# ============================================================================
+
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Create app directory
+WORKDIR /app
+
+# Copy requirements and install Python dependencies
+COPY frontend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy frontend source code
+COPY frontend/ .
+
+# Expose Streamlit default port
+EXPOSE 8501
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8501/_stcore/health')" || exit 1
+
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0", "--server.headless=true"]

backend/.env.example

@@ -0,0 +1,4 @@
+# MongoDB Atlas connection string
+# Get yours at https://cloud.mongodb.com
+# IMPORTANT: Whitelist your IP in Atlas → Network Access before connecting
+MONGO_URI=mongodb+srv://<username>:<password>@<cluster>.mongodb.net/?retryWrites=true&w=majority

backend/code_executor.py

@@ -0,0 +1,246 @@
+import subprocess
+import os
+import tempfile
+from typing import Dict, Optional
+
+
+class CodeExecutor:
+    def __init__(self, timeout: int = 10):
+        self.timeout = timeout
+    
+    def execute(self, code: str, language: str = "python", stdin_input: str = None) -> Dict:
+        """Execute code in the specified language, optionally piping stdin_input."""
+        language = language.lower().strip()
+
+        if language in ["python", "py"]:
+            return self._execute_python(code, stdin_input)
+        elif language in ["javascript", "js"]:
+            return self._execute_javascript(code, stdin_input)
+        elif language == "java":
+            return self._execute_java(code, stdin_input)
+        elif language in ["cpp", "c++"]:
+            return self._execute_cpp(code, stdin_input)
+        else:
+            return {
+                "success": False,
+                "error": f"Unsupported language: {language}"
+            }
+
+    def execute_with_test_case(self, code: str, language: str, input_data: str, expected_output: str) -> Dict:
+        """
+        Execute code with given stdin input and compare output with expected.
+        Returns result with pass/fail, actual output, etc.
+        """
+        result = self.execute(code, language, stdin_input=input_data)
+
+        if not result.get("success"):
+            return {
+                "passed": False,
+                "actual_output": result.get("error", ""),
+                "expected_output": expected_output.strip(),
+                "error": result.get("error", "Execution failed"),
+                "status": "Runtime Error" if "timeout" not in result.get("error", "").lower() else "Time Limit Exceeded"
+            }
+
+        actual = result.get("output", "").strip()
+        expected = expected_output.strip()
+
+        passed = actual == expected
+
+        return {
+            "passed": passed,
+            "actual_output": actual,
+            "expected_output": expected,
+            "error": None,
+            "status": "Accepted" if passed else "Wrong Answer"
+        }
+
+    def _execute_python(self, code: str, stdin_input: str = None) -> Dict:
+        """Execute Python code"""
+        try:
+            result = subprocess.run(
+                ["python", "-c", code],
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+                input=stdin_input
+            )
+
+            if result.returncode == 0:
+                return {
+                    "success": True,
+                    "output": result.stdout if result.stdout else "(No output)"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": result.stderr if result.stderr else "Unknown error"
+                }
+        except subprocess.TimeoutExpired:
+            return {
+                "success": False,
+                "error": f"Code execution timeout (>{self.timeout}s)"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    def _execute_javascript(self, code: str, stdin_input: str = None) -> Dict:
+        """Execute JavaScript code using Node.js"""
+        try:
+            result = subprocess.run(
+                ["node", "-e", code],
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+                input=stdin_input
+            )
+
+            if result.returncode == 0:
+                return {
+                    "success": True,
+                    "output": result.stdout if result.stdout else "(No output)"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": result.stderr if result.stderr else "Unknown error"
+                }
+        except subprocess.TimeoutExpired:
+            return {
+                "success": False,
+                "error": f"Code execution timeout (>{self.timeout}s)"
+            }
+        except FileNotFoundError:
+            return {
+                "success": False,
+                "error": "Node.js not installed. Install Node.js to run JavaScript"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    def _execute_java(self, code: str, stdin_input: str = None) -> Dict:
+        """Execute Java code"""
+        try:
+            # Create temp directory
+            with tempfile.TemporaryDirectory() as tmpdir:
+                # Write Java file
+                java_file = os.path.join(tmpdir, "Main.java")
+                with open(java_file, "w") as f:
+                    f.write(code)
+
+                # Compile
+                compile_result = subprocess.run(
+                    ["javac", java_file],
+                    capture_output=True,
+                    text=True,
+                    timeout=self.timeout
+                )
+
+                if compile_result.returncode != 0:
+                    return {
+                        "success": False,
+                        "error": compile_result.stderr if compile_result.stderr else "Compilation error"
+                    }
+
+                # Run
+                run_result = subprocess.run(
+                    ["java", "-cp", tmpdir, "Main"],
+                    capture_output=True,
+                    text=True,
+                    timeout=self.timeout,
+                    input=stdin_input
+                )
+
+                if run_result.returncode == 0:
+                    return {
+                        "success": True,
+                        "output": run_result.stdout if run_result.stdout else "(No output)"
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": run_result.stderr if run_result.stderr else "Runtime error"
+                    }
+
+        except subprocess.TimeoutExpired:
+            return {
+                "success": False,
+                "error": f"Code execution timeout (>{self.timeout}s)"
+            }
+        except FileNotFoundError:
+            return {
+                "success": False,
+                "error": "Java not installed. Install JDK to run Java code"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    def _execute_cpp(self, code: str, stdin_input: str = None) -> Dict:
+        """Execute C++ code"""
+        try:
+            with tempfile.TemporaryDirectory() as tmpdir:
+                # Write C++ file
+                cpp_file = os.path.join(tmpdir, "main.cpp")
+                exe_file = os.path.join(tmpdir, "main")
+
+                with open(cpp_file, "w") as f:
+                    f.write(code)
+
+                # Compile
+                compile_result = subprocess.run(
+                    ["g++", cpp_file, "-o", exe_file],
+                    capture_output=True,
+                    text=True,
+                    timeout=self.timeout
+                )
+
+                if compile_result.returncode != 0:
+                    return {
+                        "success": False,
+                        "error": compile_result.stderr if compile_result.stderr else "Compilation error"
+                    }
+
+                # Run
+                run_result = subprocess.run(
+                    [exe_file],
+                    capture_output=True,
+                    text=True,
+                    timeout=self.timeout,
+                    input=stdin_input
+                )
+
+                if run_result.returncode == 0:
+                    return {
+                        "success": True,
+                        "output": run_result.stdout if run_result.stdout else "(No output)"
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "error": run_result.stderr if run_result.stderr else "Runtime error"
+                    }
+
+        except subprocess.TimeoutExpired:
+            return {
+                "success": False,
+                "error": f"Code execution timeout (>{self.timeout}s)"
+            }
+        except FileNotFoundError:
+            return {
+                "success": False,
+                "error": "G++ not installed. Install GCC to run C++ code"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }

backend/database.py

@@ -0,0 +1,309 @@
+
+import motor.motor_asyncio
+import uuid
+import asyncio
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional
+from models import Room, Question, Worksheet, ExecutionResult
+
+import certifi
+
+class Database:
+    def __init__(self, uri: str):
+        self.client = motor.motor_asyncio.AsyncIOMotorClient(
+            uri,
+            tlsCAFile=certifi.where()
+        )
+        self.db = self.client.exam_ide_db
+        self.rooms_collection = self.db.rooms
+        self.questions_collection = self.db.questions
+        self.worksheets_collection = self.db.worksheets
+
+    async def create_room(
+        self,
+        room_name: str,
+        teacher_name: str,
+        language: str,
+        duration_minutes: int,
+        start_time: Optional[str] = None
+    ) -> dict:
+        room_id = str(uuid.uuid4())
+        room_code = str(uuid.uuid4())[:6].upper()
+
+        # Calculate end time if start time is provided
+        end_time: Optional[str] = None
+        if start_time and duration_minutes:
+            try:
+                # Normalize and parse start_time
+                start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                end_dt = start_dt + timedelta(minutes=duration_minutes)
+                end_time = end_dt.isoformat()
+            except Exception:
+                # If parsing fails, just leave end_time as None
+                end_time = None
+
+        room_doc = {
+            "room_id": room_id,
+            "room_code": room_code,
+            "room_name": room_name,
+            "teacher_name": teacher_name,
+            "language": language,
+            "duration_minutes": duration_minutes,
+            "start_time": start_time,
+            "end_time": end_time,
+            "students": [],
+            "student_names": {},
+            "student_red_flags": {},
+            "questions": [],
+            "status": "active",
+            "created_at": datetime.now(),
+        }
+
+        await self.rooms_collection.insert_one(room_doc)
+        room_doc.pop("_id", None)  # Remove Mongo ID
+        return room_doc
+
+    async def get_room(self, room_id: str) -> Optional[dict]:
+        room = await self.rooms_collection.find_one({"room_id": room_id}, {"_id": 0})
+        return room
+
+    async def get_room_by_code(self, room_code: str) -> Optional[dict]:
+        room = await self.rooms_collection.find_one({"room_code": room_code}, {"_id": 0})
+        return room
+
+    def is_room_expired(self, room: dict) -> bool:
+        """Check if a room's exam time has ended."""
+        end_time_str = room.get("end_time")
+        if not end_time_str:
+            return False
+        try:
+            end_dt = datetime.fromisoformat(end_time_str.replace("Z", "+00:00"))
+            # Compare as naive if needed
+            now = datetime.now(end_dt.tzinfo) if end_dt.tzinfo else datetime.now()
+            return now > end_dt
+        except Exception:
+            return False
+
+    async def expire_room(self, room_id: str):
+        """Mark a room as expired."""
+        await self.rooms_collection.update_one(
+            {"room_id": room_id},
+            {"$set": {"status": "expired"}}
+        )
+
+    async def join_room(self, room_code: str, student_name: str) -> Optional[dict]:
+        room = await self.get_room_by_code(room_code)
+        if not room:
+            return None
+
+        # Security: reject joins if room is expired
+        if room.get("status") == "expired" or self.is_room_expired(room):
+            # Auto-mark as expired in DB if not already
+            if room.get("status") != "expired":
+                await self.expire_room(room["room_id"])
+            return {"error": "expired", "detail": "This exam has ended. Room code is no longer valid."}
+
+        room_id = room["room_id"]
+        student_id = str(uuid.uuid4())
+        
+        # Update room with new student
+        await self.rooms_collection.update_one(
+            {"room_id": room_id},
+            {
+                "$push": {"students": student_id},
+                "$set": {f"student_names.{student_id}": student_name}
+            }
+        )
+        
+        return {
+            "room_id": room_id,
+            "student_id": student_id,
+            "student_name": student_name
+        }
+
+    async def create_question(
+        self,
+        room_id: str,
+        question_text: str,
+        language: str,
+        test_cases: Optional[List[dict]] = None
+    ) -> Optional[dict]:
+        """Create a question with optional test cases (example + hidden)."""
+        room = await self.get_room(room_id)
+        if not room:
+            return None
+
+        question_id = str(uuid.uuid4())
+
+        # Build test case list with generated IDs
+        processed_test_cases = []
+        if test_cases:
+            for tc in test_cases:
+                processed_test_cases.append({
+                    "test_id": tc.get("test_id", str(uuid.uuid4())),
+                    "input_data": tc.get("input_data", ""),
+                    "expected_output": tc.get("expected_output", ""),
+                    "is_hidden": tc.get("is_hidden", False)
+                })
+
+        question = {
+            "question_id": question_id,
+            "question_text": question_text,
+            "language": language,
+            "test_cases": processed_test_cases
+        }
+
+        # Embed question in room document
+        await self.rooms_collection.update_one(
+            {"room_id": room_id},
+            {"$push": {"questions": question}}
+        )
+        
+        # Also store in separate collection for direct lookups
+        await self.questions_collection.insert_one(question.copy())
+        if "_id" in question:
+            question.pop("_id")
+        
+        return question
+
+    async def get_questions(self, room_id: str) -> List[dict]:
+        room = await self.get_room(room_id)
+        if room:
+            return room.get("questions", [])
+        return []
+
+    async def get_question(self, room_id: str, question_id: str) -> Optional[dict]:
+        """Get a single question by ID (includes hidden test cases for judging)."""
+        room = await self.get_room(room_id)
+        if not room:
+            return None
+        for q in room.get("questions", []):
+            if q["question_id"] == question_id:
+                return q
+        return None
+
+    async def create_worksheet(self, room_id: str, student_id: str, question_id: str, language: str) -> dict:
+        worksheet_id = str(uuid.uuid4())
+
+        worksheet = {
+            "worksheet_id": worksheet_id,
+            "room_id": room_id,
+            "student_id": student_id,
+            "question_id": question_id,
+            "code": "",
+            "language": language,
+            "status": "working",
+            "last_updated": datetime.now().isoformat(),
+            "submission_results": []  # track submission history
+        }
+
+        await self.worksheets_collection.insert_one(worksheet)
+        worksheet.pop("_id")
+        return worksheet
+
+    async def get_worksheet(self, room_id: str, student_id: str, question_id: str) -> Optional[dict]:
+        ws = await self.worksheets_collection.find_one({
+            "room_id": room_id,
+            "student_id": student_id,
+            "question_id": question_id
+        }, {"_id": 0})
+        return ws
+        
+    async def get_worksheet_by_id(self, worksheet_id: str) -> Optional[dict]:
+         ws = await self.worksheets_collection.find_one({"worksheet_id": worksheet_id}, {"_id": 0})
+         return ws
+
+    async def save_worksheet(self, worksheet_id: str, code: str) -> bool:
+        result = await self.worksheets_collection.update_one(
+            {"worksheet_id": worksheet_id},
+            {
+                "$set": {
+                    "code": code,
+                    "last_updated": datetime.now().isoformat()
+                }
+            }
+        )
+        return result.modified_count > 0 or result.matched_count > 0
+
+    async def save_submission_result(self, worksheet_id: str, submission_result: dict) -> bool:
+        """Save a submission result to the worksheet's history."""
+        result = await self.worksheets_collection.update_one(
+            {"worksheet_id": worksheet_id},
+            {
+                "$push": {"submission_results": submission_result},
+                "$set": {
+                    "status": "accepted" if submission_result.get("overall") == "Accepted" else "attempted",
+                    "last_updated": datetime.now().isoformat()
+                }
+            }
+        )
+        return result.modified_count > 0 or result.matched_count > 0
+
+    async def get_student_worksheets(self, room_id: str, student_id: str) -> Dict:
+        cursor = self.worksheets_collection.find({"room_id": room_id, "student_id": student_id})
+        student_worksheets = {}
+        async for ws in cursor:
+            student_worksheets[ws["worksheet_id"]] = {
+                "code": ws["code"],
+                "language": ws["language"],
+                "status": ws["status"],
+                "last_updated": ws["last_updated"],
+                "question_id": ws["question_id"]
+            }
+        return student_worksheets
+        
+    async def update_red_flags(self, room_id: str, student_id: str, count: int):
+         await self.rooms_collection.update_one(
+            {"room_id": room_id},
+            {"$set": {f"student_red_flags.{student_id}": count}}
+        )
+
+    async def get_student_codes_with_names(self, room_id: str) -> Dict:
+        room = await self.get_room(room_id)
+        if not room:
+            return {}
+
+        student_codes = {}
+        students = room.get("students", [])
+        student_names = room.get("student_names", {})
+        student_red_flags = room.get("student_red_flags", {})
+
+        for student_id in students:
+            student_name = student_names.get(student_id, "Unknown Student")
+            
+            # Get latest worksheet
+            cursor = self.worksheets_collection.find({"room_id": room_id, "student_id": student_id}).sort("last_updated", -1).limit(1)
+            latest_ws = None
+            async for ws in cursor:
+                latest_ws = ws
+            
+            if latest_ws:
+                student_codes[student_id] = {
+                    "student_name": student_name,
+                    "red_flags": student_red_flags.get(student_id, 0),
+                    "code": latest_ws.get("code", ""),
+                    "language": latest_ws.get("language", "python"),
+                    "status": latest_ws.get("status", "working"),
+                    "last_updated": latest_ws.get("last_updated", ""),
+                    "question_id": latest_ws.get("question_id", "")
+                }
+            else:
+                student_codes[student_id] = {
+                    "student_name": student_name,
+                    "red_flags": student_red_flags.get(student_id, 0),
+                    "code": "",
+                    "language": "python",
+                    "status": "idle",
+                    "last_updated": "",
+                    "question_id": ""
+                }
+        
+        return student_codes
+
+    async def get_all_worksheets_for_room(self, room_id: str) -> list:
+        """Get all worksheets for a room (for scoring/report)."""
+        cursor = self.worksheets_collection.find({"room_id": room_id}, {"_id": 0})
+        worksheets = []
+        async for ws in cursor:
+            worksheets.append(ws)
+        return worksheets

backend/main.py

@@ -0,0 +1,596 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import Response
+from typing import List, Dict, Optional
+import os
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+
+from code_executor import CodeExecutor
+from database import Database
+from models import Room, Question, Worksheet, ExecutionResult, TestCase, SubmissionResult
+from report_generator import generate_exam_report
+
+# Load environment variables
+load_dotenv()
+MONGO_URI = os.getenv("MONGO_URI")
+
+if not MONGO_URI:
+    print("WARNING: MONGO_URI not found in .env")
+
+# ============================================================================
+# INITIALIZE APP
+# ============================================================================
+
+app = FastAPI(title="Online Exam IDE API",docs_url="/docs", redoc_url="/redoc")
+# Add CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Database
+db = Database(MONGO_URI)
+code_executor = CodeExecutor()
+
+# Max score per question (each question is worth this many points)
+MAX_SCORE_PER_QUESTION = 100
+
+
+# ============================================================================
+# HELPER: Room expiry check
+# ============================================================================
+
+async def check_room_active(room_id: str) -> dict:
+    """Check if room exists and is active. Auto-expire if time is up."""
+    room = await db.get_room(room_id)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+    
+    if room.get("status") == "expired":
+        raise HTTPException(status_code=403, detail="This exam has ended. Room is no longer accessible.")
+    
+    if db.is_room_expired(room):
+        await db.expire_room(room_id)
+        raise HTTPException(status_code=403, detail="This exam has ended. Room code has been revoked.")
+    
+    return room
+
+
+# ============================================================================
+# HEALTH CHECK
+# ============================================================================
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+
+
+# ============================================================================
+# ROOM ENDPOINTS
+# ============================================================================
+
+@app.post("/api/rooms/create")
+async def create_room(data: dict):
+    """Create a new exam room"""
+    room_name = data.get("room_name")
+    teacher_name = data.get("teacher_name")
+    language = data.get("language", "Python")
+    duration_minutes = int(data.get("duration", 30))
+    start_time = data.get("start_time") # ISO String
+    
+    room = await db.create_room(
+        room_name=room_name,
+        teacher_name=teacher_name,
+        language=language,
+        duration_minutes=duration_minutes,
+        start_time=start_time
+    )
+    
+    return {
+        "room_id": room["room_id"],
+        "room_code": room["room_code"],
+        "room_name": room["room_name"],
+        "teacher_name": room["teacher_name"],
+        "duration_minutes": room["duration_minutes"],
+        "start_time": room["start_time"],
+        "end_time": room["end_time"]
+    }
+
+
+@app.post("/api/rooms/{room_id}/report_violation")
+async def report_violation(room_id: str, data: dict):
+    """Report a student violation (tab switch, etc.)"""
+    student_id = data.get("student_id")
+    
+    room = await db.get_room(room_id)
+    
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+        
+    if student_id:
+        current_flags = room.get("student_red_flags", {}).get(student_id, 0)
+        new_flags = current_flags + 1
+        await db.update_red_flags(room_id, student_id, new_flags)
+        
+        return {"success": True, "new_count": new_flags}
+    
+    return {"success": False}
+
+
+@app.get("/api/rooms/{room_id}")
+async def get_room(room_id: str):
+    """Get room details. Auto-detects and marks expired rooms."""
+    room = await db.get_room(room_id)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    # Auto-expire if time is up (but still return data for teacher to view)
+    status = room.get("status", "active")
+    if status != "expired" and db.is_room_expired(room):
+        await db.expire_room(room_id)
+        status = "expired"
+
+    return {
+        "room_id": room["room_id"],
+        "room_code": room["room_code"],
+        "room_name": room["room_name"],
+        "teacher_name": room["teacher_name"],
+        "students": room.get("students", []),
+        "student_names": room.get("student_names", {}),
+        "questions": room.get("questions", []),
+        "language": room.get("language"),
+        "duration_minutes": room.get("duration_minutes"),
+        "start_time": room.get("start_time"),
+        "end_time": room.get("end_time"),
+        "student_red_flags": room.get("student_red_flags", {}),
+        "status": status
+    }
+
+
+@app.post("/api/rooms/{room_code}/join")
+async def join_room(room_code: str, data: dict):
+    """Join an existing room. BLOCKED if room is expired."""
+    result = await db.join_room(room_code, data.get("student_name"))
+    if not result:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    # Check if db.join_room returned an error (expired room)
+    if "error" in result and result["error"] == "expired":
+        raise HTTPException(status_code=403, detail=result["detail"])
+
+    return result
+
+
+# ============================================================================
+# QUESTION ENDPOINTS
+# ============================================================================
+
+@app.post("/api/rooms/{room_id}/questions")
+async def create_question(room_id: str, data: dict):
+    """Create a question in a room, with optional test cases."""
+    question = await db.create_question(
+        room_id=room_id,
+        question_text=data.get("question_text"),
+        language=data.get("language", "Python"),
+        test_cases=data.get("test_cases", [])
+    )
+
+    if not question:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    return question
+
+
+@app.get("/api/rooms/{room_id}/questions")
+async def get_questions(room_id: str):
+    """
+    Get all questions in a room.
+    Hidden test cases are filtered out for student consumption.
+    """
+    questions = await db.get_questions(room_id)
+    
+    filtered_questions = []
+    for q in questions:
+        filtered_q = {
+            "question_id": q["question_id"],
+            "question_text": q["question_text"],
+            "language": q.get("language", "Python"),
+            "test_cases": [
+                tc for tc in q.get("test_cases", [])
+                if not tc.get("is_hidden", False)
+            ],
+            "total_test_cases": len(q.get("test_cases", [])),
+            "hidden_test_cases_count": len([
+                tc for tc in q.get("test_cases", [])
+                if tc.get("is_hidden", False)
+            ])
+        }
+        filtered_questions.append(filtered_q)
+    
+    return {"questions": filtered_questions}
+
+
+@app.get("/api/rooms/{room_id}/questions/full")
+async def get_questions_full(room_id: str):
+    """Get all questions including hidden test cases (for teacher use)."""
+    questions = await db.get_questions(room_id)
+    return {"questions": questions}
+
+
+# ============================================================================
+# WORKSHEET ENDPOINTS
+# ============================================================================
+
+@app.get("/api/worksheets/{room_id}/{student_id}/{question_id}")
+async def get_worksheet(room_id: str, student_id: str, question_id: str):
+    """Get or create a worksheet"""
+    ws = await db.get_worksheet(room_id, student_id, question_id)
+
+    if ws:
+        pass
+    else:
+        room = await db.get_room(room_id)
+        language = "Python" # Default
+        if room:
+            for q in room.get("questions", []):
+                if q["question_id"] == question_id:
+                    language = q.get("language", "Python")
+                    break
+        
+        ws = await db.create_worksheet(room_id, student_id, question_id, language)
+
+    return {
+        "worksheet_id": ws["worksheet_id"],
+        "code": ws["code"],
+        "language": ws["language"],
+        "status": ws["status"],
+        "last_updated": ws["last_updated"]
+    }
+
+
+@app.post("/api/worksheets/{worksheet_id}/save")
+async def save_worksheet(worksheet_id: str, data: dict):
+    """Save worksheet code. BLOCKED if room is expired."""
+    # Check if the worksheet's room is still active
+    ws = await db.get_worksheet_by_id(worksheet_id)
+    if not ws:
+        raise HTTPException(status_code=404, detail="Worksheet not found")
+    
+    room = await db.get_room(ws["room_id"])
+    if room and (room.get("status") == "expired" or db.is_room_expired(room)):
+        if room.get("status") != "expired":
+            await db.expire_room(room["room_id"])
+        raise HTTPException(status_code=403, detail="Exam has ended. Cannot save code.")
+
+    success = await db.save_worksheet(worksheet_id, data.get("code", ""))
+
+    if not success:
+        return {"success": True, "message": "Code saved (no changes)"}
+
+    return {"success": True, "message": "Code saved"}
+
+
+# ============================================================================
+# CODE EXECUTION ENDPOINT
+# ============================================================================
+
+@app.post("/api/execute")
+async def execute_code(data: dict):
+    """Execute code (freeform run, no test case checking)"""
+    code = data.get("code")
+    language = data.get("language", "python").lower()
+
+    result = code_executor.execute(code, language)
+
+    return result
+
+
+# ============================================================================
+# SUBMISSION / AUTO-JUDGE ENDPOINT  (WITH SCORING)
+# ============================================================================
+
+@app.post("/api/submit")
+async def submit_solution(data: dict):
+    """
+    Submit a solution for judging against all test cases.
+    Returns per-case results AND a score.
+    
+    Score = (passed_cases / total_cases) * MAX_SCORE_PER_QUESTION
+    
+    BLOCKED if room is expired.
+    """
+    code = data.get("code", "")
+    language = data.get("language", "python").lower()
+    room_id = data.get("room_id")
+    question_id = data.get("question_id")
+    student_id = data.get("student_id")
+
+    if not all([code, room_id, question_id, student_id]):
+        raise HTTPException(status_code=400, detail="Missing required fields")
+
+    # Security: check room is active
+    room = await db.get_room(room_id)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+    
+    if room.get("status") == "expired" or db.is_room_expired(room):
+        if room.get("status") != "expired":
+            await db.expire_room(room_id)
+        raise HTTPException(status_code=403, detail="Exam has ended. Cannot submit solutions.")
+
+    # Get the question with ALL test cases (including hidden)
+    question = await db.get_question(room_id, question_id)
+    if not question:
+        raise HTTPException(status_code=404, detail="Question not found")
+
+    test_cases = question.get("test_cases", [])
+    if not test_cases:
+        raise HTTPException(status_code=400, detail="No test cases defined for this question")
+
+    # Run code against each test case
+    results = []
+    passed_count = 0
+    has_error = False
+
+    for i, tc in enumerate(test_cases):
+        tc_result = code_executor.execute_with_test_case(
+            code=code,
+            language=language,
+            input_data=tc.get("input_data", ""),
+            expected_output=tc.get("expected_output", "")
+        )
+
+        is_hidden = tc.get("is_hidden", False)
+
+        case_result = {
+            "case_number": i + 1,
+            "is_hidden": is_hidden,
+            "passed": tc_result["passed"],
+            "status": tc_result["status"],
+        }
+
+        # For example (visible) test cases, show full details
+        if not is_hidden:
+            case_result["input_data"] = tc.get("input_data", "")
+            case_result["expected_output"] = tc_result["expected_output"]
+            case_result["actual_output"] = tc_result["actual_output"]
+
+        if tc_result.get("error"):
+            case_result["error"] = tc_result["error"] if not is_hidden else "Runtime Error"
+            has_error = True
+
+        if tc_result["passed"]:
+            passed_count += 1
+
+        results.append(case_result)
+
+    # Determine overall verdict
+    total = len(test_cases)
+    if passed_count == total:
+        overall = "Accepted"
+    elif has_error:
+        overall = "Runtime Error"
+    else:
+        overall = "Wrong Answer"
+
+    # Calculate score
+    score = (passed_count / total) * MAX_SCORE_PER_QUESTION if total > 0 else 0
+
+    submission_result = {
+        "question_id": question_id,
+        "total_cases": total,
+        "passed_cases": passed_count,
+        "results": results,
+        "overall": overall,
+        "score": round(score, 1),
+        "max_score": MAX_SCORE_PER_QUESTION,
+        "submitted_at": datetime.now().isoformat()
+    }
+
+    # Save submission result to worksheet
+    try:
+        ws = await db.get_worksheet(room_id, student_id, question_id)
+        if ws:
+            await db.save_worksheet(ws["worksheet_id"], code)
+            await db.save_submission_result(ws["worksheet_id"], submission_result)
+    except Exception as e:
+        print(f"Warning: Could not save submission result: {e}")
+
+    return submission_result
+
+
+# ============================================================================
+# SCORES ENDPOINT
+# ============================================================================
+
+@app.get("/api/rooms/{room_id}/scores")
+async def get_room_scores(room_id: str):
+    """
+    Get aggregated scores for all students in a room.
+    Returns per-student, per-question scores based on their best submission.
+    """
+    room = await db.get_room(room_id)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    questions = room.get("questions", [])
+    students = room.get("students", [])
+    student_names = room.get("student_names", {})
+    student_red_flags = room.get("student_red_flags", {})
+
+    # Get all worksheets for the room
+    all_worksheets = await db.get_all_worksheets_for_room(room_id)
+
+    # Build lookup: (student_id, question_id) -> best submission
+    ws_lookup = {}
+    for ws in all_worksheets:
+        key = (ws["student_id"], ws["question_id"])
+        ws_lookup[key] = ws
+
+    scores_data = []
+    for sid in students:
+        student_entry = {
+            "student_id": sid,
+            "student_name": student_names.get(sid, "Unknown"),
+            "red_flags": student_red_flags.get(sid, 0),
+            "questions": [],
+            "total_score": 0,
+            "max_total": len(questions) * MAX_SCORE_PER_QUESTION
+        }
+
+        for q in questions:
+            qid = q["question_id"]
+            ws = ws_lookup.get((sid, qid))
+
+            best_score = 0
+            status = "not_attempted"
+
+            if ws and ws.get("submission_results"):
+                # Find best submission score
+                for sub in ws["submission_results"]:
+                    sub_score = sub.get("score", 0)
+                    if sub_score > best_score:
+                        best_score = sub_score
+                    if sub.get("overall") == "Accepted":
+                        status = "accepted"
+                    elif status != "accepted":
+                        status = "attempted"
+
+            student_entry["questions"].append({
+                "question_id": qid,
+                "score": best_score,
+                "max_score": MAX_SCORE_PER_QUESTION,
+                "status": status
+            })
+            student_entry["total_score"] += best_score
+
+        scores_data.append(student_entry)
+
+    # Sort by total score descending
+    scores_data.sort(key=lambda x: x["total_score"], reverse=True)
+
+    return {
+        "room_id": room_id,
+        "room_name": room.get("room_name"),
+        "max_score_per_question": MAX_SCORE_PER_QUESTION,
+        "total_questions": len(questions),
+        "total_students": len(students),
+        "scores": scores_data
+    }
+
+
+# ============================================================================
+# PDF REPORT ENDPOINT
+# ============================================================================
+
+@app.get("/api/rooms/{room_id}/report")
+async def generate_report(room_id: str):
+    """
+    Generate and download a PDF exam report with scores and violations.
+    Uses ReportLab library.
+    """
+    room = await db.get_room(room_id)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    questions = room.get("questions", [])
+    students = room.get("students", [])
+    student_names = room.get("student_names", {})
+    student_red_flags = room.get("student_red_flags", {})
+
+    # Get all worksheets for scoring
+    all_worksheets = await db.get_all_worksheets_for_room(room_id)
+
+    ws_lookup = {}
+    for ws in all_worksheets:
+        key = (ws["student_id"], ws["question_id"])
+        ws_lookup[key] = ws
+
+    # Build scores data for report
+    scores_data = []
+    for sid in students:
+        student_entry = {
+            "student_id": sid,
+            "student_name": student_names.get(sid, "Unknown"),
+            "red_flags": student_red_flags.get(sid, 0),
+            "questions": [],
+            "total_score": 0,
+            "max_total": len(questions) * MAX_SCORE_PER_QUESTION
+        }
+
+        for q in questions:
+            qid = q["question_id"]
+            ws = ws_lookup.get((sid, qid))
+
+            best_score = 0
+            status = "not_attempted"
+
+            if ws and ws.get("submission_results"):
+                for sub in ws["submission_results"]:
+                    sub_score = sub.get("score", 0)
+                    if sub_score > best_score:
+                        best_score = sub_score
+                    if sub.get("overall") == "Accepted":
+                        status = "accepted"
+                    elif status != "accepted":
+                        status = "attempted"
+
+            student_entry["questions"].append({
+                "question_id": qid,
+                "score": best_score,
+                "max_score": MAX_SCORE_PER_QUESTION,
+                "status": status
+            })
+            student_entry["total_score"] += best_score
+
+        scores_data.append(student_entry)
+
+    # Sort by total score descending
+    scores_data.sort(key=lambda x: x["total_score"], reverse=True)
+
+    # Generate PDF
+    pdf_bytes = generate_exam_report(
+        room_data=room,
+        scores_data=scores_data,
+        questions=questions
+    )
+
+    # Return as downloadable PDF
+    filename = f"exam_report_{room.get('room_name', 'report').replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+    
+    return Response(
+        content=pdf_bytes,
+        media_type="application/pdf",
+        headers={
+            "Content-Disposition": f"attachment; filename={filename}"
+        }
+    )
+
+
+# ============================================================================
+# LIVE CODE MONITOR ENDPOINT
+# ============================================================================
+
+@app.get("/api/rooms/{room_id}/student-codes")
+async def get_student_codes(room_id: str):
+    """Get all student codes in a room with student NAMES"""
+    room = await db.get_room(room_id)
+    if not room:
+        raise HTTPException(status_code=404, detail="Room not found")
+
+    student_codes = await db.get_student_codes_with_names(room_id)
+
+    return {
+        "room_id": room_id,
+        "student_codes": student_codes,
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

backend/models.py

@@ -0,0 +1,55 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict
+
+class TestCase(BaseModel):
+    test_id: str
+    input_data: str          # stdin input to feed the program
+    expected_output: str     # expected stdout output (stripped for comparison)
+    is_hidden: bool = False  # True = hidden from students, used only for judging
+
+class Room(BaseModel):
+    room_id: str
+    room_code: str
+    room_name: str
+    teacher_name: str
+    language: str
+    duration_minutes: int
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    students: List[str] = []
+    student_names: Dict[str, str] = {}
+    student_red_flags: Dict[str, int] = {}
+    questions: List[dict] = []
+    status: str = "active"
+
+class Question(BaseModel):
+    question_id: str
+    question_text: str
+    language: str
+    test_cases: List[TestCase] = []
+
+class Worksheet(BaseModel):
+    worksheet_id: str
+    room_id: str
+    student_id: str
+    question_id: str
+    code: str = ""
+    language: str
+    status: str = "working"
+    last_updated: str
+
+class ExecutionResult(BaseModel):
+    success: bool
+    output: Optional[str] = None
+    error: Optional[str] = None
+
+class CodeExecutionRequest(BaseModel):
+    code: str
+    language: str
+
+class SubmissionResult(BaseModel):
+    question_id: str
+    total_cases: int
+    passed_cases: int
+    results: List[dict] = []  # per-case verdict details
+    overall: str              # "Accepted" / "Wrong Answer" / "Runtime Error" / "Compilation Error"

backend/report_generator.py

@@ -0,0 +1,432 @@
+"""
+PDF Report Generator for Online Exam IDE
+Uses ReportLab to generate exam reports with student scores and violations.
+"""
+
+import io
+from datetime import datetime
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4, landscape
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch, mm
+from reportlab.platypus import (
+    SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer,
+    HRFlowable, PageBreak
+)
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
+
+
+def generate_exam_report(room_data: dict, scores_data: list, questions: list) -> bytes:
+    """
+    Generate a PDF exam report.
+
+    Args:
+        room_data: Room details (name, teacher, duration, start/end, etc.)
+        scores_data: List of dicts per student:
+            {
+                "student_id": str,
+                "student_name": str,
+                "red_flags": int,
+                "questions": [
+                    {"question_id": str, "score": float, "max_score": float, "status": str}
+                ],
+                "total_score": float,
+                "max_total": float
+            }
+        questions: List of question dicts with question_text and question_id
+
+    Returns:
+        PDF file as bytes
+    """
+    buffer = io.BytesIO()
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=landscape(A4),
+        rightMargin=30,
+        leftMargin=30,
+        topMargin=30,
+        bottomMargin=30,
+        title=f"Exam Report - {room_data.get('room_name', 'Unknown')}",
+        author=room_data.get("teacher_name", "Teacher")
+    )
+
+    styles = getSampleStyleSheet()
+    elements = []
+
+    # ============================
+    # Custom styles
+    # ============================
+    title_style = ParagraphStyle(
+        'CustomTitle',
+        parent=styles['Title'],
+        fontSize=22,
+        spaceAfter=6,
+        textColor=colors.HexColor("#1a1a2e"),
+        fontName="Helvetica-Bold"
+    )
+    subtitle_style = ParagraphStyle(
+        'CustomSubtitle',
+        parent=styles['Normal'],
+        fontSize=12,
+        spaceAfter=4,
+        textColor=colors.HexColor("#555555"),
+        fontName="Helvetica"
+    )
+    heading_style = ParagraphStyle(
+        'CustomHeading',
+        parent=styles['Heading2'],
+        fontSize=14,
+        spaceBefore=12,
+        spaceAfter=6,
+        textColor=colors.HexColor("#16213e"),
+        fontName="Helvetica-Bold"
+    )
+    small_style = ParagraphStyle(
+        'SmallText',
+        parent=styles['Normal'],
+        fontSize=8,
+        textColor=colors.HexColor("#888888"),
+    )
+
+    # ============================
+    # HEADER
+    # ============================
+    elements.append(Paragraph(f"📋 Exam Report", title_style))
+    elements.append(Paragraph(
+        f"<b>{room_data.get('room_name', 'Untitled Exam')}</b>",
+        subtitle_style
+    ))
+    elements.append(Spacer(1, 4))
+
+    # Exam info table
+    start_time = room_data.get("start_time", "N/A")
+    end_time = room_data.get("end_time", "N/A")
+    if start_time and start_time != "N/A":
+        try:
+            start_time = datetime.fromisoformat(start_time).strftime("%Y-%m-%d %H:%M")
+        except:
+            pass
+    if end_time and end_time != "N/A":
+        try:
+            end_time = datetime.fromisoformat(end_time).strftime("%Y-%m-%d %H:%M")
+        except:
+            pass
+
+    info_data = [
+        ["Teacher", room_data.get("teacher_name", "N/A"),
+         "Room Code", room_data.get("room_code", "N/A"),
+         "Language", room_data.get("language", "N/A")],
+        ["Duration", f"{room_data.get('duration_minutes', 'N/A')} min",
+         "Start Time", str(start_time),
+         "End Time", str(end_time)],
+        ["Total Students", str(len(room_data.get("students", []))),
+         "Total Questions", str(len(questions)),
+         "Status", room_data.get("status", "N/A").upper()],
+    ]
+
+    info_table = Table(info_data, colWidths=[80, 140, 80, 140, 80, 140])
+    info_table.setStyle(TableStyle([
+        ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
+        ('FONTSIZE', (0, 0), (-1, -1), 9),
+        ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+        ('FONTNAME', (2, 0), (2, -1), 'Helvetica-Bold'),
+        ('FONTNAME', (4, 0), (4, -1), 'Helvetica-Bold'),
+        ('TEXTCOLOR', (0, 0), (0, -1), colors.HexColor("#333333")),
+        ('TEXTCOLOR', (2, 0), (2, -1), colors.HexColor("#333333")),
+        ('TEXTCOLOR', (4, 0), (4, -1), colors.HexColor("#333333")),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+        ('GRID', (0, 0), (-1, -1), 0.5, colors.HexColor("#cccccc")),
+        ('BACKGROUND', (0, 0), (0, -1), colors.HexColor("#f0f0f0")),
+        ('BACKGROUND', (2, 0), (2, -1), colors.HexColor("#f0f0f0")),
+        ('BACKGROUND', (4, 0), (4, -1), colors.HexColor("#f0f0f0")),
+        ('TOPPADDING', (0, 0), (-1, -1), 4),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+        ('LEFTPADDING', (0, 0), (-1, -1), 6),
+    ]))
+    elements.append(info_table)
+    elements.append(Spacer(1, 12))
+    elements.append(HRFlowable(width="100%", thickness=1, color=colors.HexColor("#16213e")))
+    elements.append(Spacer(1, 8))
+
+    # ============================
+    # SCORES TABLE
+    # ============================
+    elements.append(Paragraph("📊 Student Scores & Violations", heading_style))
+    elements.append(Spacer(1, 4))
+
+    # Build header row
+    q_headers = []
+    for i, q in enumerate(questions):
+        q_text = q.get("question_text", f"Q{i+1}")
+        # Truncate long question text
+        if len(q_text) > 25:
+            q_text = q_text[:22] + "..."
+        q_headers.append(f"Q{i+1}")
+
+    header_row = ["#", "Student Name"] + q_headers + ["Total Score", "Percentage", "Violations", "Grade"]
+
+    # Build data rows
+    table_data = [header_row]
+    
+    for idx, student in enumerate(scores_data):
+        row = [
+            str(idx + 1),
+            student.get("student_name", "Unknown"),
+        ]
+
+        # Per-question scores
+        for q_score in student.get("questions", []):
+            score = q_score.get("score", 0)
+            max_s = q_score.get("max_score", 100)
+            status = q_score.get("status", "not_attempted")
+            
+            if status == "accepted":
+                cell = f"{score:.0f}/{max_s:.0f} ✓"
+            elif status == "attempted":
+                cell = f"{score:.0f}/{max_s:.0f}"
+            else:
+                cell = "—"
+            row.append(cell)
+
+        # Total score
+        total = student.get("total_score", 0)
+        max_total = student.get("max_total", 0)
+        percentage = (total / max_total * 100) if max_total > 0 else 0
+
+        row.append(f"{total:.0f}/{max_total:.0f}")
+        row.append(f"{percentage:.1f}%")
+
+        # Violations
+        red_flags = student.get("red_flags", 0)
+        flag_text = f"🚩 {red_flags}" if red_flags > 0 else "✅ 0"
+        row.append(flag_text)
+
+        # Grade
+        if percentage >= 90:
+            grade = "A+"
+        elif percentage >= 80:
+            grade = "A"
+        elif percentage >= 70:
+            grade = "B"
+        elif percentage >= 60:
+            grade = "C"
+        elif percentage >= 50:
+            grade = "D"
+        else:
+            grade = "F"
+        
+        # Flag if violations exist
+        if red_flags >= 5:
+            grade += " ⚠"
+        
+        row.append(grade)
+        table_data.append(row)
+
+    # Calculate column widths dynamically
+    num_questions = len(questions)
+    q_col_width = max(40, min(60, (500 - 200) // max(num_questions, 1)))
+    col_widths = [25, 120] + [q_col_width] * num_questions + [70, 60, 60, 45]
+
+    scores_table = Table(table_data, colWidths=col_widths, repeatRows=1)
+    
+    # Style the table
+    table_style_cmds = [
+        # Header
+        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+        ('FONTSIZE', (0, 0), (-1, 0), 8),
+        ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor("#16213e")),
+        ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
+        ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
+        
+        # Body
+        ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
+        ('FONTSIZE', (0, 1), (-1, -1), 8),
+        ('ALIGN', (0, 1), (0, -1), 'CENTER'),
+        ('ALIGN', (2, 1), (-1, -1), 'CENTER'),
+        ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+        
+        # Grid
+        ('GRID', (0, 0), (-1, -1), 0.5, colors.HexColor("#cccccc")),
+        ('TOPPADDING', (0, 0), (-1, -1), 4),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+        ('LEFTPADDING', (0, 0), (-1, -1), 3),
+        ('RIGHTPADDING', (0, 0), (-1, -1), 3),
+    ]
+
+    # Alternating row colors
+    for i in range(1, len(table_data)):
+        if i % 2 == 0:
+            table_style_cmds.append(
+                ('BACKGROUND', (0, i), (-1, i), colors.HexColor("#f8f9fa"))
+            )
+
+    # Highlight violation cells
+    for i in range(1, len(table_data)):
+        student = scores_data[i - 1]
+        red_flags = student.get("red_flags", 0)
+        violations_col = len(header_row) - 2  # violations column index
+        if red_flags > 0:
+            table_style_cmds.append(
+                ('TEXTCOLOR', (violations_col, i), (violations_col, i), colors.red)
+            )
+        if red_flags >= 5:
+            table_style_cmds.append(
+                ('BACKGROUND', (violations_col, i), (violations_col, i), colors.HexColor("#ffe0e0"))
+            )
+
+    scores_table.setStyle(TableStyle(table_style_cmds))
+    elements.append(scores_table)
+    elements.append(Spacer(1, 12))
+
+    # ============================
+    # SUMMARY STATISTICS
+    # ============================
+    elements.append(HRFlowable(width="100%", thickness=0.5, color=colors.HexColor("#cccccc")))
+    elements.append(Spacer(1, 6))
+    elements.append(Paragraph("📈 Summary Statistics", heading_style))
+
+    if scores_data:
+        all_percentages = []
+        for s in scores_data:
+            mt = s.get("max_total", 0)
+            ts = s.get("total_score", 0)
+            pct = (ts / mt * 100) if mt > 0 else 0
+            all_percentages.append(pct)
+
+        avg_score = sum(all_percentages) / len(all_percentages)
+        max_score = max(all_percentages)
+        min_score = min(all_percentages)
+        passed = sum(1 for p in all_percentages if p >= 50)
+        failed = len(all_percentages) - passed
+        total_violations = sum(s.get("red_flags", 0) for s in scores_data)
+        students_with_violations = sum(1 for s in scores_data if s.get("red_flags", 0) > 0)
+
+        summary_data = [
+            ["Metric", "Value"],
+            ["Average Score", f"{avg_score:.1f}%"],
+            ["Highest Score", f"{max_score:.1f}%"],
+            ["Lowest Score", f"{min_score:.1f}%"],
+            ["Passed (≥50%)", f"{passed}/{len(scores_data)}"],
+            ["Failed (<50%)", f"{failed}/{len(scores_data)}"],
+            ["Total Violations", str(total_violations)],
+            ["Students with Violations", f"{students_with_violations}/{len(scores_data)}"],
+        ]
+
+        summary_table = Table(summary_data, colWidths=[180, 120])
+        summary_table.setStyle(TableStyle([
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, -1), 9),
+            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor("#16213e")),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
+            ('FONTNAME', (0, 1), (0, -1), 'Helvetica-Bold'),
+            ('ALIGN', (1, 0), (1, -1), 'CENTER'),
+            ('GRID', (0, 0), (-1, -1), 0.5, colors.HexColor("#cccccc")),
+            ('TOPPADDING', (0, 0), (-1, -1), 4),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+            ('LEFTPADDING', (0, 0), (-1, -1), 6),
+        ]))
+        elements.append(summary_table)
+    else:
+        elements.append(Paragraph("No student data available.", styles['Normal']))
+
+    # ============================
+    # QUESTION DETAILS
+    # ============================
+    elements.append(Spacer(1, 12))
+    elements.append(HRFlowable(width="100%", thickness=0.5, color=colors.HexColor("#cccccc")))
+    elements.append(Paragraph("📝 Questions", heading_style))
+
+    for i, q in enumerate(questions):
+        q_text = q.get("question_text", "N/A")
+        tc_count = len(q.get("test_cases", []))
+        elements.append(Paragraph(
+            f"<b>Q{i+1}:</b> {q_text} <i>({tc_count} test cases)</i>",
+            styles['Normal']
+        ))
+        elements.append(Spacer(1, 3))
+
+    # ============================
+    # VIOLATION DETAILS
+    # ============================
+    flagged_students = [s for s in scores_data if s.get("red_flags", 0) > 0]
+    if flagged_students:
+        elements.append(Spacer(1, 12))
+        elements.append(HRFlowable(width="100%", thickness=0.5, color=colors.HexColor("#cccccc")))
+        elements.append(Paragraph("🚩 Violation Report", heading_style))
+        elements.append(Paragraph(
+            "The following students had security violations during the exam:",
+            styles['Normal']
+        ))
+        elements.append(Spacer(1, 4))
+
+        violation_data = [["#", "Student Name", "Violations", "Severity", "Recommendation"]]
+        for idx, s in enumerate(flagged_students):
+            flags = s.get("red_flags", 0)
+            if flags >= 10:
+                severity = "CRITICAL"
+                recommendation = "Disqualify / Manual Review"
+            elif flags >= 5:
+                severity = "HIGH"
+                recommendation = "Flag for Review"
+            elif flags >= 3:
+                severity = "MEDIUM"
+                recommendation = "Warning Issued"
+            else:
+                severity = "LOW"
+                recommendation = "Monitor"
+            
+            violation_data.append([
+                str(idx + 1),
+                s.get("student_name", "Unknown"),
+                str(flags),
+                severity,
+                recommendation
+            ])
+
+        viol_table = Table(violation_data, colWidths=[25, 150, 70, 80, 160])
+        viol_table.setStyle(TableStyle([
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, -1), 9),
+            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor("#8b0000")),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('ALIGN', (1, 1), (1, -1), 'LEFT'),
+            ('ALIGN', (4, 1), (4, -1), 'LEFT'),
+            ('GRID', (0, 0), (-1, -1), 0.5, colors.HexColor("#cccccc")),
+            ('TOPPADDING', (0, 0), (-1, -1), 4),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+        ]))
+
+        # Color severity cells
+        for i in range(1, len(violation_data)):
+            severity = violation_data[i][3]
+            if severity == "CRITICAL":
+                viol_table.setStyle(TableStyle([
+                    ('BACKGROUND', (3, i), (3, i), colors.HexColor("#ffcccc")),
+                    ('TEXTCOLOR', (3, i), (3, i), colors.red),
+                ]))
+            elif severity == "HIGH":
+                viol_table.setStyle(TableStyle([
+                    ('BACKGROUND', (3, i), (3, i), colors.HexColor("#ffe0cc")),
+                    ('TEXTCOLOR', (3, i), (3, i), colors.HexColor("#cc6600")),
+                ]))
+
+        elements.append(viol_table)
+
+    # ============================
+    # FOOTER
+    # ============================
+    elements.append(Spacer(1, 20))
+    elements.append(HRFlowable(width="100%", thickness=0.5, color=colors.HexColor("#cccccc")))
+    elements.append(Spacer(1, 4))
+    elements.append(Paragraph(
+        f"Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} | Online Exam IDE | Confidential",
+        small_style
+    ))
+
+    # Build PDF
+    doc.build(elements)
+    pdf_bytes = buffer.getvalue()
+    buffer.close()
+    return pdf_bytes

backend/requirements.txt

@@ -0,0 +1,13 @@
+fastapi
+uvicorn
+websockets
+python-dotenv
+pydantic
+sqlalchemy
+aiofiles
+requests
+python-multipart
+motor
+dnspython
+certifi
+reportlab

backend/room_manager.py

@@ -0,0 +1,89 @@
+from database import db
+from models import Room, Question, Session, Worksheet
+from typing import List, Optional
+import uuid
+
+
+class RoomManager:
+    """Room and exam management logic"""
+
+    @staticmethod
+    def create_exam_room(room_name: str, teacher_id: str, teacher_name: str, max_students: int = 50) -> Room:
+        """Create a new exam room"""
+        room = Room(
+            room_name=room_name,
+            teacher_id=teacher_id,
+            teacher_name=teacher_name,
+            max_students=max_students
+        )
+        return db.create_room(room)
+
+    @staticmethod
+    def get_room(room_id: str) -> Optional[Room]:
+        """Get room by ID"""
+        return db.get_room(room_id)
+
+    @staticmethod
+    def join_room(room_id: str, student_id: str) -> bool:
+        """Add student to room"""
+        return db.add_student_to_room(room_id, student_id)
+
+    @staticmethod
+    def create_question(room_id: str, title: str, description: str, allowed_languages: List[str] = None) -> Question:
+        """Create a question in a room"""
+        if allowed_languages is None:
+            allowed_languages = ["python", "javascript", "java", "cpp"]
+
+        question = Question(
+            room_id=room_id,
+            title=title,
+            description=description,
+            allowed_languages=allowed_languages
+        )
+        return db.create_question(question)
+
+    @staticmethod
+    def get_room_questions(room_id: str) -> List[Question]:
+        """Get all questions in a room"""
+        return db.get_room_questions(room_id)
+
+    @staticmethod
+    def get_student_worksheet(room_id: str, student_id: str, question_id: str) -> Worksheet:
+        """Get or create worksheet for student"""
+        return db.get_or_create_worksheet(room_id, student_id, question_id)
+
+    @staticmethod
+    def save_worksheet(worksheet: Worksheet):
+        """Save worksheet code"""
+        db.update_worksheet(worksheet)
+
+    @staticmethod
+    def get_room_students(room_id: str) -> List[str]:
+        """Get students in room"""
+        room = db.get_room(room_id)
+        return room.students if room else []
+
+    @staticmethod
+    def get_student_progress(room_id: str, student_id: str) -> dict:
+        """Get student's progress in all questions"""
+        questions = db.get_room_questions(room_id)
+        worksheets = db.get_student_worksheets(room_id, student_id)
+
+        ws_map = {ws.question_id: ws for ws in worksheets}
+
+        progress = {
+            "total_questions": len(questions),
+            "questions": []
+        }
+
+        for q in questions:
+            ws = ws_map.get(q.question_id)
+            progress["questions"].append({
+                "question_id": q.question_id,
+                "title": q.title,
+                "status": ws.status if ws else "not_started",
+                "submissions": ws.submission_count if ws else 0,
+                "last_edited": ws.last_edited_timestamp if ws else None
+            })
+
+        return progress

docker-compose.yml

@@ -0,0 +1,57 @@
+# ============================================================================
+# Online Exam IDE — Docker Compose
+# ============================================================================
+# 
+# IMPORTANT (MongoDB Atlas IP Whitelisting):
+#   MongoDB Atlas requires your IP address to be whitelisted before allowing
+#   connections. When running in Docker (locally or on a server), you must:
+#   
+#   1. Go to MongoDB Atlas → Network Access → Add IP Address
+#   2. Either add your server/host IP, OR use 0.0.0.0/0 to allow all IPs
+#      (suitable for development; restrict in production)
+#   3. The backend container uses certifi for TLS and dnspython for SRV
+#      record resolution, so Atlas SRV connection strings work correctly.
+#
+# Usage:
+#   docker-compose up --build        # Build and start
+#   docker-compose up -d             # Detached mode
+#   docker-compose down              # Stop and remove
+#   docker-compose logs -f backend   # Follow backend logs
+#
+# Access:
+#   Frontend:  http://localhost:8501
+#   Backend:   http://localhost:8000
+#   API Docs:  http://localhost:8000/docs
+# ============================================================================
+
+services:
+  backend:
+    build:
+      context: .
+      dockerfile: Dockerfile.backend
+    container_name: exam-ide-backend
+    ports:
+      - "8000:8000"
+    env_file:
+      - backend/.env
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+
+  frontend:
+    build:
+      context: .
+      dockerfile: Dockerfile.frontend
+    container_name: exam-ide-frontend
+    ports:
+      - "8501:8501"
+    environment:
+      - BACKEND_URL=http://backend:8000
+    depends_on:
+      backend:
+        condition: service_healthy
+    restart: unless-stopped

frontend/.streamlit/config.toml

@@ -0,0 +1,14 @@
+[theme]
+primaryColor = "#0066cc"
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#f0f2f6"
+textColor = "#262730"
+font = "sans serif"
+
+[client]
+showErrorDetails = true
+toolbarMode = "minimal"
+
+[server]
+maxUploadSize = 200
+enableXsrfProtection = true

frontend/app.py

@@ -0,0 +1,1274 @@
+import streamlit as st
+import streamlit.components.v1 as components
+import requests
+import json
+import os
+from datetime import datetime
+import time
+
+# ============================================================================
+# STEP 4: CODE TEMPLATES CONFIGURATION
+# ============================================================================
+
+# Python Templates (8 templates)
+PYTHON_TEMPLATES = {
+    "Simple Function": '''def greet(name):
+    """A simple greeting function"""
+    print(f"Hello, {name}!")
+
+greet("World")''',
+
+    " Function with Math": '''def add_numbers(a, b):
+    """Add two numbers and return result"""
+    result = a + b
+    print(f"{a} + {b} = {result}")
+    return result
+
+add_numbers(5, 10)''',
+
+    " For Loop": '''fruits = ["apple", "banana", "orange"]
+
+for fruit in fruits:
+    print(f"I like {fruit}")''',
+
+    " If-Else": '''age = 20
+
+if age >= 18:
+    print("You are an adult")
+else:
+    print("You are a minor")''',
+
+    " List Operations": '''numbers = [1, 2, 3, 4, 5]
+
+# Add element
+numbers.append(6)
+
+# Remove element
+numbers.remove(3)
+
+# Print all
+for num in numbers:
+    print(num)''',
+
+    " While Loop": '''count = 0
+
+while count < 5:
+    print(f"Count: {count}")
+    count += 1''',
+
+    " List Comprehension": '''# Create a list of squares
+squares = [x**2 for x in range(5)]
+print(squares)
+
+# Filter even numbers
+numbers = [x for x in range(10) if x % 2 == 0]
+print(numbers)''',
+
+    "Dictionary": '''student = {
+    "name": "John",
+    "age": 20,
+    "grade": "A"
+}
+
+print(student["name"])
+print(student["grade"])'''
+}
+
+# JavaScript Templates (5 templates)
+JAVASCRIPT_TEMPLATES = {
+    " Simple Function": '''function greet(name) {
+  console.log(`Hello, ${name}!`);
+}
+
+greet("World");''',
+
+    " Function with Math": '''function addNumbers(a, b) {
+  let result = a + b;
+  console.log(`${a} + ${b} = ${result}`);
+  return result;
+}
+
+addNumbers(5, 10);''',
+
+    " For Loop": '''let fruits = ["apple", "banana", "orange"];
+
+for (let i = 0; i < fruits.length; i++) {
+  console.log(`I like ${fruits[i]}`);
+}''',
+
+    " If-Else": '''let age = 20;
+
+if (age >= 18) {
+  console.log("You are an adult");
+} else {
+  console.log("You are a minor");
+}''',
+
+    " Array Operations": '''let numbers = [1, 2, 3, 4, 5];
+
+// Add element
+numbers.push(6);
+
+// Remove element
+numbers.splice(2, 1);
+
+// Print all
+for (let num of numbers) {
+  console.log(num);
+}'''
+}
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+BACKEND_URL = os.getenv("BACKEND_URL", "http://localhost:8000")
+
+
+# ============================================================================
+# API CLIENT
+# ============================================================================
+
+class APIClient:
+    def __init__(self, base_url):
+        self.base_url = base_url
+        self.session_id = None
+        self.role = None
+
+    def create_room(self, room_name: str, teacher_name: str, language: str = "Python", duration: int = 30,
+                    start_time: str = None):
+        """Create a new exam room"""
+        payload = {
+            "room_name": room_name,
+            "teacher_name": teacher_name,
+            "language": language,
+            "duration": duration,
+            "session_id": self.session_id
+        }
+        if start_time:
+            payload["start_time"] = start_time
+
+        response = requests.post(
+            f"{self.base_url}/api/rooms/create",
+            json=payload
+        )
+        return response.json()
+
+    def join_room(self, room_code: str, student_name: str):
+        """Join an existing exam room"""
+        response = requests.post(
+            f"{self.base_url}/api/rooms/{room_code}/join",
+            json={
+                "student_name": student_name,
+                "session_id": self.session_id
+            }
+        )
+        return response.json()
+
+    def get_room(self, room_id: str):
+        """Get room details"""
+        response = requests.get(f"{self.base_url}/api/rooms/{room_id}")
+        return response.json()
+
+    def create_question(self, room_id: str, question_text: str, language: str, test_cases: list = None):
+        """Create a question in the room with optional test cases"""
+        payload = {
+            "question_text": question_text,
+            "language": language,
+        }
+        if test_cases:
+            payload["test_cases"] = test_cases
+        
+        response = requests.post(
+            f"{self.base_url}/api/rooms/{room_id}/questions",
+            json=payload
+        )
+        return response.json()
+
+    def get_questions(self, room_id: str):
+        """Get all questions in a room (hidden test cases filtered out)"""
+        response = requests.get(f"{self.base_url}/api/rooms/{room_id}/questions")
+        return response.json()
+
+    def get_questions_full(self, room_id: str):
+        """Get all questions including hidden test cases (teacher use)"""
+        response = requests.get(f"{self.base_url}/api/rooms/{room_id}/questions/full")
+        return response.json()
+
+    def get_worksheet(self, room_id: str, student_id: str, question_id: str):
+        """Get student's worksheet"""
+        response = requests.get(
+            f"{self.base_url}/api/worksheets/{room_id}/{student_id}/{question_id}"
+        )
+        return response.json()
+
+    def save_code(self, worksheet_id: str, code: str):
+        """Save student code"""
+        response = requests.post(
+            f"{self.base_url}/api/worksheets/{worksheet_id}/save",
+            json={"code": code}
+        )
+        return response.json()
+
+    def execute_code(self, code: str, language: str):
+        """Execute code and get output"""
+        response = requests.post(
+            f"{self.base_url}/api/execute",
+            json={
+                "code": code,
+                "language": language
+            }
+        )
+        return response.json()
+
+    def submit_solution(self, code: str, language: str, room_id: str, question_id: str, student_id: str):
+        """Submit solution for auto-judging against all test cases"""
+        response = requests.post(
+            f"{self.base_url}/api/submit",
+            json={
+                "code": code,
+                "language": language,
+                "room_id": room_id,
+                "question_id": question_id,
+                "student_id": student_id
+            }
+        )
+        return response.json()
+
+    def get_student_codes(self, room_id: str):
+        """Get all student codes with NAMES in the room (Live Monitor)"""
+        response = requests.get(f"{self.base_url}/api/rooms/{room_id}/student-codes")
+        return response.json()
+
+    def get_scores(self, room_id: str):
+        """Get aggregated scores for all students"""
+        response = requests.get(f"{self.base_url}/api/rooms/{room_id}/scores")
+        return response.json()
+
+    def download_report(self, room_id: str):
+        """Download PDF exam report. Returns raw bytes."""
+        response = requests.get(f"{self.base_url}/api/rooms/{room_id}/report")
+        if response.status_code == 200:
+            return response.content
+        return None
+
+    def report_violation(self, room_id: str, student_id: str):
+        """Report a security violation"""
+        try:
+            requests.post(
+                f"{self.base_url}/api/rooms/{room_id}/report_violation",
+                json={"student_id": student_id}
+            )
+        except:
+            pass
+
+
+# ============================================================================
+# PAGE FUNCTIONS
+# ============================================================================
+
+def teacher_page(api_client):
+    """Teacher dashboard"""
+    st.title("📋 Teacher Dashboard")
+
+    # Sidebar for room creation
+    with st.sidebar:
+        st.header("Create Exam Room")
+        room_name = st.text_input("Exam/Assignment Name")
+        teacher_name = st.text_input("Your Name")
+        language = st.selectbox("Programming Language", ["Python", "JavaScript", "Java", "C++"])
+
+        # Duration and Start Time
+        duration = st.slider("Duration (minutes)", 5, 180, 60, step=5)
+
+        start_option = st.radio("Start Time", ["Start Now", "Schedule for Later"])
+        start_time_iso = None
+
+        if start_option == "Schedule for Later":
+            exam_date = st.date_input("Exam Date", min_value=datetime.now().date())
+            exam_time = st.time_input("Exam Time", value=datetime.now().time())
+            if exam_date and exam_time:
+                start_dt = datetime.combine(exam_date, exam_time)
+                start_time_iso = start_dt.isoformat()
+        else:
+            start_time_iso = datetime.now().isoformat()
+
+        if st.button("Create Exam Room", key="create_room"):
+            if room_name and teacher_name:
+                result = api_client.create_room(room_name, teacher_name, language, duration, start_time_iso)
+                if "room_id" in result:
+                    st.session_state.room_id = result["room_id"]
+                    st.session_state.room_code = result["room_code"]
+                    st.success(f"Room created! Code: {result['room_code']}")
+                else:
+                    st.error(f"Error: {result.get('detail', 'Unknown error')}")
+
+    # Display current room
+    if "room_id" in st.session_state:
+        col1, col2 = st.columns(2)
+        with col1:
+            st.info(f"🔑 Room Code: `{st.session_state.room_code}`")
+        with col2:
+            st.info(f"🆔 Room ID: `{st.session_state.room_id}`")
+
+        # ================================================================
+        # CREATE QUESTION WITH TEST CASES
+        # ================================================================
+        with st.expander("📝 Create New Question", expanded=True):
+            question_text = st.text_area("Question Text", height=100, 
+                                          placeholder="Write your coding question here...\ne.g., Write a function that reads two integers from stdin and prints their sum.")
+            question_lang = st.selectbox("Language", ["Python", "JavaScript", "Java", "C++"], key="q_lang")
+
+            st.divider()
+            st.subheader("🧪 Test Cases")
+            st.caption("Add example test cases (visible to students) and hidden test cases (used for judging only).")
+
+            # Dynamic test case management using session state
+            if "test_cases_draft" not in st.session_state:
+                st.session_state.test_cases_draft = []
+
+            # Show existing draft test cases
+            cases_to_remove = []
+            for idx, tc in enumerate(st.session_state.test_cases_draft):
+                with st.container():
+                    tc_col1, tc_col2, tc_col3 = st.columns([3, 3, 1])
+                    with tc_col1:
+                        tc["input_data"] = st.text_area(
+                            f"Input (Test Case {idx + 1})",
+                            value=tc.get("input_data", ""),
+                            key=f"tc_input_{idx}",
+                            height=80,
+                            placeholder="e.g., 5 10"
+                        )
+                    with tc_col2:
+                        tc["expected_output"] = st.text_area(
+                            f"Expected Output (Test Case {idx + 1})",
+                            value=tc.get("expected_output", ""),
+                            key=f"tc_output_{idx}",
+                            height=80,
+                            placeholder="e.g., 15"
+                        )
+                    with tc_col3:
+                        tc["is_hidden"] = st.checkbox(
+                            "Hidden?",
+                            value=tc.get("is_hidden", False),
+                            key=f"tc_hidden_{idx}",
+                            help="Hidden test cases are NOT shown to students"
+                        )
+                        if st.button("🗑️", key=f"tc_remove_{idx}"):
+                            cases_to_remove.append(idx)
+
+                    # Visual indicator
+                    badge = "🔒 Hidden" if tc.get("is_hidden") else "👁️ Visible"
+                    st.caption(f"Test Case {idx + 1} — {badge}")
+                    st.divider()
+
+            # Remove marked test cases
+            if cases_to_remove:
+                for idx in sorted(cases_to_remove, reverse=True):
+                    st.session_state.test_cases_draft.pop(idx)
+                st.rerun()
+
+            # Add new test case button
+            col_add1, col_add2 = st.columns(2)
+            with col_add1:
+                if st.button("➕ Add Example Test Case", key="add_example_tc"):
+                    st.session_state.test_cases_draft.append({
+                        "input_data": "",
+                        "expected_output": "",
+                        "is_hidden": False
+                    })
+                    st.rerun()
+            with col_add2:
+                if st.button("➕ Add Hidden Test Case", key="add_hidden_tc"):
+                    st.session_state.test_cases_draft.append({
+                        "input_data": "",
+                        "expected_output": "",
+                        "is_hidden": True
+                    })
+                    st.rerun()
+
+            # Summary
+            example_count = sum(1 for tc in st.session_state.test_cases_draft if not tc.get("is_hidden"))
+            hidden_count = sum(1 for tc in st.session_state.test_cases_draft if tc.get("is_hidden"))
+            st.info(f"📊 **{example_count}** example test case(s) | **{hidden_count}** hidden test case(s)")
+
+            # Submit question
+            if st.button("✅ Add Question", key="add_question"):
+                if question_text:
+                    # Validate test cases
+                    valid_test_cases = [
+                        tc for tc in st.session_state.test_cases_draft
+                        if tc.get("expected_output", "").strip()  # at least expected output must exist
+                    ]
+                    
+                    result = api_client.create_question(
+                        st.session_state.room_id,
+                        question_text,
+                        question_lang,
+                        test_cases=valid_test_cases if valid_test_cases else None
+                    )
+                    
+                    if "question_id" in result:
+                        st.success(f"✅ Question created with {len(valid_test_cases)} test case(s)!")
+                        st.session_state.test_cases_draft = []  # Reset draft
+                        st.rerun()
+                    else:
+                        st.error(f"Error: {result.get('detail', 'Unknown error')}")
+                else:
+                    st.warning("Please enter a question text!")
+
+        # ================================================================
+        # ROOM OVERVIEW
+        # ================================================================
+        try:
+            room = api_client.get_room(st.session_state.room_id)
+            room_status = room.get("status", "active")
+
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Connected Students", len(room.get("students", [])))
+            with col2:
+                st.metric("Questions", len(room.get("questions", [])))
+            with col3:
+                if room_status == "expired":
+                    st.metric("Status", "🔴 Expired")
+                else:
+                    st.metric("Status", "✅ Active")
+
+            # Expired room banner
+            if room_status == "expired":
+                st.warning("⏰ **This exam has ended.** Room code is revoked — no new students can join or submit.")
+
+            # Questions list with test case details
+            if room.get("questions"):
+                st.subheader("📋 Questions")
+                for i, q in enumerate(room["questions"]):
+                    tc_list = q.get("test_cases", [])
+                    example_tc = [tc for tc in tc_list if not tc.get("is_hidden")]
+                    hidden_tc = [tc for tc in tc_list if tc.get("is_hidden")]
+                    
+                    with st.expander(f"Q{i+1}: {q.get('question_text', 'N/A')[:80]}..."):
+                        st.write(f"**{q.get('question_text', 'N/A')}**")
+                        st.write(f"Language: `{q.get('language', 'Python')}`")
+                        st.write(f"Test Cases: **{len(example_tc)}** example, **{len(hidden_tc)}** hidden")
+                        
+                        if example_tc:
+                            st.write("**👁️ Example Test Cases:**")
+                            for j, tc in enumerate(example_tc):
+                                st.markdown(f"**Case {j+1}:** Input: `{tc.get('input_data', '')}` → Expected: `{tc.get('expected_output', '')}`")
+                        
+                        if hidden_tc:
+                            st.write("**🔒 Hidden Test Cases:**")
+                            for j, tc in enumerate(hidden_tc):
+                                st.markdown(f"**Case {j+1}:** Input: `{tc.get('input_data', '')}` → Expected: `{tc.get('expected_output', '')}`")
+
+            # ================================================================
+            # SCORES & REPORT SECTION
+            # ================================================================
+            st.divider()
+            st.subheader("📊 Student Scores")
+
+            try:
+                scores_response = api_client.get_scores(st.session_state.room_id)
+                scores_list = scores_response.get("scores", [])
+
+                if scores_list:
+                    # Build scoreboard table
+                    q_list = room.get("questions", [])
+                    scoreboard_data = []
+                    for rank, s in enumerate(scores_list, 1):
+                        row = {
+                            "Rank": rank,
+                            "Student": s.get("student_name", "Unknown"),
+                        }
+                        for qi, qs in enumerate(s.get("questions", [])):
+                            score = qs.get("score", 0)
+                            max_s = qs.get("max_score", 100)
+                            status = qs.get("status", "not_attempted")
+                            icon = "✅" if status == "accepted" else ("📝" if status == "attempted" else "—")
+                            row[f"Q{qi+1}"] = f"{icon} {score:.0f}/{max_s:.0f}"
+                        
+                        total = s.get("total_score", 0)
+                        max_total = s.get("max_total", 0)
+                        pct = (total / max_total * 100) if max_total > 0 else 0
+                        row["Total"] = f"{total:.0f}/{max_total:.0f}"
+                        row["Percentage"] = f"{pct:.1f}%"
+                        row["Violations"] = f"🚩 {s.get('red_flags', 0)}" if s.get('red_flags', 0) > 0 else "✅ 0"
+                        scoreboard_data.append(row)
+
+                    st.dataframe(scoreboard_data, use_container_width=True, hide_index=True)
+                else:
+                    st.info("No submissions yet.")
+            except Exception as e:
+                st.error(f"Error loading scores: {e}")
+
+            # Download report button
+            st.divider()
+            st.subheader("📄 Generate PDF Report")
+            st.caption("Download a comprehensive PDF report with scores, violations, and exam statistics.")
+            
+            if st.button("📥 Download Exam Report (PDF)", key="download_report", use_container_width=True):
+                with st.spinner("Generating PDF report..."):
+                    pdf_bytes = api_client.download_report(st.session_state.room_id)
+                if pdf_bytes:
+                    st.download_button(
+                        label="💾 Save Report",
+                        data=pdf_bytes,
+                        file_name=f"exam_report_{room.get('room_name', 'report').replace(' ', '_')}.pdf",
+                        mime="application/pdf",
+                        key="save_report_btn"
+                    )
+                    st.success("✅ Report generated! Click 'Save Report' above to download.")
+                else:
+                    st.error("Failed to generate report.")
+
+        except Exception as e:
+            st.error(f"Error loading room: {e}")
+
+        # ====================================================================
+        # LIVE CODE MONITOR
+        # ====================================================================
+
+        st.divider()
+        st.subheader("👁️ Live Student Monitor")
+
+        col1, col2, col3 = st.columns([2, 1, 1])
+        with col1:
+            st.subheader("📺 Live Code Monitor")
+
+        # CLASSROOM STATUS TABLE
+        try:
+            detailed_data = api_client.get_student_codes(st.session_state.room_id)
+            student_codes_map = detailed_data.get("student_codes", {})
+            student_ids_list = room.get("students", [])
+
+            if student_ids_list:
+                status_data = []
+                for sid in student_ids_list:
+                    s_info = student_codes_map.get(sid, {})
+                    nm = room.get("student_names", {}).get(sid, "Unknown")
+                    flgs = s_info.get("red_flags", 0)
+                    sts = s_info.get("status", "idle")
+                    last_up = s_info.get("last_updated", "")
+                    if last_up:
+                        last_up = last_up.split("T")[1][:8]
+
+                    status_icon = "🟩" if sts == "working" else ("✅" if sts == "accepted" else "🔴")
+                    flag_icon = "🚩" if flgs > 0 else "✅"
+
+                    status_data.append({
+                        "Student Name": nm,
+                        "Status": f"{status_icon} {sts}",
+                        "Violations": f"{flag_icon} {flgs}",
+                        "Last Active": last_up,
+                        "ID": sid
+                    })
+
+                st.info("**Classroom Overview**")
+                st.dataframe(
+                    status_data,
+                    column_config={
+                        "Student Name": st.column_config.TextColumn("Student Name", width="medium"),
+                        "Status": st.column_config.TextColumn("Status", width="small"),
+                        "Violations": st.column_config.TextColumn("Violations (Red Flags)", width="small"),
+                        "Last Active": st.column_config.TextColumn("Last Active", width="small"),
+                        "ID": st.column_config.TextColumn("Student ID", width="small")
+                    },
+                    use_container_width=True,
+                    hide_index=True
+                )
+            else:
+                st.warning("Waiting for students to join...")
+
+        except Exception as ex:
+            st.error(f"Error loading classroom status: {ex}")
+
+        col1, col2, col3 = st.columns([2, 1, 1])
+        with col1:
+            # Get student names from room
+            room = api_client.get_room(st.session_state.room_id)
+            student_names_map = room.get("student_names", {})
+            student_ids = room.get("students", [])
+
+            student_display = []
+
+            try:
+                detailed_data = api_client.get_student_codes(st.session_state.room_id)
+                student_codes_map = detailed_data.get("student_codes", {})
+            except:
+                student_codes_map = {}
+
+            for sid in student_ids:
+                name = student_names_map.get(sid, f"Student ({sid[:8]}...)")
+                s_data = student_codes_map.get(sid, {})
+                flags = s_data.get("red_flags", 0)
+
+                flag_str = f" ({flags})" if flags > 0 else ""
+                display_name = f"{name}{flag_str}"
+
+                student_display.append({"id": sid, "name": display_name})
+
+            if student_display:
+                selected_idx = st.selectbox(
+                    "Select Student to Monitor",
+                    range(len(student_display)),
+                    format_func=lambda i: student_display[i]["name"],
+                    key="monitor_student"
+                )
+                selected_student_id = student_display[selected_idx]["id"]
+                selected_student_name = student_display[selected_idx]["name"]
+            else:
+                st.info("No students connected yet")
+                selected_student_id = None
+                selected_student_name = None
+
+        with col2:
+            auto_refresh = st.checkbox("☑️ Auto Refresh", value=True, key="auto_refresh")
+        with col3:
+            refresh_interval = st.slider("Interval (sec)", 1, 10, 2, key="refresh_interval")
+
+        # Live code display area
+        if selected_student_id:
+            st.write(f"**Monitoring:** {selected_student_name}")
+
+            code_placeholder = st.empty()
+            status_placeholder = st.empty()
+
+            while auto_refresh:
+                try:
+                    student_codes_response = api_client.get_student_codes(st.session_state.room_id)
+
+                    if student_codes_response and "student_codes" in student_codes_response:
+                        student_data = student_codes_response["student_codes"].get(selected_student_id, {})
+
+                        code = student_data.get("code", "")
+                        student_name = student_data.get("student_name", "Unknown")
+                        language = student_data.get("language", "python").lower()
+                        status = student_data.get("status", "idle")
+                        last_updated = student_data.get("last_updated", "")
+                        red_flags = student_data.get("red_flags", 0)
+
+                        with code_placeholder.container():
+                            if red_flags > 0:
+                                st.error(
+                                    f"🔴 **VIOLATION ALERT**: This student has left the exam window {red_flags} times!")
+
+                            if code.strip():
+                                st.code(code, language=language)
+                            else:
+                                st.info("⌛ Waiting for student to start coding...")
+
+                        with status_placeholder.container():
+                            col1, col2, col3 = st.columns(3)
+
+                            if status == "idle":
+                                status_icon = ""
+                            elif status == "working":
+                                status_icon = "🟩"
+                            elif status == "accepted":
+                                status_icon = "✅"
+                            else:
+                                status_icon = "🔴"
+
+                            with col1:
+                                st.write(f"**Status:** {status_icon} {status.upper()}")
+                            with col2:
+                                st.write(f"**Language:** {language.upper()}")
+
+                            if last_updated:
+                                time_str = last_updated.split('T')[1][:8] if 'T' in last_updated else last_updated
+                                with col3:
+                                    st.write(f"**Updated:** {time_str}")
+
+                    time.sleep(refresh_interval)
+                    st.rerun()
+
+                except Exception as e:
+                    st.error(f"Error fetching code: {e}")
+                    break
+    else:
+        st.info("📌 Create a room using the sidebar to get started!")
+
+
+def student_page(api_client):
+    """Student workspace"""
+    st.title("💻 Student Workspace")
+
+    # Sidebar for room joining
+    with st.sidebar:
+        st.header("Join Exam Room")
+        room_code = st.text_input("Room Code")
+        student_name = st.text_input("Your Name")
+
+        if st.button("Join Room", key="join_room"):
+            if room_code and student_name:
+                try:
+                    result = api_client.join_room(room_code, student_name)
+                    if "room_id" in result:
+                        st.session_state.room_id = result["room_id"]
+                        st.session_state.student_id = result["student_id"]
+                        st.session_state.student_name = student_name
+                        st.success("Room joined!")
+                    else:
+                        st.error(f"Error: {result.get('detail', 'Unknown error')}")
+                except requests.exceptions.HTTPError as e:
+                    if e.response and e.response.status_code == 403:
+                        st.error("🔴 This exam has ended. The room code is no longer valid.")
+                    else:
+                        st.error(f"Error: {e}")
+                except Exception as e:
+                    # The API might return 403 as JSON
+                    st.error(f"Error: {e}")
+
+    if "room_id" in st.session_state:
+        st.info(f"✅ Connected as **{st.session_state.student_name}**")
+
+        # Get room details to check timing
+        try:
+            room = api_client.get_room(st.session_state.room_id)
+            start_time_str = room.get("start_time")
+            end_time_str = room.get("end_time")
+
+            now = datetime.now()
+            start_time = datetime.fromisoformat(start_time_str) if start_time_str else None
+            end_time = datetime.fromisoformat(end_time_str) if end_time_str else None
+
+            if start_time and now < start_time:
+                st.warning(f"Exam has not started yet. Start time: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+                time_diff = start_time - now
+                st.metric("Time until start", str(time_diff).split('.')[0])
+                if st.button("Refresh Status"):
+                    st.rerun()
+                return
+
+            if end_time and now > end_time:
+                st.error("Exam has ended. You can no longer submit code.")
+                st.metric("Exam Ended", end_time.strftime('%Y-%m-%d %H:%M:%S'))
+                return
+
+            # EXAM IN PROGRESS
+            if end_time:
+                time_left = end_time - now
+
+                st_room_id = st.session_state.room_id
+                st_student_id = st.session_state.student_id
+
+                security_script = f"""
+                <script>
+                const targetWindow = window.parent;
+                const targetDocument = targetWindow.document;
+
+                function reportViolation() {{
+                    fetch("{BACKEND_URL}/api/rooms/{st_room_id}/report_violation", {{
+                        method: "POST",
+                        headers: {{
+                            "Content-Type": "application/json"
+                        }},
+                        body: JSON.stringify({{
+                            "student_id": "{st_student_id}"
+                        }})
+                    }}).catch(e => console.error(e));
+                }}
+
+                function requestFullScreen() {{
+                    var elem = targetDocument.documentElement;
+                    if (elem.requestFullscreen) {{
+                        elem.requestFullscreen().catch(err => {{
+                            console.log("Error attempting to enable full-screen mode: " + err.message);
+                        }});
+                    }} else if (elem.webkitRequestFullscreen) {{
+                        elem.webkitRequestFullscreen();
+                    }} else if (elem.msRequestFullscreen) {{
+                        elem.msRequestFullscreen();
+                    }}
+                }}
+
+                function showOverlay(message, isRed = true) {{
+                    var overlay = targetDocument.getElementById('security-overlay');
+                    if (!overlay) {{
+                        overlay = targetDocument.createElement('div');
+                        overlay.id = 'security-overlay';
+                        overlay.style.position = 'fixed';
+                        overlay.style.top = '0';
+                        overlay.style.left = '0';
+                        overlay.style.width = '100vw';
+                        overlay.style.height = '100vh';
+                        overlay.style.zIndex = '999999';
+                        overlay.style.color = 'white';
+                        overlay.style.display = 'flex';
+                        overlay.style.justifyContent = 'center';
+                        overlay.style.alignItems = 'center';
+                        overlay.style.flexDirection = 'column';
+
+                        overlay.onclick = function() {{
+                            overlay.style.display = 'none';
+                            targetDocument.title = "Online Exam IDE";
+                            requestFullScreen();
+                        }};
+
+                        targetDocument.body.appendChild(overlay);
+                    }}
+
+                    overlay.style.backgroundColor = isRed ? 'rgba(255, 0, 0, 0.98)' : 'rgba(0, 0, 0, 0.9)';
+                    overlay.innerHTML = message;
+                    overlay.style.display = 'flex';
+                }}
+
+                targetDocument.addEventListener('contextmenu', event => {{
+                    event.preventDefault();
+                    event.stopPropagation();
+                    reportViolation();
+                    showOverlay('<h1 style="font-size: 50px;"> VIOLATION</h1><h2 style="font-size: 30px;">Right-click is forbidden!</h2><p style="font-size: 20px;">Return and CLICK HERE to resume.</p>');
+                    return false;
+                }}, true);
+
+                targetDocument.addEventListener('keydown', function(e) {{
+                    if (e.ctrlKey || e.altKey || e.metaKey) {{
+                        e.preventDefault();
+                        e.stopPropagation();
+                        reportViolation();
+                        showOverlay('<h1 style="font-size: 50px;"> VIOLATION</h1><h2 style="font-size: 30px;">Keyboard shortcuts are forbidden!</h2><p style="font-size: 20px;">Return and CLICK HERE to resume.</p>');
+                        return false;
+                    }}
+                    if (e.keyCode >= 112 && e.keyCode <= 123) {{
+                         e.preventDefault();
+                         e.stopPropagation();
+                         reportViolation();
+                         showOverlay('<h1 style="font-size: 50px;"> VIOLATION</h1><h2 style="font-size: 30px;">Function keys are forbidden!</h2><p style="font-size: 20px;">Return and CLICK HERE to resume.</p>');
+                         return false;
+                    }}
+                }}, true);
+
+                ['copy', 'cut', 'paste'].forEach(e => {{
+                    targetDocument.addEventListener(e, function(event) {{
+                        event.preventDefault();
+                        event.stopPropagation();
+                        reportViolation();
+                        let action = e.toUpperCase();
+                        showOverlay('<h1 style="font-size: 50px;"> VIOLATION</h1><h2 style="font-size: 30px;">' + action + ' is forbidden!</h2><p style="font-size: 20px;">Return and CLICK HERE to resume.</p>');
+                        return false;
+                    }}, true);
+                }});
+
+                targetWindow.addEventListener('blur', function() {{
+                   targetDocument.title = " EXAM WARNING: COME BACK!";
+                   reportViolation();
+                   showOverlay('<h1 style="font-size: 50px;"> VIOLATION</h1><h2 style="font-size: 30px;">You left the exam window!</h2><p style="font-size: 20px;">Return and CLICK HERE to resume.</p>');
+                }});
+
+                function handleFullscreenChange() {{
+                    if (!targetDocument.fullscreenElement && !targetDocument.webkitFullscreenElement && !targetDocument.msFullscreenElement) {{
+                        reportViolation();
+                        showOverlay('<h1 style="font-size: 40px;"> FULLSCREEN REQUIRED</h1><h2 style="font-size: 25px;">You cannot leave fullscreen mode.</h2><p style="font-size: 20px;">CLICK HERE to return to fullscreen.</p>', true);
+                    }}
+                }}
+
+                targetDocument.addEventListener('fullscreenchange', handleFullscreenChange);
+                targetDocument.addEventListener('webkitfullscreenchange', handleFullscreenChange);
+                targetDocument.addEventListener('mozfullscreenchange', handleFullscreenChange);
+                targetDocument.addEventListener('MSFullscreenChange', handleFullscreenChange);
+
+                const style = targetDocument.createElement('style');
+                style.innerHTML = `
+                    [data-testid="stSidebar"] {{ display: none !important; }}
+                    [data-testid="stToolbar"] {{ visibility: hidden !important; }}
+                    header {{ visibility: hidden !important; }}
+                `;
+                targetDocument.head.appendChild(style);
+
+                setInterval(function() {{
+                     if (!targetDocument.fullscreenElement && !targetDocument.webkitFullscreenElement && !targetDocument.msFullscreenElement) {{
+                         var overlay = targetDocument.getElementById('security-overlay');
+                         if (!overlay || overlay.style.display == 'none') {{
+                             showOverlay('<h1 style="font-size: 40px;"> FULLSCREEN REQUIRED</h1><h2 style="font-size: 25px;">You cannot leave fullscreen mode.</h2><p style="font-size: 20px;">CLICK HERE to return to fullscreen.</p>', true);
+                         }}
+                     }}
+                }}, 1000);
+
+                setTimeout(requestFullScreen, 500);
+                console.log("Security script loaded and attached to parent");
+                </script>
+                """
+                components.html(security_script, height=0, width=0)
+
+                # Top bar
+                col1, col2, col3 = st.columns([1, 1, 1])
+                with col1:
+                    st.metric("⏱ Time Remaining", str(time_left).split('.')[0])
+                with col3:
+                    st.markdown("""
+                    <button onclick="parent.document.documentElement.requestFullscreen()" style="
+                        background-color: #FF4B4B; 
+                        color: white; 
+                        padding: 10px 20px; 
+                        border: none; 
+                        border-radius: 5px; 
+                        cursor: pointer;
+                        font-weight: bold;">
+                        Force Full Screen
+                    </button>
+                    """, unsafe_allow_html=True)
+
+                if st.button("Refresh Timer"):
+                    st.rerun()
+
+        except Exception as e:
+            st.error(f"Error checking exam status: {e}")
+
+        # ================================================================
+        # QUESTION + TEST CASES DISPLAY + CODE EDITOR
+        # ================================================================
+        try:
+            questions = api_client.get_questions(st.session_state.room_id)
+            question_list = questions.get("questions", [])
+
+            if question_list:
+                # Question selection
+                question_names = [q.get("question_text", f"Question {i + 1}")[:60] for i, q in enumerate(question_list)]
+                selected_q_idx = st.selectbox("Select Question", range(len(question_names)),
+                                              format_func=lambda i: question_names[i])
+                selected_question = question_list[selected_q_idx]
+                question_id = selected_question.get("question_id")
+
+                # Display question text
+                st.markdown("---")
+                st.subheader("📝 Problem Statement")
+                st.write(f"**{selected_question['question_text']}**")
+                
+                language = selected_question.get("language", "Python").lower()
+
+                # ================================================================
+                # DISPLAY EXAMPLE TEST CASES (visible to students)
+                # ================================================================
+                example_test_cases = selected_question.get("test_cases", [])
+                hidden_count = selected_question.get("hidden_test_cases_count", 0)
+                total_count = selected_question.get("total_test_cases", 0)
+
+                if example_test_cases or hidden_count > 0:
+                    st.markdown("---")
+                    st.subheader("🧪 Test Cases")
+                    
+                    if example_test_cases:
+                        st.write("**Example Test Cases** (visible to you):")
+                        for j, tc in enumerate(example_test_cases):
+                            with st.container():
+                                col_in, col_out = st.columns(2)
+                                with col_in:
+                                    st.markdown(f"**Input {j+1}:**")
+                                    input_display = tc.get("input_data", "(no input)")
+                                    st.code(input_display if input_display else "(no input)", language="text")
+                                with col_out:
+                                    st.markdown(f"**Expected Output {j+1}:**")
+                                    st.code(tc.get("expected_output", ""), language="text")
+                    
+                    if hidden_count > 0:
+                        st.info(f"🔒 **{hidden_count}** hidden test case(s) will be used for final judging.")
+
+                # ================================================================
+                # CODE TEMPLATES
+                # ================================================================
+                st.divider()
+                st.subheader("📋 Code Templates")
+
+                if language in ["python", "py"]:
+                    templates = PYTHON_TEMPLATES
+                else:
+                    templates = JAVASCRIPT_TEMPLATES
+
+                selected_template = st.selectbox("Choose a Template", list(templates.keys()), key="template_select")
+
+                if st.button("📥 Load Template"):
+                    st.session_state.code = templates[selected_template]
+                    try:
+                        worksheet = api_client.get_worksheet(
+                            st.session_state.room_id,
+                            st.session_state.student_id,
+                            question_id
+                        )
+                        api_client.save_code(worksheet["worksheet_id"], st.session_state.code)
+                        st.success("Template loaded and saved!")
+                    except:
+                        st.success("Template loaded!")
+                    st.rerun()
+
+                # Indentation help
+                with st.expander("📐 Indentation Help"):
+                    if language in ["python", "py"]:
+                        st.write("""
+                        **Python Indentation Rules:**
+                        - Use **4 spaces** per indentation level
+                        - Consistent indentation is required
+                        - Common places for indentation:
+                          - Inside functions: 4 spaces
+                          - Inside loops (for, while): 4 spaces
+                          - Inside if/else blocks: 4 spaces
+                          - Class methods: 8 spaces from class definition
+
+                        **Example:**
+                        ```python
+                        def greet(name):      # No indentation
+                            print(name)       # 4 spaces
+                            if name:          # 4 spaces
+                                print("Hi")   # 8 spaces
+                        ```
+                        """)
+                    else:
+                        st.write("""
+                        **JavaScript Indentation Rules:**
+                        - Use **2 spaces** per indentation level
+                        - Common places for indentation:
+                          - Inside functions: 2 spaces
+                          - Inside loops (for, while): 2 spaces
+                          - Inside if/else blocks: 2 spaces
+                          - Inside objects: 2 spaces
+
+                        **Example:**
+                        ```javascript
+                        function greet(name) {    // No indentation
+                          console.log(name);      // 2 spaces
+                          if (name) {             // 2 spaces
+                            console.log("Hi");    // 4 spaces
+                          }
+                        }
+                        ```
+                        """)
+
+                # ================================================================
+                # CODE EDITOR
+                # ================================================================
+                st.divider()
+                st.subheader("⌨️ Code Editor")
+
+                if "code" not in st.session_state:
+                    st.session_state.code = ""
+
+                # Initialize worksheet
+                if "current_worksheet_id" not in st.session_state or st.session_state.get(
+                        "current_question_id") != question_id:
+                    try:
+                        worksheet = api_client.get_worksheet(
+                            st.session_state.room_id,
+                            st.session_state.student_id,
+                            question_id
+                        )
+                        st.session_state.current_worksheet_id = worksheet["worksheet_id"]
+                        st.session_state.current_question_id = question_id
+                        if worksheet.get("code"):
+                            st.session_state.code = worksheet["code"]
+                    except Exception as e:
+                        st.error(f"Error loading worksheet: {e}")
+
+                code_input = st.text_area(
+                    "Write your code here:",
+                    value=st.session_state.code,
+                    height=250,
+                    key="code_input"
+                )
+
+                # Auto-save
+                if code_input != st.session_state.code:
+                    st.session_state.code = code_input
+                    if "current_worksheet_id" in st.session_state:
+                        try:
+                            api_client.save_code(st.session_state.current_worksheet_id, code_input)
+                        except:
+                            pass
+
+                # ================================================================
+                # CODE QUALITY CHECK
+                # ================================================================
+                st.divider()
+                st.subheader("📊 Code Quality Check")
+
+                if code_input.strip():
+                    col1, col2, col3 = st.columns(3)
+
+                    has_output = False
+                    if language in ["python", "py"]:
+                        has_output = "print(" in code_input
+                    else:
+                        has_output = "console.log(" in code_input
+
+                    with col1:
+                        if has_output:
+                            st.success(f"✅ Has Output Statement")
+                        else:
+                            st.warning(f"⚠️ No Output Statement")
+
+                    char_count = len(code_input)
+                    with col2:
+                        st.info(f"📝 Characters: {char_count}")
+
+                    lines = code_input.split('\n')
+                    with col3:
+                        st.info(f"📄 Lines: {len(lines)}")
+
+                # ================================================================
+                # RUN & SUBMIT BUTTONS
+                # ================================================================
+                st.divider()
+                col_run, col_submit, col_save = st.columns(3)
+
+                with col_run:
+                    if st.button("▶️ Run Code", use_container_width=True):
+                        if code_input.strip():
+                            with st.spinner("Executing..."):
+                                result = api_client.execute_code(code_input, language)
+                            if "output" in result and result.get("success", True):
+                                st.success("✅ Execution successful!")
+                                st.code(result["output"], language="text")
+                            elif "error" in result:
+                                st.error("❌ Execution failed!")
+                                st.code(result["error"], language="text")
+                        else:
+                            st.warning("Write some code first!")
+
+                with col_submit:
+                    if st.button("🚀 Submit Solution", use_container_width=True, type="primary"):
+                        if code_input.strip():
+                            with st.spinner("Judging your solution against all test cases..."):
+                                result = api_client.submit_solution(
+                                    code=code_input,
+                                    language=language,
+                                    room_id=st.session_state.room_id,
+                                    question_id=question_id,
+                                    student_id=st.session_state.student_id
+                                )
+                            
+                            # Store result for display
+                            st.session_state.last_submission = result
+                        else:
+                            st.warning("Write some code first!")
+
+                with col_save:
+                    if st.button("💾 Save Code", use_container_width=True):
+                        if "current_worksheet_id" in st.session_state:
+                            try:
+                                api_client.save_code(st.session_state.current_worksheet_id, code_input)
+                                st.success("✅ Code saved!")
+                            except Exception as e:
+                                st.error(f"Error saving: {e}")
+
+                # ================================================================
+                # SUBMISSION RESULTS DISPLAY (LeetCode-style)
+                # ================================================================
+                if "last_submission" in st.session_state and st.session_state.last_submission:
+                    submission = st.session_state.last_submission
+                    
+                    st.markdown("---")
+                    st.subheader("📊 Submission Results")
+                    
+                    overall = submission.get("overall", "Unknown")
+                    passed = submission.get("passed_cases", 0)
+                    total = submission.get("total_cases", 0)
+                    score = submission.get("score", 0)
+                    max_score = submission.get("max_score", 100)
+                    
+                    # Overall verdict banner with score
+                    if overall == "Accepted":
+                        st.success(f"🎉 **{overall}** — All {total} test case(s) passed! Score: **{score:.0f}/{max_score:.0f}**")
+                    elif overall == "Wrong Answer":
+                        st.error(f"❌ **{overall}** — {passed}/{total} test case(s) passed. Score: **{score:.0f}/{max_score:.0f}**")
+                    elif overall == "Runtime Error":
+                        st.error(f"💥 **{overall}** — {passed}/{total} test case(s) passed. Score: **{score:.0f}/{max_score:.0f}**")
+                    else:
+                        st.warning(f"⚠️ **{overall}** — {passed}/{total} test case(s) passed. Score: **{score:.0f}/{max_score:.0f}**")
+                    
+                    # Per-case results
+                    case_results = submission.get("results", [])
+                    for cr in case_results:
+                        case_num = cr.get("case_number", "?")
+                        is_hidden = cr.get("is_hidden", False)
+                        case_passed = cr.get("passed", False)
+                        case_status = cr.get("status", "")
+                        
+                        icon = "✅" if case_passed else "❌"
+                        
+                        if is_hidden:
+                            # Hidden test case — only show pass/fail
+                            st.write(f"{icon} **Hidden Test Case {case_num}**: {case_status}")
+                        else:
+                            # Example test case — show full details
+                            with st.expander(f"{icon} Test Case {case_num}: {case_status}", expanded=not case_passed):
+                                tc_col1, tc_col2, tc_col3 = st.columns(3)
+                                with tc_col1:
+                                    st.markdown("**Input:**")
+                                    st.code(cr.get("input_data", "(no input)"), language="text")
+                                with tc_col2:
+                                    st.markdown("**Expected Output:**")
+                                    st.code(cr.get("expected_output", ""), language="text")
+                                with tc_col3:
+                                    st.markdown("**Your Output:**")
+                                    actual = cr.get("actual_output", "")
+                                    if cr.get("error"):
+                                        st.code(cr.get("error", ""), language="text")
+                                    else:
+                                        st.code(actual if actual else "(no output)", language="text")
+
+            else:
+                st.info("No questions available yet. Ask your teacher to create some!")
+
+        except Exception as e:
+            st.error(f"Error: {e}")
+
+    else:
+        st.info("📌 Join a room using the sidebar to get started!")
+
+
+# ============================================================================
+# MAIN APP
+# ============================================================================
+
+def main():
+    st.set_page_config(
+        page_title="Online Exam IDE",
+        page_icon="💻",
+        layout="wide"
+    )
+
+    # Initialize session state
+    if "role" not in st.session_state:
+        st.session_state.role = None
+
+    if "monitoring" not in st.session_state:
+        st.session_state.monitoring = False
+
+    # Create API client
+    api_client = APIClient(BACKEND_URL)
+    api_client.session_id = "session_123"
+
+    # Role selection
+    if not st.session_state.role:
+        col1, col2, col3 = st.columns([1, 1, 1])
+        with col1:
+            st.title("💻 Online Exam IDE")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("📋 Continue as Teacher", use_container_width=True, key="teacher_btn"):
+                st.session_state.role = "teacher"
+                st.rerun()
+
+        with col2:
+            if st.button("💻 Continue as Student", use_container_width=True, key="student_btn"):
+                st.session_state.role = "student"
+                st.rerun()
+
+    else:
+        if st.session_state.role == "teacher":
+            teacher_page(api_client)
+        else:
+            student_page(api_client)
+
+        if st.sidebar.button("🔓 Logout"):
+            st.session_state.role = None
+            st.session_state.pop("room_id", None)
+            st.session_state.pop("room_code", None)
+            st.session_state.pop("last_submission", None)
+            st.session_state.pop("test_cases_draft", None)
+            st.rerun()
+
+
+if __name__ == "__main__":
+    main()

frontend/requirements.txt

@@ -0,0 +1,3 @@
+streamlit==1.28.1
+requests==2.31.0
+python-dotenv==1.0.0

frontend/utils/api_client.py

@@ -0,0 +1,159 @@
+import requests
+import streamlit as st
+from .constants import BACKEND_URL
+from typing import Optional, Dict, Any
+import json
+
+
+class APIClient:
+    """API client for backend communication"""
+
+    BASE_URL = BACKEND_URL
+
+    @staticmethod
+    def create_room(room_name: str, teacher_id: str, teacher_name: str) -> Optional[Dict]:
+        """Create exam room"""
+        try:
+            response = requests.post(
+                f"{APIClient.BASE_URL}/api/rooms/create",
+                params={
+                    "room_name": room_name,
+                    "teacher_id": teacher_id,
+                    "teacher_name": teacher_name
+                }
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            st.error(f"Failed to create room: {str(e)}")
+            return None
+
+    @staticmethod
+    def get_room(room_id: str) -> Optional[Dict]:
+        """Get room details"""
+        try:
+            response = requests.get(f"{APIClient.BASE_URL}/api/rooms/{room_id}")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            st.error(f"Room not found: {str(e)}")
+            return None
+
+    @staticmethod
+    def join_room(room_id: str, student_id: str, student_name: str) -> Optional[Dict]:
+        """Student joins room"""
+        try:
+            response = requests.post(
+                f"{APIClient.BASE_URL}/api/rooms/{room_id}/join",
+                params={
+                    "student_id": student_id,
+                    "student_name": student_name
+                }
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            st.error(f"Failed to join room: {str(e)}")
+            return None
+
+    @staticmethod
+    def create_question(room_id: str, title: str, description: str, languages: list = None) -> Optional[Dict]:
+        """Create question"""
+        try:
+            response = requests.post(
+                f"{APIClient.BASE_URL}/api/rooms/{room_id}/questions",
+                params={
+                    "title": title,
+                    "description": description,
+                    "allowed_languages": languages or ["python", "javascript", "java", "cpp"]
+                }
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            st.error(f"Failed to create question: {str(e)}")
+            return None
+
+    @staticmethod
+    def get_questions(room_id: str) -> Optional[Dict]:
+        """Get all questions in room"""
+        try:
+            response = requests.get(f"{APIClient.BASE_URL}/api/rooms/{room_id}/questions")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            st.error(f"Failed to load questions: {str(e)}")
+            return None
+
+    @staticmethod
+    def get_worksheet(room_id: str, student_id: str, question_id: str) -> Optional[Dict]:
+        """Get student's worksheet"""
+        try:
+            response = requests.get(
+                f"{APIClient.BASE_URL}/api/worksheets/{room_id}/{student_id}/{question_id}"
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            st.error(f"Failed to load worksheet: {str(e)}")
+            return None
+
+    @staticmethod
+    def save_code(worksheet_id: str, code: str, language: str) -> bool:
+        """Auto-save code"""
+        try:
+            response = requests.post(
+                f"{APIClient.BASE_URL}/api/worksheets/{worksheet_id}/save",
+                params={
+                    "code": code,
+                    "language": language
+                }
+            )
+            response.raise_for_status()
+            return True
+        except:
+            return False
+
+    @staticmethod
+    def execute_code(worksheet_id: str, code: str, language: str, input_data: str = "") -> Optional[Dict]:
+        """Execute code"""
+        try:
+            response = requests.post(
+                f"{APIClient.BASE_URL}/api/worksheets/{worksheet_id}/execute",
+                json={
+                    "code": code,
+                    "language": language,
+                    "input_data": input_data
+                }
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            return {
+                "status": "error",
+                "output": "None",
+                "stderr": str(e)
+            }
+
+    @staticmethod
+    def get_students(room_id: str) -> Optional[Dict]:
+        """Get room students (Teacher)"""
+        try:
+            response = requests.get(f"{APIClient.BASE_URL}/api/rooms/{room_id}/students")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            st.error(f"Failed to load students: {str(e)}")
+            return None
+
+    @staticmethod
+    def get_student_progress(room_id: str, student_id: str) -> Optional[Dict]:
+        """Get student progress"""
+        try:
+            response = requests.get(
+                f"{APIClient.BASE_URL}/api/rooms/{room_id}/student/{student_id}/progress"
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            return None

frontend/utils/constants.py

@@ -0,0 +1,15 @@
+# Backend API URL (change for production)
+BACKEND_URL = "http://localhost:8000"  # Local dev
+
+# Supported languages
+SUPPORTED_LANGUAGES = {
+    "python": "python",
+    "javascript": "javascript",
+    "java": "java",
+    "c": "c",
+    "c++": "cpp"
+}
+
+# UI Settings
+EDITOR_HEIGHT = 400
+REFRESH_INTERVAL = 2  # seconds for polling updates