"""
ScriptGenius - AI-powered script generation, hook bank, CTA optimization, and TTS.
Uses Ollama + Qwen 2.5 3B local (R$0/mes).
"""

import logging
import re
from datetime import datetime

from sqlalchemy.orm import Session

from backend.models.script import Script, HookEntry, ScriptTemplate

logger = logging.getLogger(__name__)


# ─── Script Generation (5 functions) ───────────────────────────


async def generate_script(topic: str, platform: str = "tiktok", style: str = "tutorial",
                          duration: int = 30, language: str = "pt-BR") -> dict:
    """Generate a complete video script using AI."""
    from backend.services.local_ai import llm_chat

    style_guides = {
        "tutorial": "Tutorial educativo, passo a passo, claro e objetivo",
        "storytelling": "Narrativa envolvente com arco emocional, personagem e conflito",
        "humor": "Comedia, timing de piada, absurdo relatable, punchline forte",
        "review": "Review honesto, pros e contras, veredicto final",
        "trending": "Seguindo tendencia viral, formato rapido, imitavel",
        "motivacional": "Inspirador, superacao, call-to-action emocional",
        "lista": "Top X, lista rapida, cada item impactante",
        "antes_depois": "Transformacao visivel, contraste forte, resultado impressionante",
        "pov": "POV/ponto de vista, primeira pessoa, imersivo",
        "react": "Reacao a algo, expressao genuina, comentario sobre conteudo",
    }

    guide = style_guides.get(style, style_guides["tutorial"])

    prompt = f"""Crie um roteiro completo para video de {platform} sobre: "{topic}"

ESTILO: {guide}
DURACAO: ~{duration} segundos
IDIOMA: {language}

Estruture EXATAMENTE assim:

HOOK (primeiros 3 segundos - capture atencao):
[hook poderoso aqui]

DESENVOLVIMENTO (corpo do video):
[conteudo principal dividido em blocos curtos]

CTA (chamada para acao final):
[CTA forte aqui]

HASHTAGS:
[5-8 hashtags relevantes]

DICAS DE GRAVACAO:
[2-3 dicas rapidas de como gravar]

IMPORTANTE:
- Use linguagem natural, como se estivesse falando
- Frases curtas (max 15 palavras)
- Cada bloco deve ter ritmo rapido
- Hook deve gerar curiosidade imediata"""

    result = await llm_chat(prompt, system="Voce e um roteirista profissional de videos virais para redes sociais brasileiras.", max_tokens=1500)

    # Parse sections
    hook = ""
    body = ""
    cta = ""
    hashtags = []

    if result:
        sections = result.split("\n")
        current = ""
        for line in sections:
            line_lower = line.strip().lower()
            if "hook" in line_lower and (":" in line or line_lower.startswith("hook")):
                current = "hook"
                continue
            elif any(x in line_lower for x in ["desenvolvimento", "corpo", "conteudo principal"]) and ":" in line:
                current = "body"
                continue
            elif "cta" in line_lower and ":" in line:
                current = "cta"
                continue
            elif "hashtag" in line_lower and ":" in line:
                current = "hashtags"
                continue
            elif "dica" in line_lower and ":" in line:
                current = "tips"
                continue

            if current == "hook":
                hook += line.strip() + "\n"
            elif current == "body":
                body += line.strip() + "\n"
            elif current == "cta":
                cta += line.strip() + "\n"
            elif current == "hashtags":
                tags = re.findall(r'#(\w+)', line)
                hashtags.extend(tags)

    return {
        "topic": topic,
        "platform": platform,
        "style": style,
        "hook": hook.strip(),
        "body": body.strip(),
        "cta": cta.strip(),
        "full_script": result or "Erro ao gerar script.",
        "hashtags": hashtags[:8],
        "duration_estimate": duration,
        "generated_at": datetime.utcnow().isoformat(),
    }


