import os
import uuid
import asyncio
import subprocess
import shutil
from fastapi import FastAPI, Query, HTTPException
from fastapi.responses import FileResponse
from fastapi.middleware.cors import CORSMiddleware
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI(title="M3U8 to MP4 Converter", version="1.0.0")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

TEMP_DIR = "/tmp/m3u8_conversions"
os.makedirs(TEMP_DIR, exist_ok=True)

active_conversions = {}


def cleanup_files(file_paths):
    for path in file_paths:
        try:
            if os.path.exists(path):
                if os.path.isdir(path):
                    shutil.rmtree(path)
                else:
                    os.remove(path)
                logger.info(f"Cleaned up: {path}")
        except Exception as e:
            logger.error(f"Cleanup error for {path}: {e}")


def get_ffmpeg_path():
    ffmpeg_path = shutil.which("ffmpeg")
    if ffmpeg_path:
        return ffmpeg_path
    for path in ["/usr/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/app/ffmpeg", "./ffmpeg"]:
        if os.path.exists(path):
            return path
    return "ffmpeg"


async def convert_m3u8_to_mp4(m3u8_url: str, output_path: str, task_id: str):
    ffmpeg = get_ffmpeg_path()
    
    cmd = [
        ffmpeg,
        "-i", m3u8_url,
        "-c", "copy",
        "-bsf:a", "aac_adtstoasc",
        "-movflags", "+faststart",
        "-y",
        output_path
    ]
    
    cmd_fallback = [
        ffmpeg,
        "-i", m3u8_url,
        "-c:v", "libx264",
        "-preset", "fast",
        "-crf", "23",
        "-c:a", "aac",
        "-b:a", "128k",
        "-movflags", "+faststart",
        "-y",
        output_path
    ]
    
    logger.info(f"Starting conversion: {task_id}")
    logger.info(f"Command: {' '.join(cmd)}")
    
    active_conversions[task_id] = {"status": "converting", "progress": 0}
    
    try:
        process = await asyncio.create_subprocess_exec(
            *cmd,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE
        )
        
        stdout, stderr = await process.communicate()
        
        if process.returncode != 0:
            logger.warning(f"Copy mode failed, trying re-encode mode: {stderr.decode()[:500]}")
            active_conversions[task_id]["status"] = "re-encoding"
            
            process = await asyncio.create_subprocess_exec(
                *cmd_fallback,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.PIPE
            )
            stdout, stderr = await process.communicate()
            
            if process.returncode != 0:
                raise Exception(f"Conversion failed: {stderr.decode()[:1000]}")
        
        active_conversions[task_id]["status"] = "completed"
        logger.info(f"Conversion completed: {task_id}")
        
    except Exception as e:
        active_conversions[task_id]["status"] = "failed"
        active_conversions[task_id]["error"] = str(e)
        logger.error(f"Conversion error: {e}")
        raise


@app.get("/")
def root():
    return {
        "message": "M3U8 to MP4 Converter API",
        "usage": "/video?url=<m3u8-url>&format=mp4",
        "endpoints": {
            "convert": "/video?url=<m3u8-url>&format=mp4",
            "status": "/status/<task_id>"
        }
    }


@app.get("/video")
async def convert_video(
    url: str = Query(..., description="M3U8 URL to convert"),
    format: str = Query("mp4", description="Output format (mp4 only)")
):
    if not url:
        raise HTTPException(status_code=400, detail="URL parameter is required")
    
    if not url.startswith(("http://", "https://")):
        raise HTTPException(status_code=400, detail="Invalid URL format")
    
    task_id = str(uuid.uuid4())
    output_filename = f"video_{task_id}.mp4"
    output_path = os.path.join(TEMP_DIR, output_filename)
    
    try:
        await convert_m3u8_to_mp4(url, output_path, task_id)
        
        if not os.path.exists(output_path):
            raise HTTPException(status_code=500, detail="Conversion failed - output file not created")
        
        file_size = os.path.getsize(output_path)
        logger.info(f"File size: {file_size} bytes")
        
        response = FileResponse(
            path=output_path,
            media_type="video/mp4",
            filename=f"converted_video_{task_id}.mp4",
            headers={
                "Content-Disposition": f'attachment; filename="converted_video_{task_id}.mp4"'
            }
        )
        
        @response.background
        def cleanup():
            cleanup_files([output_path])
        
        return response
        
    except HTTPException:
        cleanup_files([output_path])
        raise
    except Exception as e:
        cleanup_files([output_path])
        logger.error(f"Error: {e}")
        raise HTTPException(status_code=500, detail=f"Conversion error: {str(e)}")


@app.get("/status/{task_id}")
def get_status(task_id: str):
    if task_id not in active_conversions:
        return {"status": "not_found"}
    return active_conversions[task_id]


@app.get("/health")
def health_check():
    ffmpeg = get_ffmpeg_path()
    ffmpeg_available = os.path.exists(ffmpeg) or shutil.which("ffmpeg") is not None
    return {
        "status": "healthy",
        "ffmpeg_available": ffmpeg_available,
        "ffmpeg_path": ffmpeg
    }


if __name__ == "__main__":
    import uvicorn
    port = int(os.environ.get("PORT", 7860))
    uvicorn.run(app, host="0.0.0.0", port=port)