1.2

src/api/main.py

@@ -1,67 +1,19 @@
-import uuid
 from datetime import datetime
-from typing import Dict
-from enum import Enum
 from contextlib import asynccontextmanager
 
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, HttpUrl
 
 # POT Server and Routers
 from src.api.pot_server import pot_server 
-from src.auth.dependencies import get_current_user
 from src.api.auth_routes import router as auth_router
 from src.api.notes_routes import router as notes_router
 from src.api.recommendation_routes import router as recommendation_router
 from src.utils.logger import setup_logger
 
-from src.transcription.transcript_fetcher import TranscriptFetcher
-from src.transcription.whisper_transcriber import WhisperTranscriber
-from src.summarization.note_generator import NoteGenerator
-from src.api.downloader import YouTubeDownloader
-from src.db.firebase import get_firebase_db
-from src.db.models import Note, User
-
 logger = setup_logger(__name__)
 
 
-# --- Models ---
-class TaskStatus(str, Enum):
-    PENDING = "pending"
-    DOWNLOADING = "downloading"
-    TRANSCRIBING = "transcribing"
-    GENERATING_NOTES = "generating_notes"
-    COMPLETED = "completed"
-    FAILED = "failed"
-
-
-class GenerateNotesRequest(BaseModel):
-    youtube_url: HttpUrl
-    language: str = "en"
-
-
-class TaskResponse(BaseModel):
-    task_id: str
-    status: TaskStatus
-    message: str
-
-
-class TaskStatusResponse(BaseModel):
-    status: TaskStatus
-    message: str = ""
-    youtube_url: str | None = None
-    user_id: str | None = None
-    created_at: datetime | None = None
-    notes: str | None = None
-    topics: list | None = []
-    keyPoints: list | None = []
-
-
-# Global task storage
-tasks: Dict[str, Dict] = {}
-
-
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     print("🚀 Lifespan: Starting POT solver server (bgutil v1.3.1)...")
@@ -142,140 +94,3 @@ async def health_check():
         "timestamp": datetime.now()
     }
 
-
-@app.post("/generate", response_model=TaskResponse)
-async def generate(
-    request: GenerateNotesRequest,
-    background_tasks: BackgroundTasks,
-    current_user: User = Depends(get_current_user),
-):
-    task_id = str(uuid.uuid4())
-    user_id = current_user.id
-
-    tasks[task_id] = {
-        "status": TaskStatus.PENDING,
-        "message": "Initializing...",
-        "youtube_url": str(request.youtube_url),
-        "user_id": user_id,
-        "created_at": datetime.now(),
-    }
-
-    background_tasks.add_task(
-        process_video_and_save,
-        task_id,
-        str(request.youtube_url),
-        request.language,
-        user_id,
-    )
-
-    return TaskResponse(
-        task_id=task_id,
-        status=TaskStatus.PENDING,
-        message="Generation started successfully.",
-    )
-
-
-async def transcribeAudio(task_id: str, youtube_url: str, language: str):
-    audio_file = None
-    downloader = YouTubeDownloader()
-    try:
-        video_info = downloader.get_video_info(youtube_url)
-    except Exception as e:
-        logger.warning(f"Metadata extraction failed with yt-dlp: {e}. Trying fallback.")
-        video_info = {
-            "title": "YouTube Video", 
-            "duration": 0
-        }
-
-    tasks[task_id]["status"] = TaskStatus.TRANSCRIBING
-    fetcher = TranscriptFetcher()
-    transcript_text = fetcher.fetch_transcript(youtube_url, languages=[language, 'en'])
-    
-    if transcript_text:
-        logger.info("Using direct YouTube transcript (v8)")
-    else:
-        logger.info("Direct transcript failed. Falling back to audio download + Whisper.")
-        tasks[task_id]["status"] = TaskStatus.DOWNLOADING
-        audio_file = downloader.download_audio(youtube_url, task_id)
-        
-        tasks[task_id]["status"] = TaskStatus.TRANSCRIBING
-        transcriber = WhisperTranscriber()
-        transcript_data = transcriber.transcribe(audio_file, language=language)
-        transcript_text = transcript_data["text"]
-
-    return transcript_text, video_info, audio_file, downloader
-
-
-async def process_video_and_save(
-    task_id: str, youtube_url: str, language: str, user_id: str
-):
-    audio_file = None
-    downloader = None
-    try:
-        # 1. Transcribe Audio
-        transcript_text, video_info, audio_file, downloader = await transcribeAudio(
-            task_id, youtube_url, language
-        )
-
-        # 2. Generate Summary
-        tasks[task_id]["status"] = TaskStatus.GENERATING_NOTES
-        note_gen = NoteGenerator()
-        summary_json = note_gen.generateSummary(transcript_text, video_info["title"])
-
-        final_notes = note_gen.format_final_notes(
-            note_gen.format_notes_to_markdown(summary_json),
-            video_info["title"],
-            youtube_url,
-            video_info["duration"],
-            detected_language=summary_json.get("detected_language", "English"),
-        )
-
-        # Extract key insights from segments for Flutter frontend
-        segments = summary_json.get("segments", [])
-        key_points_list = []
-        for seg in segments:
-            if isinstance(seg, dict) and seg.get("key_insight"):
-                key_points_list.append(seg["key_insight"])
-
-        # Extract video_id from URL for thumbnail
-        import re
-        video_id_match = re.search(r'(?:v=|/)([0-9A-Za-z_-]{11})', youtube_url)
-        video_id = video_id_match.group(1) if video_id_match else ""
-
-        db = get_firebase_db()
-        if db:
-            note_data = {
-                "userId": user_id,
-                "videoUrl": youtube_url,
-                "videoTitle": video_info["title"],
-                "notes": final_notes,
-                "thumbnail": f"https://img.youtube.com/vi/{video_id}/mqdefault.jpg" if video_id else "",
-                "category": summary_json.get("topics", []),
-                "keyPoints": key_points_list,
-                "createdAt": datetime.utcnow(),
-                "updatedAt": datetime.utcnow(),
-                "isFavorite": False,
-            }
-            db.collection("notes").add(note_data)
-        else:
-            logger.warning("Firestore not initialized, note not saved to DB but generated in memory.")
-
-        tasks[task_id]["notes"] = final_notes
-        tasks[task_id]["topics"] = summary_json.get("topics", [])
-        tasks[task_id]["keyPoints"] = key_points_list
-        tasks[task_id]["status"] = TaskStatus.COMPLETED
-    except Exception as e:
-        error_msg = str(e)
-        logger.error(f"Task failed: {error_msg}")
-        tasks[task_id]["status"] = TaskStatus.FAILED
-        tasks[task_id]["message"] = f"Error: {error_msg}"
-    finally:
-        if downloader and audio_file and audio_file.exists():
-            downloader.cleanup(audio_file)
-
-
-@app.get("/status/{task_id}", response_model=TaskStatusResponse)
-async def get_task_status(task_id: str):
-    if task_id not in tasks:
-        raise HTTPException(status_code=404, detail="Task not found")
-    return tasks[task_id]