def get_script_templates() -> list[dict]:
    """Return built-in script templates."""
    return [
        {"name": "Tutorial Rapido", "style": "tutorial", "platform": "tiktok",
         "description": "Tutorial passo-a-passo em 30-60s",
         "structure": {"hook": "Pergunta/problema", "body": "3 passos rapidos", "cta": "Salva pra depois"}},
        {"name": "Storytelling Viral", "style": "storytelling", "platform": "all",
         "description": "Historia envolvente com plot twist",
         "structure": {"hook": "Situacao chocante", "body": "Narrativa + tensao", "cta": "Comenta o que faria"}},
        {"name": "Top 5 Lista", "style": "lista", "platform": "all",
         "description": "Lista rapida de dicas/itens",
         "structure": {"hook": "Voce nao sabia disso", "body": "5 itens rapidos", "cta": "Segue pra mais"}},
        {"name": "POV Relatable", "style": "pov", "platform": "tiktok",
         "description": "POV que todos se identificam",
         "structure": {"hook": "POV: situacao", "body": "Cena imersiva", "cta": "Marca alguem assim"}},
        {"name": "Review Honesto", "style": "review", "platform": "youtube",
         "description": "Review detalhado com veredicto",
         "structure": {"hook": "Vale a pena?", "body": "Pros/Contras", "cta": "Comenta sua experiencia"}},
        {"name": "Antes e Depois", "style": "antes_depois", "platform": "all",
         "description": "Transformacao visual impactante",
         "structure": {"hook": "Olha como estava", "body": "Processo rapido", "cta": "Quer aprender? Link na bio"}},
        {"name": "Humor/Sketch", "style": "humor", "platform": "tiktok",
         "description": "Sketch comico curto",
         "structure": {"hook": "Setup da piada", "body": "Buildup", "cta": "Punchline + segue"}},
        {"name": "React Tendencia", "style": "react", "platform": "tiktok",
         "description": "Reacao a video/trend viral",
         "structure": {"hook": "Gente, olha isso", "body": "Reacao + comentario", "cta": "Manda o que achou"}},
        {"name": "Motivacional 60s", "style": "motivacional", "platform": "all",
         "description": "Video inspirador com mensagem forte",
         "structure": {"hook": "Frase de impacto", "body": "Historia de superacao", "cta": "Compartilha com alguem"}},
        {"name": "Trend Viral", "style": "trending", "platform": "tiktok",
         "description": "Formato de tendencia atual",
         "structure": {"hook": "Usando trend X", "body": "Adaptacao criativa", "cta": "Faz o seu e me marca"}},
    ]


async def rewrite_for_viral(script_text: str) -> dict:
    """AI rewrite to make a script more viral."""
    from backend.services.local_ai import llm_chat

    prompt = f"""Reescreva este roteiro para ser MAIS VIRAL. Mantenha a essencia mas:
- Torne o hook irresistivel (primeiros 3 segundos)
- Use pattern interrupts a cada 5-7 segundos
- Adicione loops abertos (curiosidade que mantem assistindo)
- Frases mais curtas e impactantes
- CTA que gera acao imediata

ROTEIRO ORIGINAL:
{script_text[:2000]}

ROTEIRO VIRAL:"""

    result = await llm_chat(prompt, system="Voce e um especialista em viralidade. Reescreva roteiros para maximizar retencao e engajamento.", max_tokens=1500)
    return {"original": script_text[:500], "viral_version": result or "Erro ao reescrever.", "generated_at": datetime.utcnow().isoformat()}


def adapt_for_platform(script_text: str, target_platform: str) -> dict:
    """Adapt script for different platform requirements."""
    limits = {
        "tiktok": {"max_duration": 60, "max_chars": 2200, "hashtags": 5, "style": "rapido, informal, trend-friendly"},
        "instagram": {"max_duration": 90, "max_chars": 2200, "hashtags": 30, "style": "estetico, curado, carrossel-friendly"},
        "youtube": {"max_duration": 600, "max_chars": 5000, "hashtags": 15, "style": "detalhado, SEO-friendly, thumbnail-bait"},
    }
    cfg = limits.get(target_platform, limits["tiktok"])

    # Truncate if needed
    adapted = script_text[:cfg["max_chars"]]

    return {
        "platform": target_platform,
        "adapted_script": adapted,
        "platform_tips": cfg,
        "char_count": len(adapted),
        "within_limits": len(adapted) <= cfg["max_chars"],
    }


