api_server.py

#!/usr/bin/env python3
"""
Text Extraction API Server

A FastAPI-based REST API for extracting text from various file types.
Supports file uploads, URL processing, YouTube content, and batch operations.
"""

import os
import tempfile
import time
import uuid
import logging
from datetime import datetime
from pathlib import Path
from typing import List, Optional, Dict, Any
import asyncio
import aiohttp
import traceback

import aiofiles
from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks, Depends, Query
from fastapi.responses import JSONResponse, PlainTextResponse, FileResponse
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.trustedhost import TrustedHostMiddleware
from fastapi.security import HTTPBearer
from pydantic import BaseModel, HttpUrl, Field
import uvicorn

from src.text_extractor import TextExtractor
from src.config import Config
from src.youtube_mp3_service import YouTubeMP3TranscriptionService, TranscriptionResult
from src.file_processors.tts_processor import TTSProcessor
from src.file_processors.translation_processor import TranslationProcessor

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Initialize FastAPI app
app = FastAPI(
    title="AI Content Processing API",
    description="Extract text from various file types using OpenAI GPT and Google Gemini APIs",
    version="2.0.0",
    docs_url="/docs",
    redoc_url="/redoc",
    contact={
        "name": "AI Content Processing Team",
        "email": "support@ai-content-process.com",
    },
    license_info={
        "name": "MIT",
        "url": "https://opensource.org/licenses/MIT",
    },
)

# Security
security = HTTPBearer()

# Add security middleware
app.add_middleware(TrustedHostMiddleware, allowed_hosts=["*"])

# Add CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Configure for production: ["https://yourdomain.com"]
    allow_credentials=True,
    allow_methods=["GET", "POST"],
    allow_headers=["*"],
)

# Global instances
extractor: Optional[TextExtractor] = None
youtube_mp3_service: Optional[YouTubeMP3TranscriptionService] = None
tts_processor: Optional[TTSProcessor] = None
translation_processor: Optional[TranslationProcessor] = None

# Pydantic Models
class FileInfo(BaseModel):
    """File information model."""
    name: str = Field(..., description="Original filename")
    extension: str = Field(..., description="File extension")
    size_mb: float = Field(..., description="File size in megabytes")
    mime_type: str = Field(..., description="MIME type of the file")
    duration: Optional[int] = Field(None, description="Duration in seconds for video/audio files")
    chunks_processed: Optional[int] = Field(None, description="Number of chunks processed")
    url: Optional[str] = Field(None, description="Original URL for web-based content")

class ExtractionResult(BaseModel):
    """Single file extraction result."""
    file_id: str = Field(..., description="Unique identifier for this extraction")
    file_info: FileInfo = Field(..., description="File metadata")
    success: bool = Field(..., description="Whether extraction was successful")
    error: Optional[str] = Field(None, description="Error message if failed")
    extracted_text: Optional[str] = Field(None, description="Extracted text content")
    processor_used: Optional[str] = Field(None, description="Processor that handled the file")
    processing_time: float = Field(..., description="Processing time in seconds")
    text_length: int = Field(..., description="Length of extracted text")
    timestamp: str = Field(..., description="Extraction timestamp")

class BatchExtractionResult(BaseModel):
    """Batch extraction result."""
    batch_id: str = Field(..., description="Unique batch identifier")
    total_files: int = Field(..., description="Total number of files processed")
    successful: int = Field(..., description="Number of successful extractions")
    failed: int = Field(..., description="Number of failed extractions")
    total_processing_time: float = Field(..., description="Total processing time")
    total_characters: int = Field(..., description="Total characters extracted")
    results: List[ExtractionResult] = Field(..., description="Individual extraction results")
    timestamp: str = Field(..., description="Batch processing timestamp")

class HealthResponse(BaseModel):
    """Health check response."""
    status: str = Field(..., description="Service status")
    message: str = Field(..., description="Status message")
    supported_extensions: Dict[str, List[str]] = Field(..., description="Supported file extensions by processor")
    api_keys_configured: Dict[str, bool] = Field(..., description="API key configuration status")
    version: str = Field(..., description="API version")

class ErrorResponse(BaseModel):
    """Error response model."""
    error: str = Field(..., description="Error type")
    detail: str = Field(..., description="Error details")
    timestamp: str = Field(..., description="Error timestamp")
    request_id: Optional[str] = Field(None, description="Request identifier")

class ImageTranscriptionResult(BaseModel):
    """Image transcription result with structured data."""
    file_id: str = Field(..., description="Unique identifier for this transcription")
    file_info: FileInfo = Field(..., description="File metadata")
    success: bool = Field(..., description="Whether transcription was successful")
    error: Optional[str] = Field(None, description="Error message if failed")
    title: Optional[str] = Field(None, description="Generated title for the image")
    description: Optional[str] = Field(None, description="Detailed description of the image")
    extracted_text: Optional[str] = Field(None, description="Text extracted from the image (OCR)")
    processor_used: Optional[str] = Field(None, description="Vision processor that handled the image")
    processing_time: float = Field(..., description="Processing time in seconds")
    timestamp: str = Field(..., description="Transcription timestamp")

class ImageURLRequest(BaseModel):
    """Image URL transcription request."""
    url: HttpUrl = Field(..., description="URL of the image to transcribe")

class URLRequest(BaseModel):
    """Single URL processing request."""
    url: HttpUrl = Field(..., description="URL to process")
    filename: Optional[str] = Field(None, description="Custom filename")

class URLBatchRequest(BaseModel):
    """Batch URL processing request."""
    urls: List[HttpUrl] = Field(..., description="List of URLs to process")
    filenames: Optional[List[str]] = Field(None, description="Custom filenames")

class YouTubeRequest(BaseModel):
    """YouTube content processing request."""
    url: HttpUrl = Field(..., description="YouTube URL")
    title: Optional[str] = Field(None, description="Custom title")
    extract_audio_only: Optional[bool] = Field(False, description="Extract audio only")

class YouTubeBatchRequest(BaseModel):
    """Batch YouTube processing request."""
    urls: List[HttpUrl] = Field(..., description="List of YouTube URLs")
    titles: Optional[List[str]] = Field(None, description="Custom titles")
    extract_audio_only: Optional[bool] = Field(False, description="Extract audio only")

class YouTubeMP3Request(BaseModel):
    """YouTube MP3 transcription request."""
    url: HttpUrl = Field(..., description="YouTube URL to transcribe", example="https://www.youtube.com/watch?v=dQw4w9WgXcQ")
    keep_mp3: Optional[bool] = Field(False, description="Keep downloaded MP3 file after transcription")

class YouTubeMP3Result(BaseModel):
    """YouTube MP3 transcription result."""
    request_id: str = Field(..., description="Unique request identifier")
    success: bool = Field(..., description="Whether transcription was successful")
    video_id: str = Field(..., description="YouTube video ID")
    title: str = Field(..., description="Video title")
    duration: Optional[float] = Field(None, description="Video duration in seconds")
    transcript: Optional[str] = Field(None, description="Full transcript")
    error: Optional[str] = Field(None, description="Error message if failed")
    processing_time: float = Field(..., description="Processing time in seconds")
    audio_file_size_mb: Optional[float] = Field(None, description="Size of downloaded MP3 in MB")
    chunks_processed: int = Field(..., description="Number of audio chunks processed")
    timestamp: str = Field(..., description="Request timestamp")

class TTSRequest(BaseModel):
    """Text-to-speech request for single voice."""
    text: str = Field(..., description="Text to convert to speech", max_length=4096)
    voice: str = Field("alloy", description="Voice to use: alloy, echo, fable, onyx, nova, shimmer")
    model: str = Field("tts-1", description="TTS model: tts-1 or tts-1-hd")
    format: str = Field("mp3", description="Output format: mp3, opus, aac, flac")
    speed: float = Field(1.0, description="Speech speed (0.25 to 4.0)", ge=0.25, le=4.0)

class TTSSegment(BaseModel):
    """Single segment for multi-voice TTS."""
    text: str = Field(..., description="Text for this segment", max_length=4096)
    voice: str = Field(..., description="Voice to use: alloy, echo, fable, onyx, nova, shimmer")
    speaker_name: Optional[str] = Field(None, description="Name of the speaker for this segment")

class TTSMultiVoiceRequest(BaseModel):
    """Text-to-speech request for multiple voices (podcast mode)."""
    segments: List[TTSSegment] = Field(..., description="List of text segments with different voices")
    model: str = Field("tts-1", description="TTS model: tts-1 or tts-1-hd")
    format: str = Field("mp3", description="Output format: mp3, opus, aac, flac")
    speed: float = Field(1.0, description="Speech speed (0.25 to 4.0)", ge=0.25, le=4.0)

class TTSResult(BaseModel):
    """Text-to-speech conversion result."""
    request_id: str = Field(..., description="Unique request identifier")
    success: bool = Field(..., description="Whether conversion was successful")
    error: Optional[str] = Field(None, description="Error message if failed")
    audio_file: Optional[str] = Field(None, description="Path to generated audio file")
    file_size_mb: Optional[float] = Field(None, description="Audio file size in MB")
    voice: Optional[str] = Field(None, description="Voice used")
    model: Optional[str] = Field(None, description="Model used")
    format: Optional[str] = Field(None, description="Audio format")
    speed: Optional[float] = Field(None, description="Speech speed")
    text_length: Optional[int] = Field(None, description="Length of input text")
    processing_time: float = Field(..., description="Processing time in seconds")
    timestamp: str = Field(..., description="Request timestamp")

class TTSMultiVoiceResult(BaseModel):
    """Multi-voice text-to-speech conversion result."""
    request_id: str = Field(..., description="Unique request identifier")
    success: bool = Field(..., description="Whether all conversions were successful")
    segments: List[Dict[str, Any]] = Field(..., description="Results for each segment")
    total_segments: int = Field(..., description="Total number of segments")
    successful_segments: int = Field(..., description="Number of successful conversions")
    failed_segments: int = Field(..., description="Number of failed conversions")
    total_characters: int = Field(..., description="Total characters processed")
    output_directory: Optional[str] = Field(None, description="Directory containing audio files")
    processing_time: float = Field(..., description="Total processing time in seconds")
    timestamp: str = Field(..., description="Request timestamp")


class ProcessingOptions(BaseModel):
    """Processing options for batch operations."""
    parallel: bool = Field(True, description="Use parallel processing")
    max_workers: int = Field(4, description="Maximum number of workers", ge=1, le=16)
    chunk_size: Optional[int] = Field(None, description="Chunk size for large files")

class TranslationRequest(BaseModel):
    """Single text translation request."""
    text: str = Field(..., description="Text to translate", max_length=10000)
    source_language: str = Field(..., description="Source language (e.g., 'en', 'es') or 'auto-detect'/'auto'/'detect' for automatic detection")
    target_language: str = Field(..., description="Target language (e.g., 'en', 'es', 'fr')")
    use_openai: Optional[bool] = Field(False, description="Use OpenAI API (true) or Gemini API (false)")

class TranslationBatchRequest(BaseModel):
    """Batch text translation request."""
    texts: List[str] = Field(..., description="List of texts to translate", max_items=50)
    source_language: str = Field(..., description="Source language (e.g., 'en', 'es') or 'auto-detect'/'auto'/'detect' for automatic detection")
    target_language: str = Field(..., description="Target language (e.g., 'en', 'es', 'fr')")
    use_openai: Optional[bool] = Field(False, description="Use OpenAI API (true) or Gemini API (false)")

class LanguageDetectionRequest(BaseModel):
    """Language detection request."""
    text: str = Field(..., description="Text to analyze for language detection", max_length=5000)
    use_openai: Optional[bool] = Field(False, description="Use OpenAI API (true) or Gemini API (false)")

class TranslationResult(BaseModel):
    """Single text translation result."""
    request_id: str = Field(..., description="Unique request identifier")
    success: bool = Field(..., description="Whether translation was successful")
    original_text: str = Field(..., description="Original text")
    translated_text: Optional[str] = Field(None, description="Translated text")
    source_language: str = Field(..., description="Source language")
    target_language: str = Field(..., description="Target language")
    api_used: Optional[str] = Field(None, description="API used for translation")
    model_used: Optional[str] = Field(None, description="Model used for translation")
    original_length: Optional[int] = Field(None, description="Original text length")
    translated_length: Optional[int] = Field(None, description="Translated text length")
    error: Optional[str] = Field(None, description="Error message if failed")
    processing_time: float = Field(..., description="Processing time in seconds")
    timestamp: str = Field(..., description="Request timestamp")

class TranslationBatchResult(BaseModel):
    """Batch text translation result."""
    batch_id: str = Field(..., description="Unique batch identifier")
    success: bool = Field(..., description="Whether all translations were successful")
    total_texts: int = Field(..., description="Total number of texts processed")
    successful: int = Field(..., description="Number of successful translations")
    failed: int = Field(..., description="Number of failed translations")
    source_language: str = Field(..., description="Source language")
    target_language: str = Field(..., description="Target language")
    results: List[Dict[str, Any]] = Field(..., description="Individual translation results")
    processing_time: float = Field(..., description="Total processing time in seconds")
    timestamp: str = Field(..., description="Batch processing timestamp")

class LanguageDetectionResult(BaseModel):
    """Language detection result."""
    request_id: str = Field(..., description="Unique request identifier")
    success: bool = Field(..., description="Whether detection was successful")
    original_text: str = Field(..., description="Original text analyzed")
    detected_language: Optional[str] = Field(None, description="Detected language")
    confidence: Optional[float] = Field(None, description="Detection confidence (0.0 to 1.0)")
    api_used: Optional[str] = Field(None, description="API used for detection")
    error: Optional[str] = Field(None, description="Error message if failed")
    processing_time: float = Field(..., description="Processing time in seconds")
    timestamp: str = Field(..., description="Request timestamp")

class VideoGenerationRequest(BaseModel):
    """Video generation request model."""
    image_url: HttpUrl = Field(..., description="URL of the source image")
    prompt_text: str = Field("A cinematic video with smooth motion", description="Text prompt describing desired video content")
    ratio: str = Field("1280:720", description="Video aspect ratio (e.g., '1280:720', '1024:1024')")
    duration: int = Field(5, description="Video duration in seconds (5 or 10 for gen4_turbo)", ge=5, le=10)
    model: Optional[str] = Field(None, description="Runway model to use")
    motion_intensity: str = Field("dynamic", description="Motion intensity level: subtle, moderate, dynamic, or cinematic")
    effects: Optional[List[str]] = Field(None, description="List of visual effects to apply (e.g., ['cinematic', 'vibrant', 'glow'])")
    effects_intensity: str = Field("moderate", description="Effects intensity level: subtle, moderate, or strong")
    enhance_motion: bool = Field(True, description="Apply FFmpeg motion enhancement to static videos")

class PromptToVideoRequest(BaseModel):
    """Prompt-to-video generation request model."""
    image_prompt: str = Field(..., description="Text description for image generation", max_length=1000)
    video_prompt: Optional[str] = Field(None, description="Text prompt for video animation (optional)", max_length=1000)
    ratio: str = Field("1280:720", description="Video aspect ratio (e.g., '1280:720', '1024:1024')")
    duration: int = Field(5, description="Video duration in seconds (5 or 10 for gen4_turbo)", ge=5, le=10)
    model: Optional[str] = Field(None, description="Runway model to use")
    motion_intensity: str = Field("dynamic", description="Motion intensity level: subtle, moderate, dynamic, or cinematic")
    voice_type: Optional[str] = Field(None, description="Voice type: male, female, male_deep, male_warm, female_bright, female_soft, or specific voice (alloy, echo, fable, onyx, nova, shimmer)")
    style: Optional[str] = Field(None, description="Narration style: brain_rot, explainer, cartoon, public_text, descriptive, poetic, educational, meditative")
    voice_script_preview: Optional[str] = Field(None, description="Custom script text for narration (overrides style-based generation)", max_length=2000)
    merge_audio: bool = Field(False, description="Merge audio with video using FFmpeg (requires FFmpeg installed)")
    preview_only: bool = Field(False, description="Preview all prompts that will be sent to APIs without generated content")
    effects: Optional[List[str]] = Field(None, description="List of visual effects to apply (e.g., ['cinematic', 'vibrant', 'glow'])")
    effects_intensity: str = Field("moderate", description="Effects intensity level: subtle, moderate, or strong")
    enhance_motion: bool = Field(True, description="Apply FFmpeg motion enhancement to static videos")
    auto_select_model: bool = Field(True, description="Automatically select optimal model for maximum animation quality")
    tiktok_mode: bool = Field(False, description="Optimize video specifically for TikTok (9:16 format, mobile effects)")
    tiktok_style: str = Field("trending", description="TikTok style: trending, viral, aesthetic, engaging")

class VideoGenerationResult(BaseModel):
    """Video generation result model."""
    request_id: str = Field(..., description="Unique request identifier")
    status: str = Field(..., description="Generation status: success, failed, timeout, or error")
    task_id: Optional[str] = Field(None, description="Runway task ID")
    video_url: Optional[str] = Field(None, description="URL of the generated video")
    source_image: str = Field(..., description="Source image URL")
    prompt_text: str = Field(..., description="Text prompt used")
    ratio: str = Field(..., description="Video aspect ratio")
    duration: int = Field(..., description="Video duration in seconds")
    model: str = Field(..., description="Runway model used")
    processing_time_seconds: float = Field(..., description="Total processing time")
    error: Optional[str] = Field(None, description="Error message if failed")
    timestamp: str = Field(..., description="Request timestamp")

# Startup and shutdown events
@app.on_event("startup")
async def startup_event():
    """Initialize the text extractor, YouTube MP3 service, TTS processor, and translation processor on startup."""
    global extractor, youtube_mp3_service, tts_processor, translation_processor
    try:
        logger.info("Initializing AI Content Processing API...")
        extractor = TextExtractor()
        logger.info("✅ Text Extraction API initialized successfully")
        logger.info(f"   OpenAI configured: {bool(Config.OPENAI_API_KEY)}")
        logger.info(f"   Gemini configured: {bool(Config.GOOGLE_API_KEY)}")

        # Initialize YouTube MP3 service if Gemini is available
        if Config.GOOGLE_API_KEY:
            try:
                youtube_mp3_service = YouTubeMP3TranscriptionService()
                logger.info("✅ YouTube MP3 Transcription Service initialized")
            except Exception as e:
                logger.warning(f"⚠️ YouTube MP3 service failed to initialize: {e}")
                youtube_mp3_service = None

        # Initialize TTS processor if OpenAI is available
        if Config.OPENAI_API_KEY:
            try:
                tts_processor = TTSProcessor()
                logger.info("✅ TTS Processor initialized successfully")
            except Exception as e:
                logger.warning(f"⚠️ TTS processor failed to initialize: {e}")
                tts_processor = None

        # Initialize Translation processor if either API is available
        if Config.OPENAI_API_KEY or Config.GOOGLE_API_KEY:
            try:
                translation_processor = TranslationProcessor()
                logger.info("✅ Translation Processor initialized successfully")
            except Exception as e:
                logger.warning(f"⚠️ Translation processor failed to initialize: {e}")
                translation_processor = None

        # Show supported extensions
        extensions = extractor.get_supported_extensions()
        for processor, exts in extensions.items():
            logger.info(f"   {processor}: {len(exts)} extensions")

    except Exception as e:
        logger.error(f"❌ Failed to initialize text extractor: {e}")
        logger.error(traceback.format_exc())
        extractor = None

@app.on_event("shutdown")
async def shutdown_event():
    """Cleanup on shutdown."""
    logger.info("Shutting down AI Content Processing API...")

# Dependencies for ensuring services are initialized
async def get_extractor() -> TextExtractor:
    """Dependency to ensure extractor is initialized."""
    if extractor is None:
        raise HTTPException(
            status_code=503,
            detail="Text extractor not initialized. Please check API configuration."
        )
    return extractor

async def get_youtube_mp3_service() -> YouTubeMP3TranscriptionService:
    """Dependency to ensure YouTube MP3 service is initialized."""
    if youtube_mp3_service is None:
        raise HTTPException(
            status_code=503,
            detail="YouTube MP3 service not available. Please check Gemini API configuration."
        )
    return youtube_mp3_service

async def get_tts_processor() -> TTSProcessor:
    """Dependency to ensure TTS processor is initialized."""
    if tts_processor is None:
        raise HTTPException(
            status_code=503,
            detail="TTS processor not available. Please check OpenAI API configuration."
        )
    return tts_processor

async def get_translation_processor() -> TranslationProcessor:
    """Dependency to ensure translation processor is initialized."""
    if translation_processor is None:
        raise HTTPException(
            status_code=503,
            detail="Translation processor not available. Please check OpenAI or Gemini API configuration."
        )
    return translation_processor

# Root endpoint
@app.get("/", response_class=PlainTextResponse)
async def root():
    """Root endpoint with service information."""
    return ""

# Health check endpoint
@app.get("/health", response_model=HealthResponse)
async def health_check(extractor: TextExtractor = Depends(get_extractor)):
    """Check API health and configuration status."""
    extensions = extractor.get_supported_extensions()
    api_keys = {
        "openai": bool(Config.OPENAI_API_KEY),
        "gemini": bool(Config.GOOGLE_API_KEY)
    }

    return HealthResponse(
        status="healthy",
        message="AI Content Processing API is running",
        supported_extensions=extensions,
        api_keys_configured=api_keys,
        version="2.0.0"
    )

# Supported file types endpoint
@app.get("/supported-types")
async def get_supported_types(extractor: TextExtractor = Depends(get_extractor)):
    """Get detailed information about supported file types."""
    extensions = extractor.get_supported_extensions()

    detailed_info = {}
    for processor_name, exts in extensions.items():
        processor_info = {
            "extensions": sorted(list(exts)),
            "count": len(exts),
            "description": _get_processor_description(processor_name)
        }
        detailed_info[processor_name] = processor_info

    return {
        "total_extensions": sum(len(exts) for exts in extensions.values()),
        "processors": detailed_info,
        "all_extensions": sorted(list(set().union(*extensions.values())))
    }

def _get_processor_description(processor_name: str) -> str:
    """Get description for processor."""
    descriptions = {
        "OpenAIProcessor": "Handles documents and text files using OpenAI GPT models",
        "GeminiProcessor": "Processes video and audio files using Google Gemini",
        "YouTubeProcessor": "Extracts content from YouTube videos and audio"
    }
    return descriptions.get(processor_name, "File processor")

# Single file upload endpoint
@app.post("/extract", response_model=ExtractionResult)
async def extract_text_from_file(
    background_tasks: BackgroundTasks,
    file: UploadFile = File(..., description="File to extract text from"),
    extractor: TextExtractor = Depends(get_extractor)
):
    """Extract text from a single uploaded file."""
    file_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    # Validate file
    if not file.filename:
        raise HTTPException(status_code=400, detail="Filename is required")

    # Check file extension
    file_path = Path(file.filename)
    all_extensions = set()
    for exts in extractor.get_supported_extensions().values():
        all_extensions.update(exts)

    if file_path.suffix.lower() not in all_extensions:
        raise HTTPException(
            status_code=400,
            detail=f"Unsupported file type: {file_path.suffix}. Supported: {', '.join(sorted(all_extensions))}"
        )

    # Create temporary file
    temp_file = None
    try:
        # Save uploaded file
        temp_file = await _save_uploaded_file(file, file_id)

        # Extract text
        result = extractor.extract_from_file(temp_file)

        # Schedule cleanup
        background_tasks.add_task(cleanup_temp_file, temp_file)

        # Convert to API response format
        return _convert_to_api_result(result, file_id, timestamp)

    except Exception as e:
        # Cleanup on error
        if temp_file and temp_file.exists():
            background_tasks.add_task(cleanup_temp_file, temp_file)

        logger.error(f"Error processing file {file.filename}: {e}")
        raise HTTPException(status_code=500, detail=f"File processing failed: {str(e)}")

# URL-based single file extraction endpoint
@app.post("/extract-url", response_model=ExtractionResult)
async def extract_text_from_url(
    background_tasks: BackgroundTasks,
    request: URLRequest,
    extractor: TextExtractor = Depends(get_extractor)
):
    """Extract text from a file at the given URL."""
    file_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    url_str = str(request.url)

    try:
        # Check if it's a YouTube URL first
        from src.file_processors.youtube_processor import YouTubeProcessor
        from src.file_processors.web_processor import WebProcessor

        if YouTubeProcessor.is_youtube_url(url_str):

            # Process YouTube URL directly without downloading
            result = extractor.extract_from_file(url_str)

            # Add URL to file info
            if result.get('file_info'):
                result['file_info']['url'] = url_str
                if request.filename:
                    result['file_info']['name'] = request.filename

            return _convert_to_api_result(result, file_id, timestamp)

        # Check if it's a web page URL
        if WebProcessor.is_web_page_url(url_str):
            # Process web page directly without downloading
            result = extractor.extract_from_file(url_str)

            # Add URL to file info
            if result.get('file_info'):
                result['file_info']['url'] = url_str
                if request.filename:
                    result['file_info']['name'] = request.filename

            return _convert_to_api_result(result, file_id, timestamp)

        # For other URLs, download file first
        temp_file_path, original_filename, file_size = await download_file_from_url(
            url_str,
            file_id,
            request.filename
        )

        # Validate file type
        file_path = Path(original_filename)
        all_extensions = set()
        for exts in extractor.get_supported_extensions().values():
            all_extensions.update(exts)

        if file_path.suffix.lower() not in all_extensions:
            background_tasks.add_task(cleanup_temp_file, temp_file_path)
            raise HTTPException(
                status_code=400,
                detail=f"Unsupported file type: {file_path.suffix}. Supported: {', '.join(sorted(all_extensions))}"
            )

        # Extract text
        result = extractor.extract_from_file(temp_file_path)

        # Add URL to file info
        if result.get('file_info'):
            result['file_info']['url'] = url_str

        # Schedule cleanup
        background_tasks.add_task(cleanup_temp_file, temp_file_path)

        return _convert_to_api_result(result, file_id, timestamp)

    except Exception as e:
        logger.error(f"Error processing URL {request.url}: {e}")
        raise HTTPException(status_code=500, detail=f"URL processing failed: {str(e)}")

# YouTube extraction endpoint
@app.post("/extract-youtube", response_model=ExtractionResult)
async def extract_text_from_youtube(
    request: YouTubeRequest,
    extractor: TextExtractor = Depends(get_extractor)
):
    """Extract text/audio content from YouTube videos."""
    file_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    try:
        # Process YouTube URL directly
        result = extractor.extract_from_file(str(request.url))

        # Add YouTube-specific info
        if result.get('file_info'):
            result['file_info']['url'] = str(request.url)
            if request.title:
                result['file_info']['name'] = request.title

        return _convert_to_api_result(result, file_id, timestamp)

    except Exception as e:
        logger.error(f"Error processing YouTube URL {request.url}: {e}")
        raise HTTPException(status_code=500, detail=f"YouTube processing failed: {str(e)}")


# Image transcription endpoint
@app.post("/transcribe-image", response_model=ImageTranscriptionResult)
async def transcribe_image(
    background_tasks: BackgroundTasks,
    file: UploadFile = File(..., description="Image file to transcribe"),
    extractor: TextExtractor = Depends(get_extractor)
):
    """Transcribe an image and return structured JSON with title, description, and extracted text."""
    file_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    start_time = datetime.now()

    # Validate file
    if not file.filename:
        raise HTTPException(status_code=400, detail="Filename is required")

    # Check if it's an image file
    file_path = Path(file.filename)
    image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.tif', '.webp'}

    if file_path.suffix.lower() not in image_extensions:
        raise HTTPException(
            status_code=400,
            detail=f"Unsupported image format: {file_path.suffix}. Supported: {', '.join(sorted(image_extensions))}"
        )

    # Check if image processor is available
    if not extractor.image_processor:
        raise HTTPException(
            status_code=503,
            detail="Image processor not available. Please check API key configuration."
        )

    # Create temporary file
    temp_file = None
    try:
        # Save uploaded file
        temp_file = await _save_uploaded_file(file, file_id)

        # Get image transcription data
        image_result = extractor.image_processor.extract_image_data(temp_file)

        # Get file info
        file_info_dict = extractor.image_processor.get_file_info(temp_file)

        # Calculate processing time
        end_time = datetime.now()
        processing_time = (end_time - start_time).total_seconds()

        # Schedule cleanup
        background_tasks.add_task(cleanup_temp_file, temp_file)

        # Convert to API response format
        file_info = FileInfo(
            name=file.filename,
            extension=file_path.suffix.lower(),
            size_mb=file_info_dict['size_mb'],
            mime_type=file_info_dict['mime_type']
        )

        if image_result['success']:
            return ImageTranscriptionResult(
                file_id=file_id,
                file_info=file_info,
                success=True,
                error=None,
                title=image_result['title'],
                description=image_result['description'],
                extracted_text=image_result['extracted_text'],
                processor_used=image_result.get('processor_used'),
                processing_time=processing_time,
                timestamp=timestamp
            )
        else:
            return ImageTranscriptionResult(
                file_id=file_id,
                file_info=file_info,
                success=False,
                error=image_result['error'],
                title=None,
                description=None,
                extracted_text=None,
                processor_used=None,
                processing_time=processing_time,
                timestamp=timestamp
            )

    except Exception as e:
        # Cleanup on error
        if temp_file and temp_file.exists():
            background_tasks.add_task(cleanup_temp_file, temp_file)

        logger.error(f"Error processing image {file.filename}: {e}")
        raise HTTPException(status_code=500, detail=f"Image transcription failed: {str(e)}")


# Image URL transcription endpoint
@app.post("/transcribe-image-url", response_model=ImageTranscriptionResult)
async def transcribe_image_url(
    background_tasks: BackgroundTasks,
    request: ImageURLRequest,
    extractor: TextExtractor = Depends(get_extractor)
):
    """Transcribe an image from URL and return structured JSON with title, description, and extracted text."""
    file_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    start_time = datetime.now()

    # Check if image processor is available
    if not extractor.image_processor:
        raise HTTPException(
            status_code=503,
            detail="Image processor not available. Please check API key configuration."
        )

    # Extract filename from URL
    url_path = Path(str(request.url))
    filename = url_path.name or f"image_{file_id}"
    file_extension = url_path.suffix.lower()

    # Check if it's an image file based on extension
    image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.tif', '.webp'}

    if file_extension not in image_extensions:
        # If no extension in URL, try to determine from headers later
        file_extension = '.jpg'  # Default assumption
        filename = f"{filename}.jpg"

    temp_file = None
    try:
        # Download image from URL
        async with aiohttp.ClientSession() as session:
            async with session.get(str(request.url)) as response:
                if response.status != 200:
                    raise HTTPException(
                        status_code=400,
                        detail=f"Failed to download image from URL. HTTP {response.status}: {response.reason}"
                    )

                # Check content type
                content_type = response.headers.get('content-type', '')
                if not content_type.startswith('image/'):
                    # Try to proceed anyway, but warn
                    logger.warning(f"URL content-type is not image/*: {content_type}")

                # Read image data
                image_data = await response.read()

                if len(image_data) == 0:
                    raise HTTPException(status_code=400, detail="Downloaded image is empty")

                # Create temporary file
                temp_file = Path(tempfile.gettempdir()) / f"image_{file_id}_{filename}"

                # Write image data to temporary file
                async with aiofiles.open(temp_file, 'wb') as f:
                    await f.write(image_data)

        # Get image transcription data
        image_result = extractor.image_processor.extract_image_data(temp_file)

        # Get file info
        file_info_dict = extractor.image_processor.get_file_info(temp_file)

        # Calculate processing time
        end_time = datetime.now()
        processing_time = (end_time - start_time).total_seconds()

        # Schedule cleanup
        background_tasks.add_task(cleanup_temp_file, temp_file)

        # Convert to API response format
        file_info = FileInfo(
            name=filename,
            extension=file_extension,
            size_mb=file_info_dict['size_mb'],
            mime_type=file_info_dict['mime_type'],
            url=str(request.url)
        )

        if image_result['success']:
            return ImageTranscriptionResult(
                file_id=file_id,
                file_info=file_info,
                success=True,
                error=None,
                title=image_result['title'],
                description=image_result['description'],
                extracted_text=image_result['extracted_text'],
                processor_used=image_result.get('processor_used'),
                processing_time=processing_time,
                timestamp=timestamp
            )
        else:
            return ImageTranscriptionResult(
                file_id=file_id,
                file_info=file_info,
                success=False,
                error=image_result['error'],
                title=None,
                description=None,
                extracted_text=None,
                processor_used=None,
                processing_time=processing_time,
                timestamp=timestamp
            )

    except aiohttp.ClientError as e:
        raise HTTPException(status_code=400, detail=f"Failed to download image: {str(e)}")
    except Exception as e:
        # Cleanup on error
        if temp_file and temp_file.exists():
            background_tasks.add_task(cleanup_temp_file, temp_file)

        logger.error(f"Error processing image URL {request.url}: {e}")
        raise HTTPException(status_code=500, detail=f"Image transcription failed: {str(e)}")


