Add Quiz Reel module with TTS, frame generation, and video composition

modules/quiz_reel/__init__.py

@@ -0,0 +1,31 @@
+"""
+Quiz Reel Module
+Generates quiz videos with TTS, options, and answer reveal.
+"""
+import logging
+from fastapi import FastAPI
+
+logger = logging.getLogger(__name__)
+
+# Module metadata
+MODULE_NAME = "quiz_reel"
+MODULE_PREFIX = "/api/quiz"
+MODULE_DESCRIPTION = "Quiz video generation with TTS and animated reveals"
+
+
+def register(app: FastAPI, config) -> None:
+    """Register quiz_reel module with the app"""
+    from .router import router, set_app_reference
+    
+    try:
+        # Set app reference for accessing shared services
+        set_app_reference(app)
+        
+        # Include router
+        app.include_router(router, prefix=MODULE_PREFIX, tags=["Quiz Reel"])
+        
+        logger.info(f"✅ Quiz Reel module registered at {MODULE_PREFIX}")
+        
+    except Exception as e:
+        logger.error(f"Failed to register quiz_reel module: {e}")
+        raise

modules/quiz_reel/router.py

@@ -0,0 +1,225 @@
+"""
+Quiz Reel Router
+API endpoints for quiz video generation.
+"""
+import logging
+import os
+import shutil
+import uuid
+from typing import Dict
+from pathlib import Path
+from fastapi import APIRouter, BackgroundTasks, HTTPException
+from fastapi.responses import FileResponse
+
+from .schemas import QuizRequest, JobResponse, JobStatus
+from .services.quiz_frame import QuizFrameGenerator
+from .services.quiz_composer import QuizComposer
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# App reference for accessing shared services (TTS)
+_app = None
+
+# Job storage
+jobs: Dict[str, Dict] = {}
+
+# Service instances
+frame_generator = QuizFrameGenerator()
+quiz_composer = QuizComposer()
+
+
+def set_app_reference(app):
+    """Set FastAPI app reference for accessing shared services"""
+    global _app
+    _app = app
+    logger.info("App reference set for quiz_reel module")
+
+
+def update_job(job_id: str, status: str, progress: int = 0, 
+               video_url: str = None, error: str = None):
+    """Update job status"""
+    if job_id in jobs:
+        jobs[job_id].update({
+            "status": status,
+            "progress": progress,
+            "video_url": video_url,
+            "error": error
+        })
+
+
+async def generate_quiz_video(job_id: str, quizzes: list, voice: str):
+    """Background task to generate quiz video"""
+    temp_dir = f"temp/quiz_{job_id}"
+    
+    try:
+        update_job(job_id, "processing", 5)
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        # Get TTS client from app.state
+        if not _app or not hasattr(_app, 'state'):
+            raise Exception("App reference not available")
+        
+        tts_client = getattr(_app.state, 'tts_client', None)
+        if not tts_client:
+            raise Exception("TTS client not available - check if story_reels module is loaded")
+        
+        logger.info(f"Generating quiz video with {len(quizzes)} quizzes")
+        
+        # Generate TTS for each quiz
+        quiz_audios = []
+        
+        for i, quiz in enumerate(quizzes):
+            progress = int(10 + (i / len(quizzes)) * 40)
+            update_job(job_id, "processing", progress)
+            
+            # Question TTS
+            question_text = quiz["question"]
+            question_audio_path = os.path.join(temp_dir, f"question_{i}.wav")
+            
+            logger.info(f"Generating TTS for question {i+1}: {question_text[:30]}...")
+            audio_bytes, duration = await tts_client.generate(text=question_text, voice=voice)
+            with open(question_audio_path, "wb") as f:
+                f.write(audio_bytes)
+            
+            # Answer TTS (e.g., "The answer is A, Mount Everest")
+            correct_key = quiz["correct"]
+            correct_value = quiz["options"].get(correct_key, "")
+            answer_text = f"The answer is {correct_key}, {correct_value}"
+            answer_audio_path = os.path.join(temp_dir, f"answer_{i}.wav")
+            
+            logger.info(f"Generating TTS for answer {i+1}: {answer_text[:30]}...")
+            audio_bytes, duration = await tts_client.generate(text=answer_text, voice=voice)
+            with open(answer_audio_path, "wb") as f:
+                f.write(audio_bytes)
+            
+            quiz_audios.append({
+                "question": question_audio_path,
+                "answer": answer_audio_path
+            })
+        
+        update_job(job_id, "processing", 60)
+        
+        # Compose video
+        logger.info(f"Composing quiz video for job {job_id}")
+        video_path = quiz_composer.compose_quiz_video(
+            quizzes=[dict(q) for q in quizzes],
+            quiz_audios=quiz_audios,
+            output_name=f"quiz_{job_id}.mp4",
+            frame_generator=frame_generator
+        )
+        
+        update_job(job_id, "processing", 85)
+        
+        # Upload to HF Hub (if enabled)
+        from modules.shared.services.hf_storage import get_hf_storage
+        
+        hf_storage = get_hf_storage()
+        cloud_url = None
+        
+        if hf_storage and hf_storage.enabled:
+            logger.info(f"Uploading to HF Hub for job {job_id}")
+            cloud_url = hf_storage.upload_video(
+                local_path=Path(video_path),
+                video_id=job_id,
+                folder="quiz_reel"
+            )
+            if cloud_url:
+                logger.info(f"Uploaded to cloud: {cloud_url}")
+        
+        # Cleanup temp files
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+        
+        video_url = cloud_url or f"/api/quiz/video/{job_id}"
+        update_job(job_id, "ready", 100, video_url=video_url)
+        logger.info(f"Quiz video ready: {job_id}")
+        
+    except Exception as e:
+        logger.error(f"Error generating quiz video: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
+        update_job(job_id, "failed", error=str(e))
+        
+        # Cleanup on error
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+
+
+@router.post("/generate", response_model=JobResponse)
+async def create_quiz_video(request: QuizRequest, background_tasks: BackgroundTasks):
+    """
+    Generate a quiz video from multiple quiz scenes.
+    
+    Each quiz has:
+    - hook: Category label (optional)
+    - question: The question text
+    - options: Dict with A, B, C answers
+    - correct: The correct option (A, B, or C)
+    - explain: Explanation text (optional)
+    """
+    job_id = str(uuid.uuid4())[:8]
+    
+    # Validate quizzes
+    for i, quiz in enumerate(request.quizzes):
+        if quiz.correct.upper() not in quiz.options:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Quiz {i+1}: correct answer '{quiz.correct}' not in options"
+            )
+        if len(quiz.options) != 3:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Quiz {i+1}: exactly 3 options (A, B, C) required"
+            )
+    
+    # Initialize job
+    jobs[job_id] = {
+        "status": "queued",
+        "progress": 0,
+        "video_url": None,
+        "error": None
+    }
+    
+    # Start background task
+    quizzes_data = [quiz.dict() for quiz in request.quizzes]
+    background_tasks.add_task(generate_quiz_video, job_id, quizzes_data, request.voice)
+    
+    return JobResponse(
+        job_id=job_id,
+        status="queued",
+        message=f"Quiz video generation started with {len(request.quizzes)} quizzes"
+    )
+
+
+@router.get("/{job_id}/status", response_model=JobStatus)
+async def get_job_status(job_id: str):
+    """Get the status of a quiz video generation job"""
+    if job_id not in jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
+    
+    job = jobs[job_id]
+    return JobStatus(
+        job_id=job_id,
+        status=job["status"],
+        progress=job["progress"],
+        video_url=job.get("video_url"),
+        error=job.get("error")
+    )
+
+
+@router.get("/video/{job_id}")
+async def get_video(job_id: str):
+    """Download the generated quiz video"""
+    video_path = f"videos/quiz_reel/quiz_{job_id}.mp4"
+    
+    if not os.path.exists(video_path):
+        raise HTTPException(status_code=404, detail="Video not found")
+    
+    return FileResponse(
+        video_path,
+        media_type="video/mp4",
+        filename=f"quiz_{job_id}.mp4",
+        headers={"Content-Disposition": f"attachment; filename=quiz_{job_id}.mp4"}
+    )