async def improve_script(script_text: str, focus: str = "engagement") -> dict:
    """AI-powered script improvement with specific focus."""
    from backend.services.local_ai import llm_chat

    focus_prompts = {
        "engagement": "Melhore para maximizar engajamento (likes, comentarios, shares)",
        "retention": "Melhore para maximizar retencao (watch time completo)",
        "conversion": "Melhore para maximizar conversao (clicks, vendas, seguidores)",
        "seo": "Otimize para SEO (descoberta, recomendacao do algoritmo)",
    }

    prompt = f"""Melhore este roteiro. Foco: {focus_prompts.get(focus, focus_prompts['engagement'])}

ROTEIRO:
{script_text[:2000]}

Retorne o roteiro melhorado e explique as mudancas feitas."""

    result = await llm_chat(prompt, system="Voce e um consultor de conteudo digital. Otimize roteiros com foco em resultados.", max_tokens=1500)
    return {"original": script_text[:500], "improved": result or "Erro ao melhorar.", "focus": focus, "generated_at": datetime.utcnow().isoformat()}


# ─── Hook Bank (5 functions) ──────────────────────────────────


def seed_hook_bank(db: Session) -> dict:
    """Seed the hook bank with 500+ proven hooks in PT-BR."""
    existing = db.query(HookEntry).count()
    if existing >= 100:
        return {"status": "already_seeded", "count": existing}

    hooks = [
        # Curiosidade
        ("Voce nao vai acreditar no que aconteceu quando...", "curiosidade"),
        ("Isso muda TUDO que voce sabe sobre...", "curiosidade"),
        ("Ninguem te conta isso sobre...", "curiosidade"),
        ("O segredo que os profissionais escondem...", "curiosidade"),
        ("Descobri algo que vai mudar sua vida...", "curiosidade"),
        ("Eu nao devia estar mostrando isso mas...", "curiosidade"),
        ("Por que ninguem fala sobre isso?", "curiosidade"),
        ("Isso e o que acontece quando voce...", "curiosidade"),
        ("Voce esta fazendo isso errado e nem sabe", "curiosidade"),
        ("A verdade que ninguem quer te contar sobre...", "curiosidade"),
        ("Eu testei por 30 dias e olha o resultado...", "curiosidade"),
        ("O que acontece se voce fizer isso por 1 semana?", "curiosidade"),
        ("Acabei de descobrir isso e precisava compartilhar", "curiosidade"),
        ("Voce ja parou pra pensar por que...", "curiosidade"),
        ("Todo mundo faz isso errado, vou te mostrar o certo", "curiosidade"),
        ("Isso parece impossivel mas funciona", "curiosidade"),
        ("Espera ate voce ver o final...", "curiosidade"),
        ("Voce nao esta preparado pra isso...", "curiosidade"),
        ("A maioria das pessoas nao sabe disso...", "curiosidade"),
        ("Isso vai te economizar MUITO tempo", "curiosidade"),
        # Choque
        ("Isso NAO deveria ser possivel...", "choque"),
        ("Eu perdi tudo fazendo isso...", "choque"),
        ("PARA tudo que voce esta fazendo e assiste isso", "choque"),
        ("Isso e ILEGAL e ninguem sabe", "choque"),
        ("Acabei de ser demitido e olha o que fiz...", "choque"),
        ("Gastei R$10.000 pra voce nao precisar gastar", "choque"),
        ("Fui enganado e nao quero que isso aconteca com voce", "choque"),
        ("A industria nao quer que voce saiba disso", "choque"),
        ("Eu cometi o PIOR erro da minha vida...", "choque"),
        ("Isso destruiu minha carreira em 24 horas", "choque"),
        ("Voce esta perdendo dinheiro todo dia sem saber", "choque"),
        ("O que fizeram comigo foi absurdo...", "choque"),
        ("Isso aconteceu DE VERDADE e eu filmei tudo", "choque"),
        ("Nunca mais faca isso, eu aprendi da pior forma", "choque"),
        ("Isso quase me custou TUDO...", "choque"),
        # Pergunta
        ("Voce sabia que 90% das pessoas erram nisso?", "pergunta"),
        ("Qual desses voce prefere? 1, 2 ou 3?", "pergunta"),
        ("Voce ja tentou fazer isso?", "pergunta"),
        ("Quem mais passa por isso?", "pergunta"),
        ("Isso acontece so comigo?", "pergunta"),
        ("Voce consegue adivinhar qual e o melhor?", "pergunta"),
        ("Verdade ou mito?", "pergunta"),
        ("Voce faria isso por R$1.000?", "pergunta"),
        ("Quanto voce pagaria por isso?", "pergunta"),
        ("Ja percebeu que...", "pergunta"),
        ("Voce se identifica com isso?", "pergunta"),
        ("Sou so eu ou todo mundo pensa assim?", "pergunta"),
        ("Qual a sua opiniao sobre isso?", "pergunta"),
        ("Me conta nos comentarios: voce ja...?", "pergunta"),
        ("Se voce pudesse escolher, qual seria?", "pergunta"),
        # Desafio
        ("Aposto que voce nao consegue fazer isso...", "desafio"),
        ("Tente nao rir assistindo isso...", "desafio"),
        ("Te desafio a tentar por 7 dias", "desafio"),
        ("Ninguem consegue acertar de primeira...", "desafio"),
        ("99% das pessoas nao conseguem fazer isso", "desafio"),
        ("Tenta fazer isso e me marca no resultado", "desafio"),
        ("Aposto que voce nao sabia disso", "desafio"),
        ("Ve se voce consegue assistir ate o final", "desafio"),
        ("Desafio aceito! Olha o que eu fiz...", "desafio"),
        ("Sera que voce acerta? Comenta antes de ver", "desafio"),
        # Urgencia
        ("URGENTE: isso vai sair do ar em breve...", "urgencia"),
        ("Salva esse video AGORA antes que sumam...", "urgencia"),
        ("Aproveita enquanto ainda e gratis...", "urgencia"),
        ("Isso vai explodir nas proximas 24 horas", "urgencia"),
        ("Corre que ta acabando...", "urgencia"),
        ("Ultima chance de aprender isso de graca", "urgencia"),
        ("Se voce nao fizer isso hoje, vai se arrepender", "urgencia"),
        ("Isso so funciona se voce fizer AGORA", "urgencia"),
        ("Amanha pode ser tarde demais...", "urgencia"),
        ("Aproveita essa dica antes que viralize", "urgencia"),
        # Autoridade
        ("Como especialista em X, posso te garantir...", "autoridade"),
        ("Depois de 10 anos na area, descobri que...", "autoridade"),
        ("Trabalhei com os melhores e te digo...", "autoridade"),
        ("Com mais de 1000 clientes atendidos, percebi...", "autoridade"),
        ("Estudei isso por anos e a conclusao e...", "autoridade"),
        ("Os dados mostram algo surpreendente...", "autoridade"),
        ("Como alguem que ja faturou X com isso...", "autoridade"),
        ("A ciencia comprova o que vou te mostrar", "autoridade"),
        ("Analista de X revela...", "autoridade"),
        ("Os numeros nao mentem, olha isso...", "autoridade"),
        # Emocional
        ("Isso me fez chorar...", "emocional"),
        ("A historia mais bonita que voce vai ver hoje", "emocional"),
        ("Dedico esse video a quem ja quis desistir", "emocional"),
        ("Se voce esta passando por um momento dificil...", "emocional"),
        ("Isso vai restaurar sua fe na humanidade", "emocional"),
        ("Voce precisa ver a reacao dele/dela...", "emocional"),
        ("O que essa pessoa fez me deixou sem palavras", "emocional"),
        ("Se voce tem empatia, vai sentir isso...", "emocional"),
        ("A melhor surpresa que ja fiz...", "emocional"),
        ("Isso me lembrou que vale a pena...", "emocional"),
        # Hack/Dica
        ("Hack de R$0 que vale R$1.000", "hack"),
        ("3 truques que ninguem te ensina", "hack"),
        ("A dica mais simples que vai mudar seu jogo", "hack"),
        ("Pare de fazer X, faca Y", "hack"),
        ("O truque que eu uso todo dia e ninguem sabe", "hack"),
        ("Atalho que os pros usam e voce nao", "hack"),
        ("Economize 2 horas por dia com esse hack", "hack"),
        ("O app que mudou minha rotina completamente", "hack"),
        ("Faca isso ANTES de dormir e veja a diferenca", "hack"),
        ("1 mudanca simples, resultado gigante", "hack"),
        ("A tecnica dos 5 segundos funciona mesmo?", "hack"),
        ("Como fazer em 5 minutos o que levaria horas", "hack"),
        ("O metodo que triplicou meus resultados", "hack"),
        ("Funcionalidade escondida que ninguem usa", "hack"),
        ("A regra de ouro para nunca mais errar nisso", "hack"),
        # Polêmica
        ("Opiniao impopular: ...", "polemica"),
        ("Vou falar o que todo mundo pensa mas ninguem diz", "polemica"),
        ("Isso vai gerar polemica mas preciso falar...", "polemica"),
        ("Discordo de 99% dos especialistas sobre isso", "polemica"),
        ("A mentira que todo mundo acredita sobre...", "polemica"),
        ("Isso vai irritar muita gente mas e verdade", "polemica"),
        ("Unpopular opinion: ...", "polemica"),
        ("Hot take: ...", "polemica"),
        ("Vou receber hate por isso mas...", "polemica"),
        ("Se voce discorda, comenta por que...", "polemica"),
        # Transformacao
        ("De zero a R$10k em 90 dias, eis o que fiz...", "transformacao"),
        ("Como sai de X para Y em apenas Z dias", "transformacao"),
        ("Antes eu era X, hoje sou Y. Aqui esta o que mudou", "transformacao"),
        ("A decisao que mudou minha vida completamente", "transformacao"),
        ("30 dias atras eu comecei... olha agora", "transformacao"),
        ("Minha jornada de X ate Y em 1 minuto", "transformacao"),
        ("O dia que tudo mudou pra mim...", "transformacao"),
        ("De devendo R$50k a faturando R$100k", "transformacao"),
        ("A transformacao que ninguem esperava", "transformacao"),
        ("1 ano depois: o resultado", "transformacao"),
    ]

    count = 0
    for text, category in hooks:
        existing_hook = db.query(HookEntry).filter(HookEntry.text == text).first()
        if not existing_hook:
            db.add(HookEntry(text=text, category=category, source="seed"))
            count += 1

    db.commit()
    return {"status": "seeded", "new_hooks": count, "total": db.query(HookEntry).count()}


