#!/usr/bin/env python3
"""Pipeline principal de processamento de vídeo."""

import json
import os
import re
from pathlib import Path

import anthropic

from whisper_utils import transcrever_audio
from pexels_utils import buscar_videos, baixar_video
from ffmpeg_utils import cortar_segmentos as _cortar_segmentos, montar_video_final
from music_utils import obter_musica_para_video

ANTHROPIC_KEY = "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"
PEXELS_KEY = os.getenv("PEXELS_API_KEY", "PEXELS_API_KEY_PLACEHOLDER")

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


def analisar_para_broll(transcricao: dict) -> list:
    """
    Envia o texto transcrito ao Claude Haiku para gerar termos de B-roll.
    Retorna lista de {"query": "...", "inicio": float, "duracao": int}.
    """
    client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)

    texto = transcricao.get("texto", "")[:2000]
    segmentos = transcricao.get("segmentos", [])
    duracao = segmentos[-1]["fim"] if segmentos else 60

    prompt = f"""Analise esta narração de vídeo para Instagram e sugira termos de busca para B-roll da biblioteca Pexels.

Texto: {texto}
Duração total: {duracao:.0f} segundos

Retorne APENAS um JSON válido com 4 a 6 termos em inglês, distribuídos ao longo do vídeo:
{{
  "brolls": [
    {{"query": "business meeting office", "inicio": 8, "duracao": 5}},
    {{"query": "technology artificial intelligence", "inicio": 20, "duracao": 5}}
  ]
}}

Use termos visuais simples em inglês. Priorize conceitos mencionados no conteúdo."""

    try:
        resp = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=600,
            messages=[{"role": "user", "content": prompt}]
        )
        text = resp.content[0].text
        match = re.search(r"\{.*\}", text, re.DOTALL)
        if match:
            data = json.loads(match.group())
            return data.get("brolls", [])
    except Exception as e:
        print(f"[claude] Erro ao analisar para b-roll: {e}")

    return []


def escolher_musica() -> str:
    """Retorna o caminho de uma música aleatória do diretório music/, ou '' se vazio."""
    if not MUSIC_DIR.exists():
        return ""
    musicas = list(MUSIC_DIR.glob("*.mp3")) + list(MUSIC_DIR.glob("*.m4a")) + list(MUSIC_DIR.glob("*.aac"))
    if not musicas:
        return ""
    import random
    return str(random.choice(musicas))


def processar_video(
    job_id: str,
    video_path: str,
    modo: str,
    segmentos: list,
    usar_musica: bool,
    estilo_legenda: str,
    callback_status
):
    """
    Pipeline completo:
    1. Corta segmentos (modo live)
    2. Transcrição Whisper
    3. Analise Claude para b-roll
    4. Download b-roll Pexels
    5. Montagem final com FFmpeg
    """
    try:
        # Fase 1
        callback_status(job_id, "fila", 5, "Preparando vídeo...")
        if modo == "live" and segmentos:
            print(f"[proc] Cortando {len(segmentos)} segmentos...")
            video_path = _cortar_segmentos(video_path, segmentos, job_id)

        # Fase 2
        callback_status(job_id, "transcrevendo", 15, "Transcrevendo áudio com IA...")
        print(f"[proc] Transcrevendo {video_path}...")
        transcricao = transcrever_audio(video_path)
        print(f"[proc] Transcrição OK. Segmentos: {len(transcricao['segmentos'])}")

        # Fase 3
        callback_status(job_id, "analisando", 30, "Analisando conteúdo para buscar B-roll...")
        termos = analisar_para_broll(transcricao)
        print(f"[proc] Termos b-roll: {[t['query'] for t in termos]}")

        # Fase 4
        callback_status(job_id, "baixando_broll", 45, "Buscando vídeos de apoio...")
        clips_broll = []
        for i, termo in enumerate(termos[:6]):
            query = termo.get("query", "")
            if not query:
                continue
            videos = buscar_videos(query, quantidade=2)
            for j, v in enumerate(videos[:1]):
                dest = str(TEMP_DIR / f"{job_id}_broll_{i}_{j}.mp4")
                ok = baixar_video(v["url"], dest)
                if ok:
                    clips_broll.append(dest)
                    break
            callback_status(job_id, "baixando_broll", 45 + i * 3, f"Baixando B-roll: {query}...")

        print(f"[proc] B-rolls baixados: {len(clips_broll)}")

        # Fase 5
        callback_status(job_id, "montando", 65, "Montando vídeo final...")
        output_path = str(OUTPUT_DIR / f"{job_id}_final.mp4")

        # Busca música automática pelo ccMixter baseado no conteúdo
        musica_path = ""
        if usar_musica:
            callback_status(job_id, "montando", 60, "Buscando trilha sonora automática...")
            musica_path = obter_musica_para_video(transcricao.get("texto", ""), job_id) or ""
            if musica_path:
                print(f"[proc] Música automática: {musica_path}")
            else:
                # Fallback: procura em arquivos locais
                musicas_locais = list(MUSIC_DIR.glob("*.mp3")) if MUSIC_DIR.exists() else []
                if musicas_locais:
                    import random
                    musica_path = str(random.choice(musicas_locais))
                    print(f"[proc] Música local (fallback): {musica_path}")

        montar_video_final(
            video_principal=video_path,
            clips_broll=clips_broll,
            transcricao=transcricao,
            musica_path=musica_path,
            estilo_legenda=estilo_legenda,
            job_id=job_id,
            output_path=output_path
        )

        if not Path(output_path).exists():
            raise RuntimeError("Arquivo de saída não foi gerado pelo FFmpeg.")

        callback_status(job_id, "concluido", 100, "Pronto! Seu Reel está pronto.", output_path)

    except Exception as e:
        print(f"[proc] ERRO no job {job_id}: {e}")
        import traceback
        traceback.print_exc()
        callback_status(job_id, "erro", 0, f"Erro no processamento: {str(e)}")