modules/quiz_reel/schemas.py

@@ -0,0 +1,37 @@
+"""
+Quiz Reel Schemas
+Request/Response models for quiz video generation.
+"""
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional
+
+
+class QuizScene(BaseModel):
+    """Single quiz scene data"""
+    hook: str = Field("", description="Category label like 'IQ TEST', 'MATH QUIZ'")
+    question: str = Field(..., description="The quiz question text")
+    options: Dict[str, str] = Field(..., description="Options dict like {'A': 'Answer1', 'B': 'Answer2', 'C': 'Answer3'}")
+    correct: str = Field(..., description="Correct option key: 'A', 'B', or 'C'")
+    explain: str = Field("", description="Explanation text shown after answer reveal")
+
+
+class QuizRequest(BaseModel):
+    """Request model for quiz video generation"""
+    quizzes: List[QuizScene] = Field(..., min_length=1, description="Array of quiz scenes")
+    voice: str = Field("af_heart", description="TTS voice ID")
+
+
+class JobResponse(BaseModel):
+    """Job creation response"""
+    job_id: str
+    status: str
+    message: str
+
+
+class JobStatus(BaseModel):
+    """Job status response"""
+    job_id: str
+    status: str
+    progress: int
+    video_url: Optional[str] = None
+    error: Optional[str] = None

modules/quiz_reel/services/__init__.py

@@ -0,0 +1,5 @@
+"""Quiz Reel Services"""
+from .quiz_frame import QuizFrameGenerator
+from .quiz_composer import QuizComposer
+
+__all__ = ["QuizFrameGenerator", "QuizComposer"]

modules/quiz_reel/services/quiz_composer.py