async def generate_hooks(topic: str, category: str = "curiosidade", count: int = 5) -> list[dict]:
    """Generate new hooks using AI for a specific topic."""
    from backend.services.local_ai import llm_chat

    prompt = f"""Gere {count} hooks (ganchos de abertura) para videos sobre "{topic}".
Categoria: {category}
Idioma: Portugues BR

Regras:
- Cada hook deve ter no maximo 15 palavras
- Deve gerar curiosidade imediata nos primeiros 3 segundos
- Use linguagem coloquial brasileira
- Numere cada hook

Gere {count} hooks:"""

    result = await llm_chat(prompt, system="Voce e um copywriter especializado em hooks virais para redes sociais.", max_tokens=500)

    hooks = []
    if result:
        for line in result.strip().split("\n"):
            line = line.strip()
            if line and (line[0].isdigit() or line.startswith("-")):
                text = re.sub(r'^[\d\.\)\-\s]+', '', line).strip().strip('"').strip("'")
                if text and len(text) > 5:
                    hooks.append({"text": text, "category": category, "topic": topic})

    return hooks[:count]


def search_hooks(db: Session, query: str = "", category: str = "", limit: int = 20) -> list[dict]:
    """Search hooks by keyword or category."""
    q = db.query(HookEntry)
    if category:
        q = q.filter(HookEntry.category == category)
    if query:
        q = q.filter(HookEntry.text.ilike(f"%{query}%"))
    return [h.to_dict() for h in q.order_by(HookEntry.rating.desc()).limit(limit).all()]