src/api/notes_routes.py

@@ -266,24 +266,23 @@ async def process_video_task(task_id: str, youtube_url: str, language: str, user
     downloader = YouTubeDownloader()
     
     try:
-        # استخراج الـ Video ID للعرض فقط
+        # Extract video ID for thumbnail
         video_id_match = re.search(r"(?:v=|youtu\.be/)([A-Za-z0-9_-]{11})", youtube_url)
-        video_id = video_id_match.group(1) if video_id_match else "unknown"
+        video_id = video_id_match.group(1) if video_id_match else ""
         video_title = "YouTube Video"
 
-        # الخطوة 1: استخدام نظام "الشلال" الموحد
-        # الدالة دي جواها دلوقتي (YouTube API -> AssemblyAI -> yt-dlp)
+        # Step 1: Transcribe
         tasks[task_id]["status"] = "transcribing"
         tasks[task_id]["message"] = "Processing transcript through optimized pipeline..."
         
         transcript_text = downloader.get_transcript(youtube_url)
 
-        # الخطوة 2: توليد الملاحظات بالـ AI
+        # Step 2: Generate AI summary
         tasks[task_id]["status"] = "generating_notes"
         note_gen = NoteGenerator()
         summary_json = note_gen.generateSummary(transcript_text, video_title)
 
-        # استخراج مدة الفيديو الحقيقية بدلاً من الصفر المبرمج
+        # Step 3: Fetch video duration
         tasks[task_id]["message"] = "Fetching video metadata..."
         video_duration = get_youtube_duration(youtube_url)
 
@@ -295,19 +294,40 @@ async def process_video_task(task_id: str, youtube_url: str, language: str, user
             detected_language=summary_json.get("detected_language", "English"),
         )
 
-        # الخطوة 3: الحفظ في Firebase
+        # Step 4: Extract key insights from segments
+        segments = summary_json.get("segments", [])
+        key_points_list = []
+        for seg in segments:
+            if isinstance(seg, dict) and seg.get("key_insight"):
+                key_points_list.append(seg["key_insight"])
+
+        # Step 5: Classify topics into predefined categories
+        from src.summarization.topic_classifier import classify_topics
+        raw_topics = summary_json.get("topics", [])
+        categories = classify_topics(raw_topics) if raw_topics else ["Education & Science"]
+
+        # Step 6: SINGLE Firestore write — unified camelCase schema matching note.txt
         db = get_firebase_db()
         if db:
-            db.collection("notes").add({
-                "user_id": user_id,
-                "video_url": youtube_url,
-                "video_title": video_title,
-                "summary_content": final_markdown,
-                "created_at": datetime.utcnow()
-            })
+            note_data = {
+                "userId": user_id,
+                "videoUrl": youtube_url,
+                "videoTitle": video_title,
+                "notes": final_markdown,
+                "thumbnail": f"https://img.youtube.com/vi/{video_id}/mqdefault.jpg" if video_id else "",
+                "category": categories,
+                "keyPoints": key_points_list,
+                "createdAt": datetime.utcnow(),
+                "updatedAt": datetime.utcnow(),
+                "isFavorite": False,
+            }
+            db.collection("notes").add(note_data)
+            logger.info(f"✅ Note saved to Firestore for user {user_id}")
 
         tasks[task_id]["status"] = "completed"
         tasks[task_id]["notes"] = final_markdown
+        tasks[task_id]["topics"] = categories
+        tasks[task_id]["keyPoints"] = key_points_list
         logger.info(f"✅ Task {task_id} completed successfully!")
 
     except Exception as e: