"""Download task routes.""" import uuid import os import re import logging from datetime import datetime from fastapi import APIRouter, HTTPException, Depends, BackgroundTasks, Request from fastapi.responses import FileResponse, StreamingResponse from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy import select from app.schemas import DownloadRequest, DownloadResponse, TaskStatus from app.database import get_db, async_session from app.models import Video, DownloadLog from app.auth import get_current_user, optional_auth from app.services.downloader import download_video, get_video_path logger = logging.getLogger(__name__) router = APIRouter(prefix="/api", tags=["download"]) # ── UA parsing ────────────────────────────────────────────────────────────── def _parse_ua(ua: str) -> tuple[str, str]: """Return (browser, device) from User-Agent string.""" ua_lower = ua.lower() # Device if any(k in ua_lower for k in ("bot", "crawler", "spider", "slurp", "curl", "wget", "python", "axios")): device = "bot" elif "tablet" in ua_lower or "ipad" in ua_lower: device = "tablet" elif any(k in ua_lower for k in ("mobile", "android", "iphone", "ipod", "windows phone")): device = "mobile" else: device = "desktop" # Browser if "edg/" in ua_lower or "edghtml" in ua_lower: browser = "Edge" elif "opr/" in ua_lower or "opera" in ua_lower: browser = "Opera" elif "samsungbrowser" in ua_lower: browser = "Samsung" elif "chrome/" in ua_lower: browser = "Chrome" elif "firefox/" in ua_lower: browser = "Firefox" elif "safari/" in ua_lower: browser = "Safari" else: m = re.search(r"(\w+)/[\d.]+$", ua) browser = m.group(1).capitalize() if m else "Unknown" return browser, device def _client_ip(request: Request) -> str: forwarded = request.headers.get("x-forwarded-for") if forwarded: return forwarded.split(",")[0].strip() if request.client: return request.client.host return "" async def _geo_lookup(ip: str) -> tuple[str, str, str]: """Return (country_code, country, city) via ip-api.com. Falls back to empty strings.""" if not ip or ip in ("127.0.0.1", "::1"): return "", "", "" try: import httpx async with httpx.AsyncClient(timeout=5) as client: res = await client.get( f"http://ip-api.com/json/{ip}", params={"fields": "status,countryCode,country,city"}, ) data = res.json() if data.get("status") == "success": return data.get("countryCode", ""), data.get("country", ""), data.get("city", "") except Exception as e: logger.debug(f"Geo lookup failed for {ip}: {e}") return "", "", "" async def _log_download(video_id: int, request: Request): """Write a DownloadLog entry with geo info (fire-and-forget).""" try: ua = request.headers.get("user-agent", "") browser, device = _parse_ua(ua) ip = _client_ip(request) country_code, country, city = await _geo_lookup(ip) async with async_session() as db: db.add(DownloadLog( video_id=video_id, ip=ip, user_agent=ua[:512], browser=browser, device=device, country_code=country_code, country=country, city=city, downloaded_at=datetime.utcnow(), )) await db.commit() except Exception as e: logger.warning(f"Failed to log download: {e}") async def _do_download(task_id: str, url: str, format_id: str): """Background download task.""" from app.database import async_session async with async_session() as db: video = (await db.execute(select(Video).where(Video.task_id == task_id))).scalar_one_or_none() if not video: return try: video.status = "downloading" await db.commit() def update_progress(pct): pass # Progress tracking in sync context is complex; keep simple result = download_video(url, format_id, progress_callback=update_progress) video.title = result["title"] video.thumbnail = result["thumbnail"] video.duration = result["duration"] video.filename = result["filename"] video.file_path = result["file_path"] video.file_size = result["file_size"] video.platform = result["platform"] video.status = "done" video.progress = 100 await db.commit() except Exception as e: logger.error(f"Download failed for {task_id}: {e}") video.status = "error" video.error_message = str(e)[:500] await db.commit() @router.post("/download", response_model=DownloadResponse) async def start_download(req: DownloadRequest, background_tasks: BackgroundTasks, db: AsyncSession = Depends(get_db)): # Dedup: reuse existing completed download if file still on disk existing = (await db.execute( select(Video).where( Video.url == req.url, Video.format_id == req.format_id, Video.status == "done", ).order_by(Video.created_at.desc()).limit(1) )).scalar_one_or_none() if existing and os.path.exists(existing.file_path): logger.info(f"Reusing existing download task_id={existing.task_id} for url={req.url} format={req.format_id}") return DownloadResponse(task_id=existing.task_id, status="done") task_id = str(uuid.uuid4())[:8] video = Video(task_id=task_id, url=req.url, quality=req.quality, format_id=req.format_id, status="pending") db.add(video) await db.commit() background_tasks.add_task(_do_download, task_id, req.url, req.format_id) return DownloadResponse(task_id=task_id, status="pending") @router.get("/download/{task_id}", response_model=TaskStatus) async def get_download_status(task_id: str, db: AsyncSession = Depends(get_db)): video = (await db.execute(select(Video).where(Video.task_id == task_id))).scalar_one_or_none() if not video: raise HTTPException(status_code=404, detail="Task not found") return TaskStatus( task_id=video.task_id, status=video.status, progress=video.progress, title=video.title, error_message=video.error_message or "", video_id=video.id if video.status == "done" else None, ) @router.get("/file/{video_id}") async def download_file(video_id: int, request: Request, background_tasks: BackgroundTasks, user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)): video = (await db.execute(select(Video).where(Video.id == video_id))).scalar_one_or_none() if not video or video.status != "done": raise HTTPException(status_code=404, detail="Video not found") if not os.path.exists(video.file_path): raise HTTPException(status_code=404, detail="File not found on disk") background_tasks.add_task(_log_download, video.id, request) return FileResponse(video.file_path, filename=video.filename, media_type="video/mp4") @router.get("/stream/{video_id}") async def stream_video(video_id: int, request: Request, background_tasks: BackgroundTasks, token: str = None, user: dict = Depends(optional_auth), db: AsyncSession = Depends(get_db)): # Allow token via query param for video player if not user and token: from app.auth import verify_token user = verify_token(token) if not user: from fastapi import HTTPException, status raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Authentication required") video = (await db.execute(select(Video).where(Video.id == video_id))).scalar_one_or_none() if not video or video.status != "done": raise HTTPException(status_code=404, detail="Video not found") if not os.path.exists(video.file_path): raise HTTPException(status_code=404, detail="File not found on disk") background_tasks.add_task(_log_download, video.id, request) def iter_file(): with open(video.file_path, "rb") as f: while chunk := f.read(1024 * 1024): yield chunk return StreamingResponse(iter_file(), media_type="video/mp4", headers={ "Content-Disposition": f"inline; filename={video.filename}", "Content-Length": str(video.file_size), }) @router.get("/file/task/{task_id}") async def download_file_by_task(task_id: str, request: Request, background_tasks: BackgroundTasks, db: AsyncSession = Depends(get_db)): """Download file by task_id - no auth required (public download).""" video = (await db.execute(select(Video).where(Video.task_id == task_id))).scalar_one_or_none() if not video or video.status != "done": raise HTTPException(status_code=404, detail="Video not found") if not os.path.exists(video.file_path): raise HTTPException(status_code=404, detail="File not found on disk") background_tasks.add_task(_log_download, video.id, request) return FileResponse(video.file_path, filename=video.filename, media_type="video/mp4")