"""
Módulo de música automática via ccMixter (Creative Commons)
Claude analisa o conteúdo do vídeo → define mood → ccMixter retorna trilha MP3 gratuita
"""
import requests
import os
import re
import anthropic
from pathlib import Path

ANTHROPIC_KEY = "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"
TEMP_DIR = Path(__file__).parent / "temp"
CCMIXTER_URL = "http://ccmixter.org/api/query"

# Mapeamento de mood para tags do ccMixter
MOOD_TAGS = {
    "upbeat":     "upbeat,instrumental",
    "inspiring":  "inspiring,instrumental",
    "corporate":  "corporate,instrumental",
    "energetic":  "energetic,electronic,instrumental",
    "calm":       "ambient,calm,instrumental",
    "dramatic":   "cinematic,instrumental",
    "happy":      "happy,upbeat,instrumental",
    "motivational": "motivational,inspiring,instrumental",
}


def analisar_mood_do_video(texto_transcricao: str) -> str:
    """
    Claude analisa a transcrição e retorna o mood ideal para a trilha sonora.
    Retorna um dos: upbeat, inspiring, corporate, energetic, calm, dramatic, happy, motivational
    """
    if not texto_transcricao.strip():
        return "inspiring"

    client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
    prompt = f"""Analise o texto abaixo (transcrição de um vídeo para Instagram) e escolha o mood ideal para a trilha sonora de fundo.

Texto: {texto_transcricao[:1000]}

Responda com UMA PALAVRA apenas, escolhendo entre:
upbeat, inspiring, corporate, energetic, calm, dramatic, happy, motivational

Considere:
- Conteúdo motivacional/empreendedorismo = inspiring ou motivational
- Conteúdo de IA/tecnologia = corporate ou energetic
- Conteúdo de estilo de vida = upbeat ou happy
- Conteúdo educativo = calm ou corporate
- Conteúdo de vendas = upbeat ou energetic

Responda apenas com a palavra."""

    try:
        resp = client.messages.create(
            model="claude-haiku-4-5-20251001",
            max_tokens=10,
            messages=[{"role": "user", "content": prompt}]
        )
        mood = resp.content[0].text.strip().lower()
        return mood if mood in MOOD_TAGS else "inspiring"
    except Exception:
        return "inspiring"


def buscar_musica_ccmixter(mood: str, duracao_min_seg: int = 60) -> dict | None:
    """
    Busca uma trilha instrumental no ccMixter pelo mood.
    Filtra por licença comercial (Attribution sem NonCommercial).
    Retorna dict com url, nome, artista ou None.
    """
    tags = MOOD_TAGS.get(mood, "instrumental,background")

    try:
        r = requests.get(CCMIXTER_URL, params={
            "tags": tags,
            "type": "media",       # tracks completas (não samples)
            "format": "json",
            "limit": 10,
            "ord": "score",        # mais populares primeiro
        }, timeout=15)

        if r.status_code != 200:
            return None

        tracks = r.json()

        for track in tracks:
            # Filtra licenças comercialmente usáveis (Attribution sem NonCommercial)
            license_name = track.get("license_name", "")
            if "Noncommercial" in license_name or "NonCommercial" in license_name:
                continue

            # Pega o arquivo MP3 principal
            files = track.get("files", [])
            mp3_file = next((f for f in files if f.get("file_nicname") == "mp3"), None)
            if not mp3_file:
                mp3_file = next((f for f in files if f.get("file_format_info", {}).get("default-ext") == "mp3"), None)

            if mp3_file and mp3_file.get("download_url"):
                return {
                    "url": mp3_file["download_url"],
                    "nome": track.get("upload_name", "Trilha"),
                    "artista": track.get("user_real_name") or track.get("user_name", "Unknown"),
                    "licenca": license_name,
                    "mood": mood
                }

    except Exception as e:
        print(f"[music] Erro ao buscar no ccMixter: {e}")

    return None


def baixar_musica(url: str, destino: str) -> bool:
    """Baixa o MP3 para o caminho especificado."""
    try:
        r = requests.get(url, stream=True, timeout=30,
                         headers={"User-Agent": "Mozilla/5.0"})
        r.raise_for_status()
        with open(destino, "wb") as f:
            for chunk in r.iter_content(chunk_size=8192):
                f.write(chunk)
        return os.path.getsize(destino) > 10000  # mínimo 10KB
    except Exception as e:
        print(f"[music] Erro ao baixar música: {e}")
        return False


def obter_musica_para_video(texto_transcricao: str, job_id: str) -> str | None:
    """
    Pipeline completo: analisa mood → busca trilha → baixa → retorna caminho local.
    Retorna o caminho do MP3 baixado ou None se falhar.
    """
    print(f"[music] Analisando mood do conteúdo...")
    mood = analisar_mood_do_video(texto_transcricao)
    print(f"[music] Mood detectado: {mood}")

    print(f"[music] Buscando trilha no ccMixter para mood '{mood}'...")
    track = buscar_musica_ccmixter(mood)

    if not track:
        # Fallback: tenta com mood genérico
        print(f"[music] Nenhuma trilha encontrada para '{mood}', tentando fallback...")
        track = buscar_musica_ccmixter("instrumental")

    if not track:
        print(f"[music] Nenhuma trilha disponível.")
        return None

    print(f"[music] Trilha: '{track['nome']}' por {track['artista']}")
    destino = str(TEMP_DIR / f"{job_id}_music.mp3")

    if baixar_musica(track["url"], destino):
        print(f"[music] Download concluído: {destino}")
        return destino

    return None