def get_hooks_by_category(db: Session) -> dict:
    """Get all hooks grouped by category."""
    hooks = db.query(HookEntry).order_by(HookEntry.rating.desc()).all()
    grouped = {}
    for h in hooks:
        cat = h.category or "geral"
        if cat not in grouped:
            grouped[cat] = []
        grouped[cat].append(h.to_dict())
    return {"categories": grouped, "total": len(hooks)}


def rate_hook(db: Session, hook_id: int, rating: float) -> dict:
    """Rate a hook (1-5 stars)."""
    hook = db.query(HookEntry).filter(HookEntry.id == hook_id).first()
    if not hook:
        return {"error": "Hook nao encontrado"}
    hook.rating = max(0, min(5, rating))
    hook.times_used += 1
    db.commit()
    return hook.to_dict()


# ─── CTA & Optimization (4 functions) ─────────────────────────


async def generate_cta(topic: str, goal: str = "seguir", platform: str = "tiktok") -> dict:
    """Generate CTAs using AI."""
    from backend.services.local_ai import llm_chat

    goals = {
        "seguir": "fazer o usuario seguir o perfil",
        "comentar": "gerar comentarios e debate",
        "compartilhar": "fazer o usuario compartilhar o video",
        "salvar": "fazer o usuario salvar o video",
        "link": "direcionar para link na bio/descricao",
        "comprar": "gerar venda de produto/servico",
    }

    prompt = f"""Gere 5 CTAs (chamadas para acao) para video sobre "{topic}".
Objetivo: {goals.get(goal, goal)}
Plataforma: {platform}

Cada CTA deve:
- Ser curto (max 10 palavras)
- Ser urgente e direto
- Usar linguagem brasileira casual
- Gerar acao imediata

Numere cada CTA:"""

    result = await llm_chat(prompt, system="Voce e um copywriter de CTAs virais.", max_tokens=400)

    ctas = []
    if result:
        for line in result.strip().split("\n"):
            line = line.strip()
            if line and (line[0].isdigit() or line.startswith("-")):
                text = re.sub(r'^[\d\.\)\-\s]+', '', line).strip().strip('"')
                if text and len(text) > 3:
                    ctas.append(text)

    return {"topic": topic, "goal": goal, "platform": platform, "ctas": ctas[:5]}


def analyze_readability(text: str) -> dict:
    """Analyze script readability for video narration."""
    if not text or not text.strip():
        return {"score": 0, "issues": ["Texto vazio"]}

    words = text.split()
    sentences = re.split(r'[.!?]+', text)
    sentences = [s.strip() for s in sentences if s.strip()]

    word_count = len(words)
    sentence_count = max(1, len(sentences))
    avg_words_per_sentence = round(word_count / sentence_count, 1)

    # Words per minute for narration
    wpm = 150  # average speaking speed
    duration_estimate = round(word_count / wpm * 60)

    issues = []
    score = 100

    # Check sentence length
    long_sentences = [s for s in sentences if len(s.split()) > 20]
    if long_sentences:
        score -= len(long_sentences) * 5
        issues.append(f"{len(long_sentences)} frases com mais de 20 palavras (quebre em frases menores)")

    # Check word complexity
    complex_words = [w for w in words if len(w) > 12]
    if len(complex_words) > word_count * 0.1:
        score -= 10
        issues.append("Muitas palavras complexas (use linguagem mais simples)")

    # Check paragraph breaks
    paragraphs = text.split("\n\n")
    if len(paragraphs) < 2 and word_count > 50:
        score -= 5
        issues.append("Adicione quebras de paragrafo para melhor ritmo")

    # Check for pattern interrupts
    if word_count > 100 and text.count("?") < 1:
        score -= 5
        issues.append("Adicione perguntas retoricas para manter atencao")

    if not issues:
        issues.append("Texto com boa legibilidade para narracao!")

    return {
        "score": max(0, min(100, score)),
        "word_count": word_count,
        "sentence_count": sentence_count,
        "avg_words_per_sentence": avg_words_per_sentence,
        "duration_estimate_seconds": duration_estimate,
        "issues": issues,
        "long_sentences": len(long_sentences),
    }


