"""Video Service API - FastAPI endpoints for video generation."""
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, Field
from typing import Optional
from pathlib import Path
from datetime import datetime
import sys

sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))

from shared.config import settings
from shared.logging_config import setup_logging
from services.video.providers.mock_provider import get_mock_provider

logger = setup_logging("video.api")

app = FastAPI(
    title="Video Generation Service",
    description="Video generation API with multiple provider support",
    version="1.0.0"
)


class VideoGenerationRequest(BaseModel):
    """Video generation request."""
    prompt: str = Field(..., description="Text description of the video")
    duration: int = Field(30, ge=1, le=300, description="Duration in seconds")
    resolution: str = Field("1080p", description="Video resolution")
    fps: int = Field(30, ge=24, le=60, description="Frames per second")
    style: Optional[str] = Field(None, description="Visual style")
    provider: str = Field("mock", description="Video provider (mock, veo3, hunyuan)")


class VideoWithAudioRequest(BaseModel):
    """Video generation with audio request."""
    prompt: str = Field(..., description="Text description of the video")
    audio_file: str = Field(..., description="Path to audio file")
    resolution: str = Field("1080p", description="Video resolution")
    fps: int = Field(30, ge=24, le=60, description="Frames per second")
    style: Optional[str] = Field(None, description="Visual style")
    provider: str = Field("mock", description="Video provider")


class JobResponse(BaseModel):
    """Job response."""
    job_id: str
    status: str
    message: Optional[str] = None


class JobStatusResponse(BaseModel):
    """Job status response."""
    job_id: str
    status: str
    progress: int
    video_file: Optional[str] = None
    metadata: Optional[dict] = None
    error: Optional[str] = None


@app.get("/health")
async def health_check():
    """Health check endpoint."""
    return {
        "status": "healthy",
        "service": "video",
        "timestamp": datetime.utcnow(),
        "providers": ["mock"]  # Will expand with real providers
    }


@app.post("/generate", response_model=JobResponse, status_code=status.HTTP_202_ACCEPTED)
async def generate_video(request: VideoGenerationRequest):
    """Generate video from text prompt.
    
    Args:
        request: Generation request
        
    Returns:
        Job ID for tracking
    """
    logger.info(f"Video generation request: {request.prompt[:50]}...")
    
    # Get provider (currently only mock)
    if request.provider != "mock":
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Provider '{request.provider}' not yet implemented. Use 'mock' for testing."
        )
    
    provider = get_mock_provider()
    
    # Start generation
    result = await provider.generate(
        prompt=request.prompt,
        duration=request.duration,
        resolution=request.resolution,
        fps=request.fps,
        style=request.style
    )
    
    return JobResponse(
        job_id=result["job_id"],
        status=result["status"],
        message=result.get("message")
    )


@app.post("/generate-with-audio", response_model=JobResponse, status_code=status.HTTP_202_ACCEPTED)
async def generate_video_with_audio(request: VideoWithAudioRequest):
    """Generate video synchronized with audio.
    
    Args:
        request: Generation request with audio
        
    Returns:
        Job ID for tracking
    """
    logger.info(f"Video+audio generation request: {request.prompt[:50]}...")
    
    # Get provider
    if request.provider != "mock":
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Provider '{request.provider}' not yet implemented. Use 'mock' for testing."
        )
    
    provider = get_mock_provider()
    
    # Start generation
    result = await provider.generate_with_audio(
        prompt=request.prompt,
        audio_file=request.audio_file,
        resolution=request.resolution,
        fps=request.fps,
        style=request.style
    )
    
    return JobResponse(
        job_id=result["job_id"],
        status=result["status"],
        message=result.get("message")
    )


@app.get("/jobs/{job_id}", response_model=JobStatusResponse)
async def get_job_status(job_id: str, provider: str = "mock"):
    """Get video generation job status.
    
    Args:
        job_id: Job ID
        provider: Provider name
        
    Returns:
        Job status
    """
    # Get provider
    if provider != "mock":
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Provider '{provider}' not yet implemented"
        )
    
    provider_instance = get_mock_provider()
    status_info = await provider_instance.check_status(job_id)
    
    if status_info.get("status") == "not_found":
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Job not found"
        )
    
    return JobStatusResponse(
        job_id=job_id,
        status=status_info["status"],
        progress=status_info.get("progress", 0),
        video_file=status_info.get("video_file"),
        metadata=status_info.get("metadata"),
        error=status_info.get("error")
    )


if __name__ == "__main__":
    import uvicorn
    
    uvicorn.run(
        "video_api:app",
        host="0.0.0.0",
        port=8003,
        reload=True
    )