# Copy application code
 COPY . /blt
 
+# Install Python dependencies
+RUN pip install -r requirements.txt
+RUN pip install youtube-transcript-api openai
+
 # Convert line endings and set permissions
 RUN dos2unix Dockerfile docker-compose.yml scripts/entrypoint.sh ./blt/settings.py
 # Check if .env exists and run dos2unix on it, otherwise skip
 RUN if [ -f /blt/.env ]; then dos2unix /blt/.env; fi
 RUN chmod +x /blt/scripts/entrypoint.sh
 
 ENTRYPOINT ["/blt/scripts/entrypoint.sh"]
 CMD ["poetry", "run", "python", "manage.py", "runserver", "0.0.0.0:8000"]
-
-RUN pip install -r requirements.txt
-RUN pip install youtube-transcript-api openai

     def save(self, *args, **kwargs):
         import re
-        youtube_regex = r'(?:youtube\.com\/watch\?v=|youtu\.be\/)([^&\n?#]+)'
+        youtube_regex = r'(?:youtube(?:-nocookie)?\.com\/(?:watch\?v=|embed\/|v\/)|youtu\.be\/)([^&\n?#]+)'
         match = re.search(youtube_regex, self.youtube_url)
         if match:
             self.youtube_id = match.group(1)
+        elif not self.youtube_id:
+            # Fallback: try to extract from query params or path
+            from urllib.parse import urlparse, parse_qs
+            parsed = urlparse(self.youtube_url)
+            if 'v' in parse_qs(parsed.query):
+                self.youtube_id = parse_qs(parsed.query)['v'][0]
         super().save(*args, **kwargs)

 def generate_ai_summary_and_verify(youtube_id, title, transcript):
     """
     Use OpenAI to generate summary and verify if content is educational.
     Returns (summary_text, is_educational_bool).
     """
     if not client:
-        print("DEBUG: OpenAI client not initialized (OPENAI_API_KEY missing)")
+        logger.warning("OpenAI client not initialized (OPENAI_API_KEY missing)")
         return None, False
 
     if not openai_api_key:
-        print("DEBUG: OPENAI_API_KEY is missing")
+        logger.warning("OPENAI_API_KEY is missing")
         return None, False
 
     if not transcript:
-        print(f"DEBUG: no transcript provided for video {youtube_id}")
+        logger.warning(f"No transcript provided for video {youtube_id}")
         return None, False
 
     try:
         response = client.chat.completions.create(
             model="gpt-3.5-turbo",
             messages=[
                 {
                     "role": "system",
                     "content": (
                         "You are an educational content expert. "
                         "Analyze the video transcript and determine if it's educational/security-related content. "
                         "Respond in JSON format with 'summary' and 'is_educational' fields."
                     ),
                 },
                 {
                     "role": "user",
                     "content": (
                         f"Video Title: {title}\n\nTranscript:\n{transcript}\n\n"
                         "Provide a brief (100-150 word) summary and determine if this is educational security content. "
                         "Respond ONLY with valid JSON using double quotes, like this:\n"
                         '{"summary": "...", "is_educational": true}'
                     ),
                 },
             ],
             max_tokens=500,
-            temperature=0.7,
+            temperature=0.3,
+            timeout=30,
         )
 
         content = response.choices[0].message.content
-        print(f"DEBUG: raw OpenAI content for {youtube_id}: {content[:100]}...")  # First 100 chars
+        logger.debug(f"Raw OpenAI response for {youtube_id}: {content[:100]}...")
 
         # Strip code fences if model wraps JSON in ``` (triple backticks)
         content_stripped = content.strip()
         if content_stripped.startswith("```"):
             lines = content_stripped.splitlines()
             # Remove first line (opening fence)
             if len(lines) > 1:
                 lines = lines[1:]
             # Remove last line if it's a closing fence
             if lines and lines[-1].strip().startswith("```"):
                 lines = lines[:-1]
             content_stripped = "\n".join(lines).strip()
 
         data = json.loads(content_stripped)
         summary = data.get("summary", "")
         is_educational = data.get("is_educational", False)
 
-        print(
-            f"DEBUG: parsed summary_present={bool(summary)}, "
-            f"is_educational={is_educational}"
-        )
+        logger.info(f"Generated summary for {youtube_id}: summary_present={bool(summary)}, is_educational={is_educational}")
         return summary, is_educational
 
     except json.JSONDecodeError as e:
-        print(f"DEBUG: JSON decode error for {youtube_id}: {e}")
-        print(f"DEBUG: content that failed to parse: {content_stripped[:200]}")
+        logger.error(f"JSON decode error for {youtube_id}: {e}")
+        logger.debug(f"Content that failed to parse: {content_stripped[:200]}")
         return None, False
     except Exception as e:
-        print(f"DEBUG: OpenAI error for {youtube_id}: {e}")
+        logger.error(f"OpenAI API error for {youtube_id}: {e}")
         return None, False

 def generate_quiz_from_transcript(youtube_id, transcript, title):
     """
     Generate 5-10 quiz questions from transcript using OpenAI.
     Returns list of question dicts or empty list on error.
     """
     if not client:
-        print(f"DEBUG: OpenAI client not initialized, skipping quiz for {youtube_id}")
+        logger.warning(f"OpenAI client not initialized, skipping quiz for {youtube_id}")
         return []
 
     if not openai_api_key:
-        print(f"DEBUG: OPENAI_API_KEY missing, skipping quiz for {youtube_id}")
+        logger.warning(f"OPENAI_API_KEY missing, skipping quiz for {youtube_id}")
         return []
 
     if not transcript:
-        print(f"DEBUG: no transcript for quiz generation for {youtube_id}")
+        logger.warning(f"No transcript for quiz generation for {youtube_id}")
         return []
 
     try:
         response = client.chat.completions.create(
             model="gpt-3.5-turbo",
             messages=[
                 {
                     "role": "system",
                     "content": (
                         "You are a quiz generator expert. Create educational multiple-choice questions "
                         "based on the video content. Respond ONLY with valid JSON array."
                     ),
                 },
                 {
                     "role": "user",
                     "content": (
                         f"Create 5 multiple-choice questions from this video on '{title}':\n\n{transcript}\n\n"
                         "Respond ONLY with valid JSON array in this exact format:\n"
                         "[\n"
                         "  {\n"
                         '    "question": "What is...?",\n'
                         '    "option_a": "Answer A",\n'
                         '    "option_b": "Answer B",\n'
                         '    "option_c": "Answer C",\n'
                         '    "option_d": "Answer D",\n'
                         '    "correct_answer": "A",\n'
                         '    "explanation": "The correct answer is..."\n'
                         "  }\n"
                         "]"
                     ),
                 },
             ],
             max_tokens=2000,
             temperature=0.7,
+            timeout=30,
         )
 
         content = response.choices[0].message.content
-        print(f"DEBUG: raw quiz content for {youtube_id}: {content[:100]}...")
+        logger.debug(f"Raw quiz response for {youtube_id}: {content[:100]}...")
 
         # Strip code fences if present (triple backticks)
         content_stripped = content.strip()
         if content_stripped.startswith("```"):
             lines = content_stripped.splitlines()
             if len(lines) > 1:
                 lines = lines[1:]
             if lines and lines[-1].strip().startswith("```"):
                 lines = lines[:-1]
             content_stripped = "\n".join(lines).strip()
 
         questions = json.loads(content_stripped)
-        print(f"DEBUG: parsed {len(questions)} quiz questions for {youtube_id}")
+        logger.info(f"Generated {len(questions)} quiz questions for {youtube_id}")
         return questions[:10]  # Limit to 10 questions
 
     except json.JSONDecodeError as e:
-        print(f"DEBUG: quiz JSON decode error for {youtube_id}: {e}")
+        logger.error(f"Quiz JSON decode error for {youtube_id}: {e}")
         return []
     except Exception as e:
-        print(f"DEBUG: quiz generation error for {youtube_id}: {e}")
+        logger.error(f"Quiz generation error for {youtube_id}: {e}")
         return []

     # Handle YouTube video submission with AI processing
     if request.method == "POST":
-        print("DEBUG: education_home POST reached")
+        logger.info("Processing YouTube video submission")
         youtube_url = request.POST.get("youtube_url", "").strip()
         title = request.POST.get("video_title", "").strip()
         description = request.POST.get("video_description", "").strip()
 
-        print(f"DEBUG: raw POST values title={repr(title)}, url={repr(youtube_url)}")
+        logger.debug(f"Received submission: title={title}, url={youtube_url}")
 
         if youtube_url and title:
-            print(f"DEBUG: got title and url {title} {youtube_url}")
+            logger.info(f"Processing video: {title}")
             try:
                 # Extract video ID from URL
                 match = re.search(
                     r'(?:youtube\.com\/watch\?v=|youtu\.be\/)([^&\n?#]+)',
                     youtube_url
                 )
                 if not match:
                     messages.error(request, "Invalid YouTube URL format.")
                     return redirect("education")
 
                 youtube_id = match.group(1)
-                print(f"DEBUG: extracted youtube_id={youtube_id}")
+                logger.info(f"Extracted YouTube ID: {youtube_id}")
 
                 # Step 1: Get transcript
-                print("DEBUG: calling get_youtube_transcript")
                 transcript = get_youtube_transcript(youtube_id)
-                print(f"DEBUG: transcript present? {bool(transcript)}")
 
                 # Step 2: Generate summary and educational verification
-                print("DEBUG: calling generate_ai_summary_and_verify")
                 summary, is_verified = generate_ai_summary_and_verify(
                     youtube_id, title, transcript
                 )
 
                 # Step 3: Create video record
                 video = EducationalVideo.objects.create(
                     title=title,
                     youtube_url=youtube_url,
                     youtube_id=youtube_id,
                     description=description,
                     ai_summary=summary or "",
                     is_verified=is_verified,
                 )
-                print(f"DEBUG: created video record with id={video.id}")
+                logger.info(f"Created video record: {video.id}")
 
                 # Step 4: Generate quiz questions (only if transcript exists)
                 if transcript:
-                    print("DEBUG: calling generate_quiz_from_transcript")
                     quiz_questions = generate_quiz_from_transcript(
                         youtube_id, transcript, title
                     )
-                    print(f"DEBUG: quiz_questions returned: {len(quiz_questions)} questions")
+                    logger.info(f"Generated {len(quiz_questions)} quiz questions for video {video.id}")
 
                     for q_data in quiz_questions:
                         try:
                             VideoQuizQuestion.objects.create(
                                 video=video,
                                 question=q_data.get("question", ""),
                                 option_a=q_data.get("option_a", ""),
                                 option_b=q_data.get("option_b", ""),
                                 option_c=q_data.get("option_c", ""),
                                 option_d=q_data.get("option_d", ""),
                                 correct_answer=q_data.get("correct_answer", "A"),
                                 explanation=q_data.get("explanation", ""),
                             )
-                            print(f"DEBUG: created quiz question for video {video.id}")
                         except Exception as q_err:
-                            print(f"DEBUG: error creating quiz question: {q_err}")
+                            logger.error(f"Error creating quiz question for video {video.id}: {q_err}")
                 else:
-                    print(f"DEBUG: skipping quiz generation, no transcript for {youtube_id}")
+                    logger.info(f"Skipping quiz generation for {youtube_id}: no transcript available")
 
                 messages.success(
                     request,
                     "Video added successfully with AI-generated content!"
                 )
                 return redirect("education")
 
             except Exception as e:
-                print(f"DEBUG: exception in POST handler: {e}")
-                import traceback
-                traceback.print_exc()
+                logger.exception(f"Error processing video submission: {e}")
                 messages.error(request, f"Error processing video: {str(e)}")
                 return redirect("education")

     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         video = self.object
         context["quiz_questions"] = VideoQuizQuestion.objects.filter(video=video)
+        context["options"] = [
+            (video.option_a, 'A'),
+            (video.option_b, 'B'),
+            (video.option_c, 'C'),
+            (video.option_d, 'D')
+        ]
         if self.request.user.is_authenticated:
             context["quiz_history"] = QuizAttempt.objects.filter(
                 user=self.request.user, video=video
             )
         return context

     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         video = self.object
         context["quiz_questions"] = VideoQuizQuestion.objects.filter(video=video)
+        # Provide option labels for template iteration
+        context["options"] = [
+            ('option_a', 'A'),
+            ('option_b', 'B'),
+            ('option_c', 'C'),
+            ('option_d', 'D')
+        ]
         if self.request.user.is_authenticated:
             context["quiz_history"] = QuizAttempt.objects.filter(
                 user=self.request.user, video=video
             )
         return context