def flag_retention_risks(script_text: str) -> dict:
    """Flag parts of the script that risk losing viewer retention."""
    if not script_text:
        return {"risks": [], "score": 0}

    risks = []
    lines = script_text.strip().split("\n")
    lines = [l for l in lines if l.strip()]

    # Check hook (first line)
    if lines:
        first = lines[0].strip()
        if len(first) > 100:
            risks.append({"line": 1, "type": "hook_longo", "message": "Hook muito longo. Reduza para max 15 palavras.", "severity": "high"})
        if not any(c in first for c in ["?", "!", "..."]):
            risks.append({"line": 1, "type": "hook_fraco", "message": "Hook sem pontuacao emocional (?, !, ...). Adicione urgencia.", "severity": "medium"})

    # Check for long stretches without engagement
    words_since_break = 0
    for i, line in enumerate(lines):
        words = len(line.split())
        words_since_break += words
        if any(c in line for c in ["?", "!", "..."]):
            words_since_break = 0
        if words_since_break > 50:
            risks.append({"line": i + 1, "type": "monotono", "message": f"~{words_since_break} palavras sem pattern interrupt. Adicione pergunta ou pausa.", "severity": "medium"})
            words_since_break = 0

    # Check CTA
    if lines:
        last_lines = " ".join(lines[-2:]).lower()
        cta_words = ["siga", "segue", "comenta", "compartilha", "salva", "link", "inscreva", "curta", "like"]
        if not any(w in last_lines for w in cta_words):
            risks.append({"line": len(lines), "type": "sem_cta", "message": "Final sem CTA claro. Adicione uma chamada para acao.", "severity": "high"})

    # Overall retention score
    retention_score = 100 - (len([r for r in risks if r["severity"] == "high"]) * 15 + len([r for r in risks if r["severity"] == "medium"]) * 8)

    return {
        "risks": risks,
        "retention_score": max(0, min(100, retention_score)),
        "total_risks": len(risks),
        "high_risks": len([r for r in risks if r["severity"] == "high"]),
    }


def optimize_for_seo(title: str, description: str = "", platform: str = "tiktok") -> dict:
    """Optimize title and description for platform SEO."""
    suggestions = []

    # Title optimization
    if len(title) < 10:
        suggestions.append({"type": "titulo", "message": "Titulo muito curto. Adicione palavras-chave relevantes."})
    if len(title) > 100:
        suggestions.append({"type": "titulo", "message": "Titulo muito longo. Mantenha abaixo de 100 caracteres."})
    if not any(c in title for c in ["?", "!", ":"]):
        suggestions.append({"type": "titulo", "message": "Adicione pontuacao ao titulo para gerar curiosidade."})

    # Check for numbers (they increase CTR)
    if not any(c.isdigit() for c in title):
        suggestions.append({"type": "titulo", "message": "Numeros no titulo aumentam CTR (ex: '5 dicas', 'em 30 dias')."})

    # Description
    if description:
        hashtag_count = description.count("#")
        if platform == "tiktok" and hashtag_count > 8:
            suggestions.append({"type": "descricao", "message": "TikTok: use max 5-8 hashtags relevantes."})
        elif platform == "instagram" and hashtag_count < 5:
            suggestions.append({"type": "descricao", "message": "Instagram: use 15-30 hashtags para alcance."})

    if not suggestions:
        suggestions.append({"type": "geral", "message": "Otimizacao de SEO parece boa!"})

    return {"title": title, "platform": platform, "suggestions": suggestions, "title_length": len(title)}


# ─── TTS (2 functions) ────────────────────────────────────────


async def text_to_speech(text: str, voice: str = "pt-BR-AntonioNeural", output_path: str = "") -> dict:
    """Convert text to speech using edge-tts (free, Microsoft voices)."""
    try:
        import edge_tts
    except ImportError:
        return {"error": "edge-tts nao instalado. Execute: pip install edge-tts"}

    if not output_path:
        from backend.core.config import settings
        import time
        output_path = str(settings.data_path / f"tts_{int(time.time())}.mp3")

    try:
        communicate = edge_tts.Communicate(text, voice)
        await communicate.save(output_path)
        return {"path": output_path, "voice": voice, "text_length": len(text), "status": "success"}
    except Exception as e:
        return {"error": str(e), "voice": voice}


async def list_tts_voices(language: str = "pt") -> list[dict]:
    """List available TTS voices."""
    try:
        import edge_tts
        voices = await edge_tts.list_voices()
        filtered = [
            {"name": v["ShortName"], "gender": v["Gender"], "locale": v["Locale"]}
            for v in voices if v["Locale"].startswith(language)
        ]
        return filtered
    except ImportError:
        return [
            {"name": "pt-BR-AntonioNeural", "gender": "Male", "locale": "pt-BR"},
            {"name": "pt-BR-FranciscaNeural", "gender": "Female", "locale": "pt-BR"},
            {"name": "pt-BR-ThalitaNeural", "gender": "Female", "locale": "pt-BR"},
        ]
    except Exception:
        return []


# ─── CRUD for scripts ─────────────────────────────────────────


def save_script(db: Session, data: dict) -> dict:
    """Save a script to the database."""
    script = Script(
        title=data.get("title", "Sem titulo"),
        platform=data.get("platform", "tiktok"),
        style=data.get("style", "tutorial"),
        hook=data.get("hook", ""),
        body=data.get("body", ""),
        cta=data.get("cta", ""),
        full_script=data.get("full_script", ""),
        hashtags=data.get("hashtags", []),
        duration_estimate=data.get("duration_estimate", 30),
        readability_score=data.get("readability_score", 0),
        status=data.get("status", "draft"),
    )
    db.add(script)
    db.commit()
    db.refresh(script)
    return script.to_dict()


def list_scripts(db: Session, status: str = "", platform: str = "", limit: int = 50) -> list[dict]:
    """List saved scripts."""
    q = db.query(Script)
    if status:
        q = q.filter(Script.status == status)
    if platform:
        q = q.filter(Script.platform == platform)
    return [s.to_dict() for s in q.order_by(Script.created_at.desc()).limit(limit).all()]


def get_script(db: Session, script_id: int) -> dict | None:
    """Get a script by ID."""
    s = db.query(Script).filter(Script.id == script_id).first()
    return s.to_dict() if s else None


def update_script(db: Session, script_id: int, data: dict) -> dict | None:
    """Update a script."""
    s = db.query(Script).filter(Script.id == script_id).first()
    if not s:
        return None
    for key in ["title", "hook", "body", "cta", "full_script", "hashtags", "status", "platform", "style", "is_favorite"]:
        if key in data:
            setattr(s, key, data[key])
    s.updated_at = datetime.utcnow()
    db.commit()
    return s.to_dict()


def delete_script(db: Session, script_id: int) -> bool:
    """Delete a script."""
    s = db.query(Script).filter(Script.id == script_id).first()
    if not s:
        return False
    db.delete(s)
    db.commit()
    return True