@@ -0,0 +1,187 @@
+"""
+Quiz Composer
+Assembles quiz frames with TTS audio into final video.
+"""
+import logging
+import os
+import shutil
+from pathlib import Path
+from typing import List, Dict, Optional
+from moviepy.editor import ImageSequenceClip, AudioFileClip, concatenate_videoclips, CompositeAudioClip
+
+logger = logging.getLogger(__name__)
+
+
+class QuizComposer:
+    """
+    Composes quiz video from frames and TTS audio.
+    
+    Timing flow per quiz:
+    - Question TTS plays + show question frame
+    - 3s thinking (silence, same frame)
+    - Answer TTS plays + show answer frame
+    """
+    
+    FPS = 30
+    THINKING_DURATION = 3.0  # Fixed 3 seconds
+    
+    def __init__(self, output_dir: str = "videos/quiz_reel"):
+        self.output_dir = output_dir
+        os.makedirs(output_dir, exist_ok=True)
+    
+    def compose_single_quiz(
+        self,
+        frame_generator,
+        quiz_data: Dict,
+        temp_dir: str,
+        question_audio_path: str,
+        answer_audio_path: str,
+        quiz_index: int = 0
+    ) -> Dict:
+        """
+        Compose a single quiz scene with audio.
+        
+        Returns dict with clip and timing info.
+        """
+        # Get audio durations
+        question_duration = 2.0  # Default
+        answer_duration = 2.0    # Default
+        
+        if os.path.exists(question_audio_path):
+            with AudioFileClip(question_audio_path) as audio:
+                question_duration = audio.duration
+                logger.info(f"Question audio duration: {question_duration:.2f}s")
+        
+        if os.path.exists(answer_audio_path):
+            with AudioFileClip(answer_audio_path) as audio:
+                answer_duration = audio.duration
+                logger.info(f"Answer audio duration: {answer_duration:.2f}s")
+        
+        # Generate frames with correct durations
+        quiz_frames_dir = os.path.join(temp_dir, f"quiz_{quiz_index}")
+        frame_result = frame_generator.generate_quiz_frames(
+            quiz_data=quiz_data,
+            output_dir=quiz_frames_dir,
+            fps=self.FPS,
+            question_duration=question_duration,
+            thinking_duration=self.THINKING_DURATION,
+            answer_duration=answer_duration
+        )
+        
+        frame_paths = frame_result["frame_paths"]
+        
+        # Create video clip from frames
+        video_clip = ImageSequenceClip(frame_paths, fps=self.FPS)
+        
+        # Calculate audio timing
+        # Question audio starts at 0
+        # Answer audio starts at question_duration + thinking_duration
+        answer_audio_start = question_duration + self.THINKING_DURATION
+        
+        # Load and position audio clips
+        audio_clips = []
+        
+        if os.path.exists(question_audio_path):
+            q_audio = AudioFileClip(question_audio_path)
+            audio_clips.append(q_audio.set_start(0))
+        
+        if os.path.exists(answer_audio_path):
+            a_audio = AudioFileClip(answer_audio_path)
+            audio_clips.append(a_audio.set_start(answer_audio_start))
+        
+        # Combine audio clips
+        if audio_clips:
+            combined_audio = CompositeAudioClip(audio_clips)
+            video_clip = video_clip.set_audio(combined_audio)
+        
+        total_duration = question_duration + self.THINKING_DURATION + answer_duration
+        
+        return {
+            "clip": video_clip,
+            "duration": total_duration,
+            "frame_paths": frame_paths
+        }
+    
+    def compose_quiz_video(
+        self,
+        quizzes: List[Dict],
+        quiz_audios: List[Dict],  # [{"question": path, "answer": path}, ...]
+        output_name: str,
+        frame_generator
+    ) -> str:
+        """
+        Compose full quiz video from multiple quizzes.
+        
+        Args:
+            quizzes: List of quiz data dicts
+            quiz_audios: List of audio path dicts for each quiz
+            output_name: Output video filename
+            frame_generator: QuizFrameGenerator instance
+        
+        Returns:
+            Path to output video file
+        """
+        temp_dir = os.path.join(self.output_dir, "temp_frames")
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        try:
+            clips = []
+            all_frame_paths = []
+            
+            for i, (quiz, audio_paths) in enumerate(zip(quizzes, quiz_audios)):
+                logger.info(f"Composing quiz {i+1}/{len(quizzes)}: {quiz['question'][:30]}...")
+                
+                result = self.compose_single_quiz(
+                    frame_generator=frame_generator,
+                    quiz_data=quiz,
+                    temp_dir=temp_dir,
+                    question_audio_path=audio_paths.get("question", ""),
+                    answer_audio_path=audio_paths.get("answer", ""),
+                    quiz_index=i
+                )
+                
+                clips.append(result["clip"])
+                all_frame_paths.extend(result["frame_paths"])
+            
+            # Concatenate all quiz clips
+            if len(clips) == 1:
+                final_clip = clips[0]
+            else:
+                final_clip = concatenate_videoclips(clips, method="compose")
+            
+            # Output path
+            output_path = os.path.join(self.output_dir, output_name)
+            
+            # Write video
+            logger.info(f"Writing video to {output_path}")
+            final_clip.write_videofile(
+                output_path,
+                fps=self.FPS,
+                codec="libx264",
+                audio_codec="aac",
+                preset="medium",
+                threads=4,
+                logger=None
+            )
+            
+            # Cleanup
+            final_clip.close()
+            for clip in clips:
+                clip.close()
+            
+            logger.info(f"Quiz video complete: {output_path}")
+            return output_path
+            
+        finally:
+            # Cleanup temp frames
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+    
+    def cleanup_frames(self, frame_paths: List[str]):
+        """Remove frame files"""
+        for path in frame_paths:
+            try:
+                if os.path.exists(path):
+                    os.remove(path)
+            except Exception as e:
+                logger.warning(f"Failed to remove frame {path}: {e}")

