#!/usr/bin/env python3
"""Backend do Video Editor - Flask porta 5054"""

import json
import os
import threading
import time
import uuid
from datetime import datetime, timedelta
from pathlib import Path

from flask import Flask, jsonify, request, send_file
from flask_cors import CORS

from processor import processar_video

# ---------------------------------------------------------------------------
# Config
# ---------------------------------------------------------------------------
TEMP_DIR = Path(__file__).parent / "temp"
OUTPUT_DIR = Path(__file__).parent / "output"
MUSIC_DIR = Path(__file__).parent / "music"

for d in [TEMP_DIR, OUTPUT_DIR, MUSIC_DIR]:
    d.mkdir(exist_ok=True)

app = Flask(__name__)
CORS(app, origins="*", supports_credentials=True)

# Jobs em memória: job_id -> dict
jobs: dict = {}

# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

def callback_status(job_id: str, status: str, progresso: int, mensagem: str, video_path: str = None):
    if job_id not in jobs:
        return
    jobs[job_id].update({
        "status": status,
        "progresso": progresso,
        "mensagem": mensagem,
        "updated_at": datetime.utcnow().isoformat()
    })
    if video_path:
        jobs[job_id]["video_path"] = video_path


def cleanup_old_files():
    """Remove arquivos temporários e de output com mais de 24 horas."""
    cutoff = datetime.now() - timedelta(hours=24)
    for d in [TEMP_DIR, OUTPUT_DIR]:
        for f in d.iterdir():
            if f.is_file():
                mtime = datetime.fromtimestamp(f.stat().st_mtime)
                if mtime < cutoff:
                    try:
                        f.unlink()
                    except Exception:
                        pass

# Roda cleanup na inicialização
cleanup_old_files()

# ---------------------------------------------------------------------------
# Endpoints
# ---------------------------------------------------------------------------

@app.route("/api/health", methods=["GET"])
def health():
    return jsonify({"status": "ok", "timestamp": datetime.utcnow().isoformat()})


@app.route("/api/processar", methods=["POST"])
def processar():
    """Inicia o processamento de um vídeo."""
    if "video" not in request.files:
        return jsonify({"erro": "Arquivo de vídeo não enviado."}), 400

    video_file = request.files["video"]
    if not video_file.filename:
        return jsonify({"erro": "Nome do arquivo inválido."}), 400

    # Valida extensão
    ext = Path(video_file.filename).suffix.lower()
    if ext not in {".mp4", ".mov", ".avi", ".webm", ".mkv"}:
        return jsonify({"erro": f"Formato não suportado: {ext}"}), 400

    modo = request.form.get("modo", "clip")
    usar_musica = request.form.get("musica", "true").lower() == "true"
    estilo_legenda = request.form.get("estilo_legenda", "branca")

    segmentos = []
    seg_json = request.form.get("segmentos", "[]")
    try:
        segmentos = json.loads(seg_json)
    except Exception:
        pass

    job_id = str(uuid.uuid4())

    # Salva o vídeo no temp
    video_path = str(TEMP_DIR / f"{job_id}_input{ext}")
    video_file.save(video_path)

    # Registra job
    jobs[job_id] = {
        "status": "fila",
        "progresso": 0,
        "mensagem": "Na fila...",
        "video_path": None,
        "created_at": datetime.utcnow().isoformat(),
        "updated_at": datetime.utcnow().isoformat()
    }

    # Dispara processamento em background
    t = threading.Thread(
        target=processar_video,
        args=(job_id, video_path, modo, segmentos, usar_musica, estilo_legenda, callback_status),
        daemon=True
    )
    t.start()

    return jsonify({"job_id": job_id})


@app.route("/api/job/<job_id>", methods=["GET"])
def status_job(job_id: str):
    """Retorna status atual de um job."""
    if job_id not in jobs:
        return jsonify({"erro": "Job não encontrado."}), 404

    job = jobs[job_id].copy()
    result = {
        "status": job["status"],
        "progresso": job["progresso"],
        "mensagem": job["mensagem"]
    }

    if job["status"] == "concluido" and job.get("video_path"):
        result["video_url"] = f"/api/download/{job_id}"

    return jsonify(result)


@app.route("/api/download/<job_id>", methods=["GET"])
def download_video(job_id: str):
    """Baixa o vídeo processado."""
    if job_id not in jobs:
        return jsonify({"erro": "Job não encontrado."}), 404

    job = jobs[job_id]
    if job["status"] != "concluido" or not job.get("video_path"):
        return jsonify({"erro": "Vídeo ainda não disponível."}), 404

    video_path = job["video_path"]
    if not Path(video_path).exists():
        return jsonify({"erro": "Arquivo não encontrado no servidor."}), 404

    return send_file(
        video_path,
        mimetype="video/mp4",
        as_attachment=True,
        download_name=f"reel_{job_id[:8]}.mp4"
    )


@app.route("/api/musicas", methods=["GET"])
def listar_musicas():
    """Lista músicas disponíveis no diretório music/."""
    musicas = []
    for ext in ("*.mp3", "*.m4a", "*.aac"):
        for f in MUSIC_DIR.glob(ext):
            musicas.append({"nome": f.stem, "arquivo": f.name})
    return jsonify({"musicas": musicas, "total": len(musicas)})


# ---------------------------------------------------------------------------
# Startup
# ---------------------------------------------------------------------------
if __name__ == "__main__":
    print("=" * 60)
    print("Video Editor Backend - Porta 5054")
    print(f"Temp dir:   {TEMP_DIR}")
    print(f"Output dir: {OUTPUT_DIR}")
    print(f"Music dir:  {MUSIC_DIR}")
    print("=" * 60)
    app.run(host="0.0.0.0", port=5054, debug=False, threaded=True)