# YouTube MP3 transcription endpoint
@app.post("/youtube-mp3-transcribe", response_model=YouTubeMP3Result)
async def transcribe_youtube_mp3(
    request: YouTubeMP3Request,
    service: YouTubeMP3TranscriptionService = Depends(get_youtube_mp3_service)
):
    """Download MP3 from YouTube video and transcribe it using Gemini."""
    request_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    try:
        # Validate YouTube URL
        if not service.is_youtube_url(str(request.url)):
            raise HTTPException(
                status_code=400,
                detail="Invalid YouTube URL provided"
            )

        logger.info(f"Starting YouTube MP3 transcription for: {request.url}")

        # Process the video
        result = service.transcribe_youtube_video(
            str(request.url),
            keep_mp3=request.keep_mp3
        )

        # Convert to API response format
        return YouTubeMP3Result(
            request_id=request_id,
            success=result.success,
            video_id=result.video_id,
            title=result.title,
            duration=result.duration,
            transcript=result.transcript,
            error=result.error,
            processing_time=result.processing_time,
            audio_file_size_mb=result.audio_file_size_mb,
            chunks_processed=result.chunks_processed,
            timestamp=timestamp
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error in YouTube MP3 transcription {request.url}: {e}")
        return YouTubeMP3Result(
            request_id=request_id,
            success=False,
            video_id="",
            title="",
            duration=None,
            transcript=None,
            error=f"Transcription failed: {str(e)}",
            processing_time=0.0,
            audio_file_size_mb=None,
            chunks_processed=0,
            timestamp=timestamp
        )


# Text-to-Speech endpoint for single voice
@app.post("/text-to-speech", response_model=TTSResult)
async def convert_text_to_speech(
    background_tasks: BackgroundTasks,
    request: TTSRequest,
    processor: TTSProcessor = Depends(get_tts_processor)
):
    """Convert text to speech using a single voice."""
    request_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    try:
        logger.info(f"🎤 TTS request: {len(request.text)} characters, voice: {request.voice}")

        # Convert text to speech
        result = processor.text_to_speech(
            text=request.text,
            voice=request.voice,
            model=request.model,
            output_format=request.format,
            speed=request.speed
        )

        # Clean up audio file after response (optional - comment out to keep files)
        if result.get("success") and result.get("audio_file"):
            background_tasks.add_task(cleanup_temp_file, Path(result["audio_file"]))

        return TTSResult(
            request_id=request_id,
            success=result["success"],
            error=result.get("error"),
            audio_file=result.get("audio_file"),
            file_size_mb=result.get("file_size_mb"),
            voice=result.get("voice"),
            model=result.get("model"),
            format=result.get("format"),
            speed=result.get("speed"),
            text_length=result.get("text_length"),
            processing_time=result["processing_time"],
            timestamp=timestamp
        )

    except Exception as e:
        logger.error(f"Error in TTS conversion: {e}")
        return TTSResult(
            request_id=request_id,
            success=False,
            error=f"TTS conversion failed: {str(e)}",
            audio_file=None,
            file_size_mb=None,
            voice=None,
            model=None,
            format=None,
            speed=None,
            text_length=None,
            processing_time=0.0,
            timestamp=timestamp
        )


# Text-to-Speech endpoint for multiple voices (podcast mode)
@app.post("/text-to-speech-podcast", response_model=TTSMultiVoiceResult)
async def convert_text_to_speech_podcast(
    background_tasks: BackgroundTasks,
    request: TTSMultiVoiceRequest,
    processor: TTSProcessor = Depends(get_tts_processor)
):
    """Convert multiple text segments to speech with different voices for podcast creation."""
    request_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    try:
        total_chars = sum(len(segment.text) for segment in request.segments)
        logger.info(f"🎙️ Podcast TTS request: {len(request.segments)} segments, {total_chars} total characters")

        # Convert segments to dict format expected by processor
        segments_dict = []
        for segment in request.segments:
            segments_dict.append({
                "text": segment.text,
                "voice": segment.voice,
                "speaker_name": segment.speaker_name
            })

        # Convert multiple segments to speech
        result = processor.text_to_speech_multiple_voices(
            segments=segments_dict,
            model=request.model,
            output_format=request.format,
            speed=request.speed
        )

        # Schedule cleanup of audio files after response (optional)
        if result.get("success") and result.get("output_directory"):
            background_tasks.add_task(cleanup_temp_directory, Path(result["output_directory"]))

        return TTSMultiVoiceResult(
            request_id=request_id,
            success=result["success"],
            segments=result["segments"],
            total_segments=result["total_segments"],
            successful_segments=result["successful_segments"],
            failed_segments=result["failed_segments"],
            total_characters=result["total_characters"],
            output_directory=result.get("output_directory"),
            processing_time=result["processing_time"],
            timestamp=timestamp
        )

    except Exception as e:
        logger.error(f"Error in podcast TTS conversion: {e}")
        return TTSMultiVoiceResult(
            request_id=request_id,
            success=False,
            segments=[],
            total_segments=0,
            successful_segments=0,
            failed_segments=0,
            total_characters=0,
            output_directory=None,
            processing_time=0.0,
            timestamp=timestamp
        )


# TTS voices endpoint
@app.get("/tts-voices")
async def get_tts_voices(processor: TTSProcessor = Depends(get_tts_processor)):
    """Get available TTS voices and their descriptions."""
    return {
        "voices": processor.get_available_voices(),
        "supported_formats": processor.get_supported_formats(),
        "models": ["tts-1", "tts-1-hd"],
        "speed_range": {"min": 0.25, "max": 4.0},
        "max_text_length": 4096
    }


# Translation endpoints
@app.post("/translate", response_model=TranslationResult)
async def translate_text(
    request: TranslationRequest,
    processor: TranslationProcessor = Depends(get_translation_processor)
):
    """Translate text from source language to target language."""
    request_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    try:
        logger.info(f"🌐 Translation request: {len(request.text)} chars, {request.source_language} → {request.target_language}")

        # Handle auto-detection
        if request.source_language.lower() in ["auto", "auto-detect", "detect"]:
            # First detect the language
            detection_result = processor.detect_language(request.text, request.use_openai)
            if not detection_result["success"]:
                return TranslationResult(
                    request_id=request_id,
                    success=False,
                    original_text=request.text,
                    translated_text=None,
                    source_language=request.source_language,
                    target_language=request.target_language,
                    error=f"Language detection failed: {detection_result.get('error', 'Unknown error')}",
                    processing_time=detection_result.get("processing_time", 0.0),
                    timestamp=timestamp
                )
            detected_language = detection_result["detected_language"]
            logger.info(f"🔍 Detected language: {detected_language}")
        else:
            detected_language = request.source_language

        # Translate text
        result = processor.translate_text(
            text=request.text,
            source_language=detected_language,
            target_language=request.target_language,
            use_openai=request.use_openai
        )

        return TranslationResult(
            request_id=request_id,
            success=result["success"],
            original_text=request.text,
            translated_text=result.get("translated_text"),
            source_language=detected_language,
            target_language=request.target_language,
            api_used=result.get("api_used"),
            model_used=result.get("model_used"),
            original_length=result.get("original_length"),
            translated_length=result.get("translated_length"),
            error=result.get("error"),
            processing_time=result["processing_time"],
            timestamp=timestamp
        )

    except Exception as e:
        logger.error(f"Error in translation: {e}")
        return TranslationResult(
            request_id=request_id,
            success=False,
            original_text=request.text,
            translated_text=None,
            source_language=request.source_language,
            target_language=request.target_language,
            error=f"Translation failed: {str(e)}",
            processing_time=0.0,
            timestamp=timestamp
        )


@app.post("/translate-batch", response_model=TranslationBatchResult)
async def translate_text_batch(
    request: TranslationBatchRequest,
    processor: TranslationProcessor = Depends(get_translation_processor)
):
    """Translate multiple texts from source language to target language."""
    batch_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    try:
        logger.info(f"🌐 Batch translation: {len(request.texts)} texts, {request.source_language} → {request.target_language}")

        # Handle auto-detection for batch
        source_language = request.source_language
        if request.source_language.lower() in ["auto", "auto-detect", "detect"]:
            # For batch auto-detection, we'll detect on the first text
            if request.texts:
                detection_result = processor.detect_language(request.texts[0], request.use_openai)
                if detection_result["success"]:
                    source_language = detection_result["detected_language"]
                    logger.info(f"🔍 Detected language for batch: {source_language}")
                else:
                    # Fallback to English if detection fails
                    source_language = "English"
                    logger.warning("Language detection failed, defaulting to English")

        # Translate batch
        result = processor.translate_batch(
            texts=request.texts,
            source_language=source_language,
            target_language=request.target_language,
            use_openai=request.use_openai
        )

        return TranslationBatchResult(
            batch_id=batch_id,
            success=result["success"],
            total_texts=result["total_texts"],
            successful=result["successful"],
            failed=result["failed"],
            source_language=source_language,
            target_language=request.target_language,
            results=result["results"],
            processing_time=result["processing_time"],
            timestamp=timestamp
        )

    except Exception as e:
        logger.error(f"Error in batch translation: {e}")
        return TranslationBatchResult(
            batch_id=batch_id,
            success=False,
            total_texts=len(request.texts),
            successful=0,
            failed=len(request.texts),
            source_language=request.source_language,
            target_language=request.target_language,
            results=[],
            processing_time=0.0,
            timestamp=timestamp
        )


@app.post("/detect-language", response_model=LanguageDetectionResult)
async def detect_language(
    request: LanguageDetectionRequest,
    processor: TranslationProcessor = Depends(get_translation_processor)
):
    """Detect the language of the given text."""
    request_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()

    try:
        logger.info(f"🔍 Language detection request: {len(request.text)} characters")

        result = processor.detect_language(
            text=request.text,
            use_openai=request.use_openai
        )

        return LanguageDetectionResult(
            request_id=request_id,
            success=result["success"],
            original_text=request.text,
            detected_language=result.get("detected_language"),
            confidence=result.get("confidence"),
            api_used=result.get("api_used"),
            error=result.get("error"),
            processing_time=result["processing_time"],
            timestamp=timestamp
        )

    except Exception as e:
        logger.error(f"Error in language detection: {e}")
        return LanguageDetectionResult(
            request_id=request_id,
            success=False,
            original_text=request.text,
            detected_language=None,
            confidence=0.0,
            api_used=None,
            error=f"Language detection failed: {str(e)}",
            processing_time=0.0,
            timestamp=timestamp
        )


@app.get("/supported-languages")
async def get_supported_languages(processor: TranslationProcessor = Depends(get_translation_processor)):
    """Get list of supported languages for translation."""
    languages = processor.get_supported_languages()
    return {
        "supported_languages": languages,
        "language_codes": list(languages.keys()),
        "language_names": list(languages.values()),
        "total_languages": len(languages),
        "auto_detection_supported": True,
        "available_apis": {
            "openai": bool(Config.OPENAI_API_KEY),
            "gemini": bool(Config.GOOGLE_API_KEY)
        }
    }


@app.post("/generate-video", response_model=VideoGenerationResult)
async def generate_video_from_image(
    request: VideoGenerationRequest,
    extractor: TextExtractor = Depends(get_extractor)
):
    """Generate a video from an image using Runway AI."""
    request_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    start_time = time.time()

    try:
        logger.info(f"🎬 Video generation request: {request.image_url}")
        logger.info(f"   Prompt: {request.prompt_text}")
        logger.info(f"   Ratio: {request.ratio}")
        logger.info(f"   Duration: {request.duration}s")
        logger.info(f"   Motion Intensity: {request.motion_intensity}")
        if request.effects:
            logger.info(f"   Effects: {request.effects} (intensity: {request.effects_intensity})")

        # Validate duration for gen4_turbo model
        if request.duration not in [5, 10]:
            raise HTTPException(
                status_code=400,
                detail=f"Duration must be 5 or 10 seconds for gen4_turbo model, got {request.duration}"
            )

        # Check if Runway processor is available
        if not hasattr(extractor, 'runway_processor') or not extractor.runway_processor:
            raise HTTPException(
                status_code=503,
                detail="Runway video generation service not available. Please check RUNWAY_API_KEY configuration."
            )

        # Generate video
        result_json = extractor.generate_video_from_image(
            image_path=str(request.image_url),
            prompt_text=request.prompt_text,
            ratio=request.ratio,
            duration=request.duration,
            model=request.model
        )

        # Parse the JSON result
        import json
        result_data = json.loads(result_json)

        processing_time = time.time() - start_time

        # Create response
        return VideoGenerationResult(
            request_id=request_id,
            status=result_data.get("status", "unknown"),
            task_id=result_data.get("task_id"),
            video_url=result_data.get("video_url"),
            source_image=str(request.image_url),
            prompt_text=request.prompt_text,
            ratio=request.ratio,
            duration=request.duration,
            model=result_data.get("model", request.model or Config.RUNWAY_MODEL),
            processing_time_seconds=result_data.get("processing_time_seconds", processing_time),
            error=result_data.get("error"),
            timestamp=timestamp
        )

    except HTTPException:
        raise
    except Exception as e:
        processing_time = time.time() - start_time
        error_msg = f"Video generation failed: {str(e)}"
        logger.error(f"❌ {error_msg}")

        return VideoGenerationResult(
            request_id=request_id,
            status="error",
            task_id=None,
            video_url=None,
            source_image=str(request.image_url),
            prompt_text=request.prompt_text,
            ratio=request.ratio,
            duration=request.duration,
            model=request.model or Config.RUNWAY_MODEL,
            processing_time_seconds=processing_time,
            error=error_msg,
            timestamp=timestamp
        )


@app.post("/generate-video-from-prompt", response_model=VideoGenerationResult)
async def generate_video_from_prompt(
    request: PromptToVideoRequest,
    extractor: TextExtractor = Depends(get_extractor)
):
    """Generate a video by first creating an image from a text prompt, then animating it."""
    request_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    start_time = time.time()

    try:
        if request.preview_only:
            logger.info(f"📋 Preview mode: Prompt preview request")
        else:
            logger.info(f"🎨➡️🎬 Prompt-to-video generation request")

        logger.info(f"   Image prompt: {request.image_prompt}")
        logger.info(f"   Video prompt: {request.video_prompt or 'Auto-generated'}")
        logger.info(f"   Ratio: {request.ratio}")
        logger.info(f"   Duration: {request.duration}s")
        logger.info(f"   Motion Intensity: {request.motion_intensity}")
        if request.effects:
            logger.info(f"   Effects: {request.effects} (intensity: {request.effects_intensity})")
        if request.enhance_motion:
            logger.info(f"   Motion Enhancement: Enabled")
        if request.tiktok_mode:
            logger.info(f"   TikTok Mode: {request.tiktok_style} style, 9:16 format")
        if request.voice_type and (request.style or request.voice_script_preview):
            if request.voice_script_preview:
                logger.info(f"   🎙️ Audio: {request.voice_type} voice, custom script ({len(request.voice_script_preview)} chars)")
            else:
                logger.info(f"   🎙️ Audio: {request.voice_type} voice, {request.style} style")
        if request.merge_audio:
            logger.info(f"   🎬🎙️ Merge audio: Enabled (requires FFmpeg)")
        if request.preview_only:
            logger.info(f"   📋 Preview only: Will not execute APIs")

        # Validate duration for gen4_turbo model
        if request.duration not in [5, 10]:
            raise HTTPException(
                status_code=400,
                detail=f"Duration must be 5 or 10 seconds for gen4_turbo model, got {request.duration}"
            )

        # Check if Runway processor is available
        if not hasattr(extractor, 'runway_processor') or not extractor.runway_processor:
            raise HTTPException(
                status_code=503,
                detail="Runway video generation service not available. Please check RUNWAY_API_KEY configuration."
            )

        # Generate video from prompt (with optional audio, merging, and effects) or preview mode
        result_json = extractor.generate_video_from_prompt(
            image_prompt=request.image_prompt,
            video_prompt=request.video_prompt,
            ratio=request.ratio,
            duration=request.duration,
            model=request.model,
            motion_intensity=request.motion_intensity,
            voice_type=request.voice_type,
            style=request.style,
            voice_script_preview=request.voice_script_preview,
            merge_audio=request.merge_audio,
            preview_only=request.preview_only,
            effects=request.effects,
            effects_intensity=request.effects_intensity,
            enhance_motion=request.enhance_motion,
            tiktok_mode=request.tiktok_mode,
            tiktok_style=request.tiktok_style
        )

        # Parse the JSON result
        import json
        result_data = json.loads(result_json)

        processing_time = time.time() - start_time

        # Create response
        return VideoGenerationResult(
            request_id=request_id,
            status=result_data.get("status", "unknown"),
            task_id=result_data.get("task_id"),
            video_url=result_data.get("video_url"),
            source_image=result_data.get("generated_image_url", "Generated by DALL-E"),
            prompt_text=request.video_prompt or f"Cinematic animation of: {request.image_prompt}",
            ratio=request.ratio,
            duration=request.duration,
            model=result_data.get("model", request.model or Config.RUNWAY_MODEL),
            processing_time_seconds=result_data.get("processing_time_seconds", processing_time),
            error=result_data.get("error"),
            timestamp=timestamp
        )

    except HTTPException:
        raise
    except Exception as e:
        processing_time = time.time() - start_time
        error_msg = f"Prompt-to-video generation failed: {str(e)}"
        logger.error(f"❌ {error_msg}")

        return VideoGenerationResult(
            request_id=request_id,
            status="error",
            task_id=None,
            video_url=None,
            source_image="Failed to generate",
            prompt_text=request.video_prompt or f"Cinematic animation of: {request.image_prompt}",
            ratio=request.ratio,
            duration=request.duration,
            model=request.model or Config.RUNWAY_MODEL,
            processing_time_seconds=processing_time,
            error=error_msg,
            timestamp=timestamp
        )


# Batch file upload endpoint
@app.post("/extract-batch", response_model=BatchExtractionResult)
async def extract_text_from_files(
    background_tasks: BackgroundTasks,
    files: List[UploadFile] = File(..., description="Files to extract text from"),
    parallel: bool = Query(True, description="Use parallel processing"),
    max_workers: int = Query(4, description="Maximum number of workers", ge=1, le=16),
    extractor: TextExtractor = Depends(get_extractor)
):
    """Extract text from multiple uploaded files."""
    batch_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    start_time = datetime.now()

    if not files:
        raise HTTPException(status_code=400, detail="No files provided")

    temp_files = []
    results = []

    try:
        # Save all uploaded files
        for file in files:
            if not file.filename:
                continue
            temp_file = await _save_uploaded_file(file, f"{batch_id}_{file.filename}")
            temp_files.append((temp_file, file.filename))

        # Extract text from all files
        file_paths = [temp_file for temp_file, _ in temp_files]
        extraction_results = extractor.extract_from_files(
            file_paths,
            parallel=parallel,
            max_workers=max_workers
        )

        # Convert results
        for i, result in enumerate(extraction_results):
            file_id = f"{batch_id}_{i}"
            api_result = _convert_to_api_result(result, file_id, timestamp)
            results.append(api_result)

        # Schedule cleanup
        for temp_file, _ in temp_files:
            background_tasks.add_task(cleanup_temp_file, temp_file)

        # Calculate batch statistics
        end_time = datetime.now()
        total_time = (end_time - start_time).total_seconds()
        successful = sum(1 for r in results if r.success)
        failed = len(results) - successful
        total_chars = sum(r.text_length for r in results if r.success)

        return BatchExtractionResult(
            batch_id=batch_id,
            total_files=len(results),
            successful=successful,
            failed=failed,
            total_processing_time=total_time,
            total_characters=total_chars,
            results=results,
            timestamp=timestamp
        )

    except Exception as e:
        # Cleanup on error
        for temp_file, _ in temp_files:
            background_tasks.add_task(cleanup_temp_file, temp_file)

        logger.error(f"Error in batch processing: {e}")
        raise HTTPException(status_code=500, detail=f"Batch processing failed: {str(e)}")

# Batch URL extraction endpoint
@app.post("/extract-batch-url", response_model=BatchExtractionResult)
async def extract_text_from_urls(
    background_tasks: BackgroundTasks,
    request: URLBatchRequest,
    parallel: bool = Query(True, description="Use parallel processing"),
    max_workers: int = Query(4, description="Maximum number of workers", ge=1, le=16),
    extractor: TextExtractor = Depends(get_extractor)
):
    """Extract text from multiple URLs."""
    batch_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    start_time = datetime.now()

    if not request.urls:
        raise HTTPException(status_code=400, detail="No URLs provided")

    temp_files = []
    results = []

    try:
        # Import processors for URL checking
        from src.file_processors.youtube_processor import YouTubeProcessor
        from src.file_processors.web_processor import WebProcessor

        # Separate URLs by type
        youtube_urls = []
        web_urls = []
        regular_urls = []
        url_indices = {}  # Track original index for each URL

        for i, url in enumerate(request.urls):
            url_str = str(url)
            if YouTubeProcessor.is_youtube_url(url_str):
                youtube_urls.append(url_str)
                url_indices[url_str] = i
            elif WebProcessor.is_web_page_url(url_str):
                web_urls.append(url_str)
                url_indices[url_str] = i
            else:
                regular_urls.append((url_str, i))
                url_indices[url_str] = i

        # Process YouTube URLs directly
        youtube_results = []
        if youtube_urls:
            youtube_extraction_results = extractor.extract_from_files(
                youtube_urls,
                parallel=parallel,
                max_workers=max_workers
            )
            for j, result in enumerate(youtube_extraction_results):
                youtube_url = youtube_urls[j]
                original_index = url_indices[youtube_url]
                file_id = f"{batch_id}_{original_index}"

                # Add URL info
                if result.get('file_info'):
                    result['file_info']['url'] = youtube_url
                    if request.filenames and original_index < len(request.filenames):
                        result['file_info']['name'] = request.filenames[original_index]

                api_result = _convert_to_api_result(result, file_id, timestamp)
                youtube_results.append((original_index, api_result))

        # Process web page URLs directly
        web_results = []
        if web_urls:
            web_extraction_results = extractor.extract_from_files(
                web_urls,
                parallel=parallel,
                max_workers=max_workers
            )
            for j, result in enumerate(web_extraction_results):
                web_url = web_urls[j]
                original_index = url_indices[web_url]
                file_id = f"{batch_id}_{original_index}"

                # Add URL info
                if result.get('file_info'):
                    result['file_info']['url'] = web_url
                    if request.filenames and original_index < len(request.filenames):
                        result['file_info']['name'] = request.filenames[original_index]

                api_result = _convert_to_api_result(result, file_id, timestamp)
                web_results.append((original_index, api_result))

        # Download and process regular files
        regular_results = []
        if regular_urls:
            # Download all regular files
            for url_str, original_index in regular_urls:
                filename = None
                if request.filenames and original_index < len(request.filenames):
                    filename = request.filenames[original_index]

                temp_file_path, original_filename, file_size = await download_file_from_url(
                    url_str,
                    f"{batch_id}_{original_index}",
                    filename
                )
                temp_files.append(temp_file_path)

            # Extract text from all downloaded files
            if temp_files:
                extraction_results = extractor.extract_from_files(
                    temp_files,
                    parallel=parallel,
                    max_workers=max_workers
                )

                # Convert results
                for j, result in enumerate(extraction_results):
                    url_str, original_index = regular_urls[j]
                    file_id = f"{batch_id}_{original_index}"

                    # Add URL info
                    if result.get('file_info'):
                        result['file_info']['url'] = url_str
                    api_result = _convert_to_api_result(result, file_id, timestamp)
                    regular_results.append((original_index, api_result))

        # Combine and sort all results by original index
        all_results = youtube_results + web_results + regular_results
        all_results.sort(key=lambda x: x[0])  # Sort by original index
        results = [result for _, result in all_results]

        # Schedule cleanup
        for temp_file in temp_files:
            background_tasks.add_task(cleanup_temp_file, temp_file)

        # Calculate batch statistics
        end_time = datetime.now()
        total_time = (end_time - start_time).total_seconds()
        successful = sum(1 for r in results if r.success)
        failed = len(results) - successful
        total_chars = sum(r.text_length for r in results if r.success)

        return BatchExtractionResult(
            batch_id=batch_id,
            total_files=len(results),
            successful=successful,
            failed=failed,
            total_processing_time=total_time,
            total_characters=total_chars,
            results=results,
            timestamp=timestamp
        )

    except Exception as e:
        # Cleanup on error
        for temp_file in temp_files:
            background_tasks.add_task(cleanup_temp_file, temp_file)

        logger.error(f"Error in batch URL processing: {e}")
        raise HTTPException(status_code=500, detail=f"Batch URL processing failed: {str(e)}")

# Batch YouTube extraction endpoint
@app.post("/extract-youtube-batch", response_model=BatchExtractionResult)
async def extract_text_from_youtube_batch(
    request: YouTubeBatchRequest,
    parallel: bool = Query(True, description="Use parallel processing"),
    max_workers: int = Query(4, description="Maximum number of workers", ge=1, le=16),
    extractor: TextExtractor = Depends(get_extractor)
):
    """Extract text from multiple YouTube videos."""
    batch_id = str(uuid.uuid4())
    timestamp = datetime.now().isoformat()
    start_time = datetime.now()

    if not request.urls:
        raise HTTPException(status_code=400, detail="No URLs provided")

    try:
        # Process YouTube URLs
        url_strings = [str(url) for url in request.urls]
        extraction_results = extractor.extract_from_files(
            url_strings,
            parallel=parallel,
            max_workers=max_workers
        )

        # Convert results
        results = []
        for i, result in enumerate(extraction_results):
            file_id = f"{batch_id}_{i}"
            # Add YouTube-specific info
            if result.get('file_info'):
                result['file_info']['url'] = str(request.urls[i])
                if request.titles and i < len(request.titles):
                    result['file_info']['name'] = request.titles[i]

            api_result = _convert_to_api_result(result, file_id, timestamp)
            results.append(api_result)

        # Calculate batch statistics
        end_time = datetime.now()
        total_time = (end_time - start_time).total_seconds()
        successful = sum(1 for r in results if r.success)
        failed = len(results) - successful
        total_chars = sum(r.text_length for r in results if r.success)

        return BatchExtractionResult(
            batch_id=batch_id,
            total_files=len(results),
            successful=successful,
            failed=failed,
            total_processing_time=total_time,
            total_characters=total_chars,
            results=results,
            timestamp=timestamp
        )

    except Exception as e:
        logger.error(f"Error in batch YouTube processing: {e}")
        raise HTTPException(status_code=500, detail=f"Batch YouTube processing failed: {str(e)}")

# Utility functions
async def _save_uploaded_file(file: UploadFile, file_id: str) -> Path:
    """Save uploaded file to temporary location."""
    temp_dir = Path(tempfile.gettempdir()) / "ai_content_process"
    temp_dir.mkdir(exist_ok=True)

    # Create unique filename
    file_extension = Path(file.filename).suffix if file.filename else ""
    temp_file_path = temp_dir / f"{file_id}{file_extension}"

    async with aiofiles.open(temp_file_path, 'wb') as f:
        content = await file.read()
        await f.write(content)

    return temp_file_path

def _convert_to_api_result(result: Dict[str, Any], file_id: str, timestamp: str) -> ExtractionResult:
    """Convert internal result format to API response format."""
    if result['success']:
        file_info = FileInfo(**result['file_info'])
        return ExtractionResult(
            file_id=file_id,
            file_info=file_info,
            success=True,
            extracted_text=result['extracted_text'],
            processor_used=result['processor_used'],
            processing_time=result['processing_time'],
            text_length=result['text_length'],
            timestamp=timestamp
        )
    else:
        # Create minimal file info for failed cases
        file_info = FileInfo(
            name=Path(result['file_path']).name,
            extension=Path(result['file_path']).suffix,
            size_mb=0.0,
            mime_type="unknown"
        )
        return ExtractionResult(
            file_id=file_id,
            file_info=file_info,
            success=False,
            error=result['error'],
            extracted_text=None,
            processor_used=result.get('processor_used'),
            processing_time=0.0,
            text_length=0,
            timestamp=timestamp
        )

async def download_file_from_url(url: str, file_id: str, custom_filename: str = None, temp_dir: Path = None) -> tuple:
    """Download file from URL and return path, filename, and size."""
    if temp_dir is None:
        temp_dir = Path(tempfile.gettempdir()) / "ai_content_process"
        temp_dir.mkdir(exist_ok=True)

    try:
        async with aiohttp.ClientSession() as session:
            async with session.get(url) as response:
                response.raise_for_status()

                # Determine filename
                if custom_filename:
                    filename = custom_filename
                else:
                    # Try to get filename from Content-Disposition header
                    content_disposition = response.headers.get('Content-Disposition', '')
                    if 'filename=' in content_disposition:
                        filename = content_disposition.split('filename=')[1].strip('"')
                    else:
                        # Extract from URL
                        url_path = Path(url.split('?')[0])  # Remove query parameters
                        filename = url_path.name or f"download_{file_id}"

                # Ensure filename has extension
                if not Path(filename).suffix and response.headers.get('Content-Type'):
                    content_type = response.headers['Content-Type'].split(';')[0]
                    extension_map = {
                        'application/pdf': '.pdf',
                        'application/msword': '.doc',
                        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
                        'video/mp4': '.mp4',
                        'audio/mpeg': '.mp3',
                        'audio/webm': '.webm',
                        'video/webm': '.webm',
                        'audio/ogg': '.ogg',
                        'application/ogg': '.ogg',
                        'text/plain': '.txt'
                    }
                    if content_type in extension_map:
                        filename += extension_map[content_type]

                # Create unique temp file path
                temp_file_path = temp_dir / f"{file_id}_{filename}"

                # Download file
                file_size = 0
                async with aiofiles.open(temp_file_path, 'wb') as f:
                    async for chunk in response.content.iter_chunked(8192):
                        await f.write(chunk)
                        file_size += len(chunk)

                return temp_file_path, filename, file_size

    except Exception as e:
        logger.error(f"Error downloading file from {url}: {e}")
        raise HTTPException(status_code=400, detail=f"Failed to download file: {str(e)}")

async def cleanup_temp_file(file_path: Path):
    """Clean up temporary file."""
    try:
        if file_path.exists():
            file_path.unlink()
            logger.debug(f"Cleaned up temp file: {file_path}")
    except Exception as e:
        logger.warning(f"Failed to cleanup temp file {file_path}: {e}")

async def cleanup_temp_directory(dir_path: Path):
    """Clean up temporary directory."""
    try:
        if dir_path.exists() and dir_path.is_dir():
            for file_path in dir_path.iterdir():
                if file_path.is_file():
                    file_path.unlink()
            dir_path.rmdir()
            logger.debug(f"Cleaned up temp directory: {dir_path}")
    except Exception as e:
        logger.warning(f"Failed to cleanup temp directory {dir_path}: {e}")

# Exception handlers
@app.exception_handler(HTTPException)
async def http_exception_handler(request, exc):
    """Handle HTTP exceptions with structured error response."""
    return JSONResponse(
        status_code=exc.status_code,
        content=ErrorResponse(
            error=f"HTTP {exc.status_code}",
            detail=exc.detail,
            timestamp=datetime.now().isoformat()
        ).dict()
    )

@app.exception_handler(Exception)
async def general_exception_handler(request, exc):
    """Handle general exceptions with structured error response."""
    logger.error(f"Unhandled exception: {exc}")
    logger.error(traceback.format_exc())
    return JSONResponse(
        status_code=500,
        content=ErrorResponse(
            error="Internal Server Error",
            detail="An unexpected error occurred. Please try again later.",
            timestamp=datetime.now().isoformat()
        ).dict()
    )

# Audio file serving endpoint
@app.get("/audio/{audio_id}")
async def get_audio_file(audio_id: str, background_tasks: BackgroundTasks):
    """Serve generated audio files and schedule cleanup."""
    try:
        # Find the audio file in temp directory
        temp_dir = Path(tempfile.gettempdir())
        audio_files = list(temp_dir.glob(f"runway_audio_{audio_id}*.mp3"))

        if not audio_files:
            raise HTTPException(status_code=404, detail="Audio file not found")

        audio_file = audio_files[0]

        if not audio_file.exists():
            raise HTTPException(status_code=404, detail="Audio file not found")

        # Schedule cleanup after serving (delay to allow download)
        background_tasks.add_task(cleanup_audio_file, audio_file)

        # Serve the file
        return FileResponse(
            path=str(audio_file),
            media_type="audio/mpeg",
            filename=f"generated_audio_{audio_id}.mp3",
            headers={"Content-Disposition": "inline"}  # Allow inline playback
        )

    except Exception as e:
        logger.error(f"Error serving audio file {audio_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to serve audio file")

async def cleanup_audio_file(file_path: Path, delay: int = 300):
    """Clean up audio file after delay (5 minutes by default)."""
    try:
        await asyncio.sleep(delay)  # Wait before cleanup
        if file_path.exists():
            file_path.unlink()
            logger.info(f"🗑️ Cleaned up audio file: {file_path.name}")
    except Exception as e:
        logger.error(f"Error cleaning up audio file {file_path}: {e}")

# Merged video file serving endpoint
@app.get("/merged-video/{video_id}")
async def get_merged_video_file(video_id: str, background_tasks: BackgroundTasks):
    """Serve merged video files and schedule cleanup."""
    try:
        # Find the merged video file in temp directory
        temp_dir = Path(tempfile.gettempdir())
        video_files = list(temp_dir.glob(f"*_merged_{video_id}.mp4"))

        if not video_files:
            raise HTTPException(status_code=404, detail="Merged video file not found")

        video_file = video_files[0]

        if not video_file.exists():
            raise HTTPException(status_code=404, detail="Merged video file not found")

        # Schedule cleanup after serving (delay to allow download)
        background_tasks.add_task(cleanup_video_file, video_file)

        # Serve the file
        return FileResponse(
            path=str(video_file),
            media_type="video/mp4",
            filename=f"merged_video_{video_id}.mp4",
            headers={"Content-Disposition": "inline"}  # Allow inline playback
        )

    except Exception as e:
        logger.error(f"Error serving merged video file {video_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to serve merged video file")

async def cleanup_video_file(file_path: Path, delay: int = 600):
    """Clean up video file after delay (10 minutes by default)."""
    try:
        await asyncio.sleep(delay)  # Wait before cleanup
        if file_path.exists():
            file_path.unlink()
            logger.info(f"🗑️ Cleaned up video file: {file_path.name}")
    except Exception as e:
        logger.error(f"Error cleaning up video file {file_path}: {e}")

# Run server
if __name__ == "__main__":
    uvicorn.run(
        "api_server:app",
        host="0.0.0.0",
        port=8000,
        reload=True,
        log_level="info"
    )