modules/quiz_reel/services/quiz_frame.py

@@ -0,0 +1,360 @@
+"""
+Quiz Frame Generator
+Creates quiz frames using Pillow based on the design specification.
+"""
+import logging
+import os
+from PIL import Image, ImageDraw, ImageFont
+from typing import Dict, List, Tuple, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class QuizFrameGenerator:
+    """
+    Generates quiz frames with:
+    - Dark green gradient background with grid
+    - Hook text (yellow, top)
+    - Question card (white rounded rectangle)
+    - Option pills (3 options: A, B, C)
+    - Answer reveal (correct = green + checkmark)
+    - Explain text (bottom)
+    """
+    
+    # Canvas dimensions (9:16)
+    WIDTH = 1080
+    HEIGHT = 1920
+    
+    # Colors
+    BG_COLOR_TOP = (15, 60, 50)      # Dark green top
+    BG_COLOR_BOTTOM = (10, 40, 35)   # Darker green bottom
+    GRID_COLOR = (25, 80, 65)        # Grid lines
+    
+    HOOK_COLOR = (204, 255, 0)       # Yellow/lime #CCFF00
+    QUESTION_BG = (240, 240, 235)    # Off-white
+    QUESTION_TEXT = (50, 50, 50)     # Dark gray
+    
+    OPTION_DEFAULT_BG = (220, 220, 215)   # Light gray
+    OPTION_CORRECT_BG = (74, 222, 128)    # Green #4ADE80
+    OPTION_TEXT = (50, 50, 50)            # Dark gray
+    OPTION_TEXT_CORRECT = (255, 255, 255) # White on green
+    
+    EXPLAIN_COLOR = (180, 180, 180)  # Light gray
+    SPARKLE_COLOR = (255, 255, 255)  # White
+    
+    # Positions (Y coordinates as percentages of HEIGHT)
+    HOOK_Y = 0.06          # 6% from top (~115px)
+    QUESTION_TOP = 0.15    # 15% (~288px)
+    QUESTION_BOTTOM = 0.35 # 35% (~672px)
+    OPTIONS_START = 0.40   # 40% (~768px)
+    OPTIONS_GAP = 0.09     # 9% gap between options
+    OPTION_HEIGHT = 100    # Fixed pixel height
+    EXPLAIN_Y = 0.72       # 72% (~1382px)
+    
+    def __init__(self):
+        self._load_fonts()
+    
+    def _load_fonts(self):
+        """Load fonts with fallbacks"""
+        font_paths = [
+            "C:/Windows/Fonts/Inter-Bold.ttf",
+            "C:/Windows/Fonts/arial.ttf",
+            "C:/Windows/Fonts/ArialBD.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+        ]
+        
+        # Try to load custom fonts, fallback to default
+        self.font_hook = None
+        self.font_question = None
+        self.font_option = None
+        self.font_explain = None
+        
+        for path in font_paths:
+            if os.path.exists(path):
+                try:
+                    self.font_hook = ImageFont.truetype(path, 72)
+                    self.font_question = ImageFont.truetype(path, 48)
+                    self.font_option = ImageFont.truetype(path, 36)
+                    self.font_explain = ImageFont.truetype(path, 28)
+                    logger.info(f"Loaded font: {path}")
+                    break
+                except Exception as e:
+                    logger.warning(f"Failed to load font {path}: {e}")
+        
+        # Fallback to default
+        if not self.font_hook:
+            self.font_hook = ImageFont.load_default()
+            self.font_question = ImageFont.load_default()
+            self.font_option = ImageFont.load_default()
+            self.font_explain = ImageFont.load_default()
+            logger.warning("Using default font")
+    
+    def _create_gradient_background(self) -> Image.Image:
+        """Create dark green gradient background with grid"""
+        img = Image.new('RGB', (self.WIDTH, self.HEIGHT))
+        draw = ImageDraw.Draw(img)
+        
+        # Gradient from top to bottom
+        for y in range(self.HEIGHT):
+            ratio = y / self.HEIGHT
+            r = int(self.BG_COLOR_TOP[0] + (self.BG_COLOR_BOTTOM[0] - self.BG_COLOR_TOP[0]) * ratio)
+            g = int(self.BG_COLOR_TOP[1] + (self.BG_COLOR_BOTTOM[1] - self.BG_COLOR_TOP[1]) * ratio)
+            b = int(self.BG_COLOR_TOP[2] + (self.BG_COLOR_BOTTOM[2] - self.BG_COLOR_TOP[2]) * ratio)
+            draw.line([(0, y), (self.WIDTH, y)], fill=(r, g, b))
+        
+        # Draw grid lines
+        grid_spacing = 40
+        for x in range(0, self.WIDTH, grid_spacing):
+            draw.line([(x, 0), (x, self.HEIGHT)], fill=self.GRID_COLOR, width=1)
+        for y in range(0, self.HEIGHT, grid_spacing):
+            draw.line([(0, y), (self.WIDTH, y)], fill=self.GRID_COLOR, width=1)
+        
+        return img
+    
+    def _draw_rounded_rect(self, draw: ImageDraw, bbox: Tuple, fill: Tuple, radius: int = 30):
+        """Draw a rounded rectangle"""
+        x1, y1, x2, y2 = bbox
+        draw.rounded_rectangle(bbox, radius=radius, fill=fill)
+    
+    def _draw_text_centered(self, draw: ImageDraw, text: str, y: int, font, color: Tuple, max_width: int = None):
+        """Draw centered text, optionally wrapped"""
+        if max_width:
+            # Word wrap
+            words = text.split()
+            lines = []
+            current_line = ""
+            for word in words:
+                test_line = current_line + " " + word if current_line else word
+                bbox = draw.textbbox((0, 0), test_line, font=font)
+                if bbox[2] - bbox[0] <= max_width:
+                    current_line = test_line
+                else:
+                    if current_line:
+                        lines.append(current_line)
+                    current_line = word
+            if current_line:
+                lines.append(current_line)
+            
+            # Draw each line
+            line_height = draw.textbbox((0, 0), "Ay", font=font)[3] + 10
+            for i, line in enumerate(lines):
+                bbox = draw.textbbox((0, 0), line, font=font)
+                text_width = bbox[2] - bbox[0]
+                x = (self.WIDTH - text_width) // 2
+                draw.text((x, y + i * line_height), line, fill=color, font=font)
+        else:
+            bbox = draw.textbbox((0, 0), text, font=font)
+            text_width = bbox[2] - bbox[0]
+            x = (self.WIDTH - text_width) // 2
+            draw.text((x, y), text, fill=color, font=font)
+    
+    def _draw_checkmark(self, draw: ImageDraw, center: Tuple[int, int], size: int = 40):
+        """Draw a checkmark icon in a circle"""
+        cx, cy = center
+        # Circle background
+        draw.ellipse([cx - size//2, cy - size//2, cx + size//2, cy + size//2], 
+                     fill=(255, 255, 255))
+        # Checkmark
+        check_color = self.OPTION_CORRECT_BG
+        draw.line([(cx - 12, cy), (cx - 4, cy + 10)], fill=check_color, width=4)
+        draw.line([(cx - 4, cy + 10), (cx + 14, cy - 10)], fill=check_color, width=4)
+    
+    def _draw_sparkle(self, draw: ImageDraw, pos: Tuple[int, int]):
+        """Draw sparkle icon at position"""
+        x, y = pos
+        # Simple 4-pointed star
+        points = [
+            (x, y - 15), (x + 5, y - 5), (x + 15, y), (x + 5, y + 5),
+            (x, y + 15), (x - 5, y + 5), (x - 15, y), (x - 5, y - 5)
+        ]
+        draw.polygon(points, fill=self.SPARKLE_COLOR)
+    
+    def create_question_frame(
+        self,
+        hook: str,
+        question: str,
+        options: Dict[str, str]
+    ) -> Image.Image:
+        """
+        Create frame showing question + options (before answer reveal)
+        """
+        img = self._create_gradient_background()
+        draw = ImageDraw.Draw(img)
+        
+        # Hook text (top, yellow)
+        if hook:
+            self._draw_text_centered(draw, hook.upper(), int(self.HEIGHT * self.HOOK_Y), 
+                                     self.font_hook, self.HOOK_COLOR)
+        
+        # Question card
+        card_x1 = int(self.WIDTH * 0.05)
+        card_x2 = int(self.WIDTH * 0.95)
+        card_y1 = int(self.HEIGHT * self.QUESTION_TOP)
+        card_y2 = int(self.HEIGHT * self.QUESTION_BOTTOM)
+        self._draw_rounded_rect(draw, (card_x1, card_y1, card_x2, card_y2), 
+                               self.QUESTION_BG, radius=40)
+        
+        # Question text inside card
+        text_y = card_y1 + 40
+        max_text_width = card_x2 - card_x1 - 60
+        self._draw_text_centered(draw, question, text_y, self.font_question, 
+                                self.QUESTION_TEXT, max_width=max_text_width)
+        
+        # Options
+        option_width = int(self.WIDTH * 0.85)
+        option_x = (self.WIDTH - option_width) // 2
+        
+        for i, (key, value) in enumerate(options.items()):
+            y_pos = int(self.HEIGHT * (self.OPTIONS_START + i * self.OPTIONS_GAP))
+            
+            # Option pill (gray - not revealed yet)
+            self._draw_rounded_rect(draw, 
+                (option_x, y_pos, option_x + option_width, y_pos + self.OPTION_HEIGHT),
+                self.OPTION_DEFAULT_BG, radius=50)
+            
+            # Option text
+            option_text = f"{key}. {value}"
+            bbox = draw.textbbox((0, 0), option_text, font=self.font_option)
+            text_height = bbox[3] - bbox[1]
+            text_y = y_pos + (self.OPTION_HEIGHT - text_height) // 2
+            draw.text((option_x + 30, text_y), option_text, fill=self.OPTION_TEXT, font=self.font_option)
+        
+        # Sparkle icon (bottom right)
+        self._draw_sparkle(draw, (self.WIDTH - 60, self.HEIGHT - 60))
+        
+        return img
+    
+    def create_answer_frame(
+        self,
+        hook: str,
+        question: str,
+        options: Dict[str, str],
+        correct: str,
+        explain: str
+    ) -> Image.Image:
+        """
+        Create frame showing answer reveal (correct option green + explain)
+        """
+        img = self._create_gradient_background()
+        draw = ImageDraw.Draw(img)
+        
+        # Hook text (top, yellow)
+        if hook:
+            self._draw_text_centered(draw, hook.upper(), int(self.HEIGHT * self.HOOK_Y), 
+                                     self.font_hook, self.HOOK_COLOR)
+        
+        # Question card
+        card_x1 = int(self.WIDTH * 0.05)
+        card_x2 = int(self.WIDTH * 0.95)
+        card_y1 = int(self.HEIGHT * self.QUESTION_TOP)
+        card_y2 = int(self.HEIGHT * self.QUESTION_BOTTOM)
+        self._draw_rounded_rect(draw, (card_x1, card_y1, card_x2, card_y2), 
+                               self.QUESTION_BG, radius=40)
+        
+        # Question text inside card
+        text_y = card_y1 + 40
+        max_text_width = card_x2 - card_x1 - 60
+        self._draw_text_centered(draw, question, text_y, self.font_question, 
+                                self.QUESTION_TEXT, max_width=max_text_width)
+        
+        # Options with answer reveal
+        option_width = int(self.WIDTH * 0.85)
+        option_x = (self.WIDTH - option_width) // 2
+        
+        for i, (key, value) in enumerate(options.items()):
+            y_pos = int(self.HEIGHT * (self.OPTIONS_START + i * self.OPTIONS_GAP))
+            is_correct = key.upper() == correct.upper()
+            
+            # Option pill (green for correct, gray for wrong)
+            bg_color = self.OPTION_CORRECT_BG if is_correct else self.OPTION_DEFAULT_BG
+            text_color = self.OPTION_TEXT_CORRECT if is_correct else self.OPTION_TEXT
+            
+            self._draw_rounded_rect(draw, 
+                (option_x, y_pos, option_x + option_width, y_pos + self.OPTION_HEIGHT),
+                bg_color, radius=50)
+            
+            # Option text
+            option_text = f"{key}. {value}"
+            bbox = draw.textbbox((0, 0), option_text, font=self.font_option)
+            text_height = bbox[3] - bbox[1]
+            text_y = y_pos + (self.OPTION_HEIGHT - text_height) // 2
+            draw.text((option_x + 30, text_y), option_text, fill=text_color, font=self.font_option)
+            
+            # Checkmark for correct answer
+            if is_correct:
+                checkmark_x = option_x + option_width - 60
+                checkmark_y = y_pos + self.OPTION_HEIGHT // 2
+                self._draw_checkmark(draw, (checkmark_x, checkmark_y))
+        
+        # Explain text (bottom)
+        if explain:
+            explain_y = int(self.HEIGHT * self.EXPLAIN_Y)
+            self._draw_text_centered(draw, explain, explain_y, self.font_explain, 
+                                    self.EXPLAIN_COLOR, max_width=int(self.WIDTH * 0.85))
+        
+        # Sparkle icon (bottom right)
+        self._draw_sparkle(draw, (self.WIDTH - 60, self.HEIGHT - 60))
+        
+        return img
+    
+    def generate_quiz_frames(
+        self,
+        quiz_data: Dict,
+        output_dir: str,
+        fps: int = 30,
+        question_duration: float = 0,  # Will be set by TTS
+        thinking_duration: float = 3.0,
+        answer_duration: float = 0     # Will be set by TTS
+    ) -> Dict:
+        """
+        Generate all frames for a single quiz scene.
+        
+        Returns dict with frame paths and timing info.
+        """
+        os.makedirs(output_dir, exist_ok=True)
+        
+        hook = quiz_data.get("hook", "")
+        question = quiz_data["question"]
+        options = quiz_data["options"]
+        correct = quiz_data["correct"]
+        explain = quiz_data.get("explain", "")
+        
+        frame_paths = []
+        frame_num = 0
+        
+        # Phase 1: Question frame (duration set by TTS)
+        question_frame = self.create_question_frame(hook, question, options)
+        question_frames_count = max(1, int(question_duration * fps)) if question_duration > 0 else fps * 2
+        
+        for _ in range(question_frames_count):
+            path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
+            question_frame.save(path)
+            frame_paths.append(path)
+            frame_num += 1
+        
+        # Phase 2: Thinking time (same frame, fixed 3 seconds)
+        thinking_frames_count = int(thinking_duration * fps)
+        for _ in range(thinking_frames_count):
+            path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
+            question_frame.save(path)
+            frame_paths.append(path)
+            frame_num += 1
+        
+        # Phase 3: Answer frame (duration set by TTS)
+        answer_frame = self.create_answer_frame(hook, question, options, correct, explain)
+        answer_frames_count = max(1, int(answer_duration * fps)) if answer_duration > 0 else fps * 2
+        
+        for _ in range(answer_frames_count):
+            path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
+            answer_frame.save(path)
+            frame_paths.append(path)
+            frame_num += 1
+        
+        logger.info(f"Generated {len(frame_paths)} frames for quiz: {question[:30]}...")
+        
+        return {
+            "frame_paths": frame_paths,
+            "question_frames": question_frames_count,
+            "thinking_frames": thinking_frames_count,
+            "answer_frames": answer_frames_count
+        }

static/index.html

@@ -276,6 +276,9 @@
             <button class="tab-btn" data-tab="trends">
                 📊 Trends
             </button>
+            <button class="tab-btn" data-tab="quiz">
+                🎯 Quiz Reel
+            </button>
         </div>
 
         <!-- Story Reels Tab -->
@@ -569,6 +572,77 @@
         </div>
     </div>
 
+    <!-- Quiz Reel Tab -->
+    <div id="quiz-tab" class="tab-content">
+        <div class="card">
+            <h2>🎯 Quiz Reel Generator</h2>
+            <p style="color: var(--text-secondary); margin-bottom: 1.5rem;">
+                Create quiz videos with TTS, thinking time, and animated answer reveals
+            </p>
+
+            <form id="quizForm">
+                <div id="quizContainer">
+                    <!-- Quiz 1 -->
+                    <div class="quiz-item"
+                        style="background: var(--bg-secondary); padding: 1.5rem; border-radius: 12px; margin-bottom: 1rem;">
+                        <h4 style="color: var(--accent); margin-bottom: 1rem;">Quiz 1</h4>
+                        <div class="form-group">
+                            <label>Hook (Category)</label>
+                            <input type="text" class="quiz-hook" placeholder="e.g., IQ TEST, MATH QUIZ" value="IQ TEST">
+                        </div>
+                        <div class="form-group">
+                            <label>Question *</label>
+                            <input type="text" class="quiz-question" placeholder="What is the tallest mountain?"
+                                required>
+                        </div>
+                        <div class="form-row">
+                            <div class="form-group">
+                                <label>Option A *</label>
+                                <input type="text" class="quiz-option-a" placeholder="Answer A" required>
+                            </div>
+                            <div class="form-group">
+                                <label>Option B *</label>
+                                <input type="text" class="quiz-option-b" placeholder="Answer B" required>
+                            </div>
+                            <div class="form-group">
+                                <label>Option C *</label>
+                                <input type="text" class="quiz-option-c" placeholder="Answer C" required>
+                            </div>
+                        </div>
+                        <div class="form-row">
+                            <div class="form-group">
+                                <label>Correct Answer *</label>
+                                <select class="quiz-correct" required>
+                                    <option value="A">A</option>
+                                    <option value="B">B</option>
+                                    <option value="C">C</option>
+                                </select>
+                            </div>
+                        </div>
+                        <div class="form-group">
+                            <label>Explain (shown after answer)</label>
+                            <input type="text" class="quiz-explain" placeholder="Brief explanation of the answer">
+                        </div>
+                    </div>
+                </div>
+
+                <div style="display: flex; gap: 1rem; margin-bottom: 1.5rem;">
+                    <button type="button" id="addQuizBtn" class="btn btn-secondary" style="flex: 1;">
+                        ➕ Add Another Quiz
+                    </button>
+                    <button type="button" id="removeQuizBtn" class="btn btn-secondary"
+                        style="flex: 1; background: #dc2626;">
+                        ➖ Remove Last Quiz
+                    </button>
+                </div>
+
+                <button type="submit" class="btn btn-primary" style="width: 100%;">🎯 Generate Quiz Video</button>
+            </form>
+
+            <div id="quizStatus" class="status hidden"></div>
+        </div>
+    </div>
+
     <script>
         // Tab switching
         document.querySelectorAll('.tab-btn').forEach(btn => {
@@ -1008,6 +1082,149 @@
             }
         });
 
+        // ==========================================
+        // QUIZ REEL MODULE
+        // ==========================================
+
+        let quizCount = 1;
+
+        // Add Quiz button
+        document.getElementById('addQuizBtn').addEventListener('click', () => {
+            quizCount++;
+            const container = document.getElementById('quizContainer');
+            const quizHtml = `
+                <div class="quiz-item" style="background: var(--bg-secondary); padding: 1.5rem; border-radius: 12px; margin-bottom: 1rem;">
+                    <h4 style="color: var(--accent); margin-bottom: 1rem;">Quiz ${quizCount}</h4>
+                    <div class="form-group">
+                        <label>Hook (Category)</label>
+                        <input type="text" class="quiz-hook" placeholder="e.g., IQ TEST, MATH QUIZ">
+                    </div>
+                    <div class="form-group">
+                        <label>Question *</label>
+                        <input type="text" class="quiz-question" placeholder="Enter your question" required>
+                    </div>
+                    <div class="form-row">
+                        <div class="form-group">
+                            <label>Option A *</label>
+                            <input type="text" class="quiz-option-a" placeholder="Answer A" required>
+                        </div>
+                        <div class="form-group">
+                            <label>Option B *</label>
+                            <input type="text" class="quiz-option-b" placeholder="Answer B" required>
+                        </div>
+                        <div class="form-group">
+                            <label>Option C *</label>
+                            <input type="text" class="quiz-option-c" placeholder="Answer C" required>
+                        </div>
+                    </div>
+                    <div class="form-row">
+                        <div class="form-group">
+                            <label>Correct Answer *</label>
+                            <select class="quiz-correct" required>
+                                <option value="A">A</option>
+                                <option value="B">B</option>
+                                <option value="C">C</option>
+                            </select>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label>Explain (shown after answer)</label>
+                        <input type="text" class="quiz-explain" placeholder="Brief explanation">
+                    </div>
+                </div>
+            `;
+            container.insertAdjacentHTML('beforeend', quizHtml);
+        });
+
+        // Remove Quiz button
+        document.getElementById('removeQuizBtn').addEventListener('click', () => {
+            const container = document.getElementById('quizContainer');
+            const items = container.querySelectorAll('.quiz-item');
+            if (items.length > 1) {
+                items[items.length - 1].remove();
+                quizCount--;
+            }
+        });
+
+        // Quiz status polling
+        async function pollQuizStatus(jobId, statusDiv) {
+            const checkStatus = async () => {
+                try {
+                    const res = await fetch(`/api/quiz/${jobId}/status`);
+                    const status = await res.json();
+
+                    if (status.status === 'ready') {
+                        statusDiv.className = 'status success';
+                        statusDiv.innerHTML = `✅ Video Ready! <a href="${status.video_url}" target="_blank" style="color: var(--accent);">Download Video</a>`;
+                        return;
+                    } else if (status.status === 'failed') {
+                        statusDiv.className = 'status error';
+                        statusDiv.innerHTML = `❌ Failed: ${status.error}`;
+                        return;
+                    } else {
+                        statusDiv.innerHTML = `⏳ ${status.status}... ${status.progress}%`;
+                        setTimeout(checkStatus, 2000);
+                    }
+                } catch (err) {
+                    statusDiv.className = 'status error';
+                    statusDiv.innerHTML = `❌ Error: ${err.message}`;
+                }
+            };
+            checkStatus();
+        }
+
+        // Quiz Form submission
+        document.getElementById('quizForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const status = document.getElementById('quizStatus');
+            status.className = 'status';
+            status.classList.remove('hidden');
+            status.innerHTML = '⏳ Starting quiz video generation...';
+
+            // Collect all quizzes
+            const quizItems = document.querySelectorAll('.quiz-item');
+            const quizzes = [];
+
+            quizItems.forEach(item => {
+                quizzes.push({
+                    hook: item.querySelector('.quiz-hook').value || '',
+                    question: item.querySelector('.quiz-question').value,
+                    options: {
+                        A: item.querySelector('.quiz-option-a').value,
+                        B: item.querySelector('.quiz-option-b').value,
+                        C: item.querySelector('.quiz-option-c').value
+                    },
+                    correct: item.querySelector('.quiz-correct').value,
+                    explain: item.querySelector('.quiz-explain').value || ''
+                });
+            });
+
+            const data = {
+                quizzes: quizzes,
+                voice: 'af_heart'
+            };
+
+            try {
+                const res = await fetch('/api/quiz/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(data)
+                });
+                const result = await res.json();
+
+                if (result.job_id) {
+                    status.innerHTML = `⏳ Job started: ${result.job_id} (${quizzes.length} quizzes)`;
+                    pollQuizStatus(result.job_id, status);
+                } else {
+                    status.className = 'status error';
+                    status.innerHTML = `❌ Error: ${result.detail || 'Failed to start'}`;
+                }
+            } catch (err) {
+                status.className = 'status error';
+                status.innerHTML = '❌ Error: ' + err.message;
+            }
+        });
+
         // ==========================================
         // GEMINI CHATBOT TEST
         // ==========================================