Update app.py

app.py

@@ -1,23 +1,20 @@
 """
 Video Clip Generator - Tudo integrado
-Transcrição + Cortes + Face Tracking + Cortes Virais
+Transcrição + Cortes + Face Tracking
 """
 
 import gradio as gr
 import cv2
 import numpy as np
+from moviepy.editor import VideoFileClip, concatenate_videoclips
 import whisper
 import subprocess
 from pathlib import Path
 from dataclasses import dataclass
-from typing import List, Tuple, Optional, Union
+from typing import List, Tuple, Optional
 import tempfile
 import os
 import shutil
-import json
-import random
-from difflib import SequenceMatcher
-import math
 
 # ======================= DATACLASSES =======================
 
@@ -42,49 +39,6 @@ class FaceBox:
     center_y: int
     confidence: float = 1.0
 
-# ======================= UTILS =======================
-
-def resolve_video_path(v: Union[str, dict, None]) -> Optional[str]:
-    """Gradio pode entregar str (caminho) ou dict. Normaliza para caminho local."""
-    if v is None:
-        return None
-    if isinstance(v, str):
-        return v
-    if isinstance(v, dict):
-        if "name" in v and isinstance(v["name"], str) and os.path.exists(v["name"]):
-            return v["name"]
-        if "path" in v and isinstance(v["path"], str) and os.path.exists(v["path"]):
-            return v["path"]
-        return v.get("name") or v.get("path")
-    return None
-
-def probe_duration(path: str) -> Optional[float]:
-    """Retorna a duração (s) via ffprobe."""
-    try:
-        cmd = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "json", path]
-        out = subprocess.run(cmd, check=True, capture_output=True)
-        data = json.loads(out.stdout.decode("utf-8", errors="ignore"))
-        dur = float(data.get("format", {}).get("duration", 0.0))
-        return dur if dur > 0 else None
-    except Exception as e:
-        print(f"[ffprobe] falhou: {e}")
-        return None
-
-def remux_video(src: str) -> str:
-    """Gera um MP4 remuxado (ajusta PTS/timebase e faststart)."""
-    fd, tmp_path = tempfile.mkstemp(suffix=".mp4")
-    os.close(fd)
-    cmd = [
-        "ffmpeg", "-y",
-        "-fflags", "+genpts",
-        "-i", src,
-        "-c", "copy",
-        "-movflags", "+faststart",
-        tmp_path
-    ]
-    subprocess.run(cmd, check=True, capture_output=True)
-    return tmp_path
-
 # ======================= FACE TRACKING =======================
 
 class FaceTracker:
@@ -107,9 +61,9 @@ class FaceTracker:
         
         self.enabled = self.face_cascade is not None and not self.face_cascade.empty()
         if self.enabled:
-            print("Detector de rostos carregado")
+            print("✅ Detector de rostos carregado")
         else:
-            print("Detector de rostos não disponível - usando crop centralizado")
+            print("⚠️ Detector de rostos não disponível - usando crop centralizado")
     
     def detect_faces(self, frame: np.ndarray) -> List[FaceBox]:
         if not self.enabled:
@@ -188,147 +142,69 @@ class FaceTracker:
         
         return (crop_x, crop_y, crop_w, crop_h)
 
-# ======================= TRANSCRIÇÃO (ROBUSTA) =======================
-
-def extract_audio_wav_strong(input_video: str, sr: int = 16000) -> str:
-    """
-    Extração de áudio à prova de VFR/PTS ruins.
-    1) Remuxa o vídeo (ajusta timebase)
-    2) Extrai WAV mono 16k
-    3) Se o WAV vier curto, faz fallback re-decodificando o original
-    """
-    vid_dur = probe_duration(input_video)
-    print(f"[probe] video: {vid_dur:.2f}s" if vid_dur else "[probe] video: ?")
-
-    remux = remux_video(input_video)
-    print(f"[remux] -> {remux}")
-
-    fd, wav_path = tempfile.mkstemp(suffix=".wav")
-    os.close(fd)
-
-    # Tentativa 1 — do remux, convertendo para PCM
-    cmd1 = [
-        "ffmpeg", "-y",
-        "-i", remux,
-        "-vn",
-        "-map", "0:a:0?",
-        "-ac", "1", "-ar", str(sr),
-        "-c:a", "pcm_s16le",
-        wav_path
-    ]
-    subprocess.run(cmd1, check=True, capture_output=True)
-    wav_dur = probe_duration(wav_path)
-    print(f"[probe] wav #1: {wav_dur:.2f}s" if wav_dur else "[probe] wav #1: ?")
-
-    # Fallback — redecodifica direto do original
-    if vid_dur and (not wav_dur or wav_dur + 2 < vid_dur):
-        print("[fallback] re-decodificando o arquivo original…")
-        fd2, wav2 = tempfile.mkstemp(suffix=".wav")
-        os.close(fd2)
-        cmd2 = [
-            "ffmpeg", "-y",
-            "-fflags", "+genpts",
-            "-i", input_video,
-            "-vn",
-            "-ac", "1", "-ar", str(sr),
-            "-c:a", "pcm_s16le",
-            wav2
-        ]
-        subprocess.run(cmd2, check=True, capture_output=True)
-        wav2_dur = probe_duration(wav2)
-        print(f"[probe] wav #2: {wav2_dur:.2f}s" if wav2_dur else "[probe] wav #2: ?")
-        if wav2_dur and (not wav_dur or wav2_dur > wav_dur):
-            try:
-                Path(wav_path).unlink(missing_ok=True)
-                Path(remux).unlink(missing_ok=True)
-            except Exception:
-                pass
-            return wav2
-
-    try:
-        Path(remux).unlink(missing_ok=True)
-    except Exception:
-        pass
-    return wav_path
+# ======================= TRANSCRIÇÃO =======================
 
 def transcribe(video_file: str, model_size: str = "small") -> List[Segment]:
-    print(f"[whisper] modelo: {model_size}")
+    print(f"🎙️ Carregando modelo Whisper: {model_size}")
     model = whisper.load_model(model_size)
-
-    print("[audio] extraindo WAV robusto…")
-    audio_wav = extract_audio_wav_strong(video_file, sr=16000)
-
-    vid_dur = probe_duration(video_file)
-    wav_dur = probe_duration(audio_wav)
-    if vid_dur:  print(f"[dur] vídeo: {vid_dur:.2f}s")
-    if wav_dur:  print(f"[dur] wav:   {wav_dur:.2f}s")
-
-    print("[whisper] transcrevendo…")
-    result = model.transcribe(
-        audio_wav,
-        language="pt",
-        verbose=False,
-        task="transcribe",
-        temperature=0,
-        condition_on_previous_text=False,
-        fp16=False
-    )
-
-    segments = [Segment(start=s["start"], end=s["end"], text=s["text"].strip())
-                for s in result.get("segments", [])]
-    print(f"[whisper] segmentos: {len(segments)}")
-
-    try:
-        Path(audio_wav).unlink(missing_ok=True)
-    except Exception:
-        pass
+    
+    print(f"🎬 Transcrevendo: {video_file}")
+    result = model.transcribe(video_file, language="pt", verbose=False)
+    
+    segments = []
+    for seg in result["segments"]:
+        segments.append(Segment(
+            start=seg["start"],
+            end=seg["end"],
+            text=seg["text"].strip()
+        ))
+    
+    print(f"✅ Transcrição completa: {len(segments)} segmentos")
     return segments
 
 # ======================= PROCESSAMENTO DE VÍDEO =======================
 
 def extract_video_segment(input_video: str, output_video: str, start_time: float, end_time: float) -> bool:
-    duration = max(0.0, end_time - start_time)
-    if duration <= 0:
-        print(f"[extract] duração inválida: {duration}")
-        return False
+    duration = end_time - start_time
     cmd = [
         "ffmpeg", "-y", "-ss", str(start_time), "-i", input_video,
-        "-t", str(duration),
-        "-c:v", "libx264",
-        "-c:a", "aac",
-        "-movflags", "+faststart",
-        output_video
+        "-t", str(duration), "-c:v", "libx264", "-c:a", "aac",
+        "-strict", "experimental", output_video
     ]
+    
     try:
         subprocess.run(cmd, check=True, capture_output=True)
         return True
     except subprocess.CalledProcessError as e:
-        print(f"[extract] erro: {e}")
+        print(f"❌ Erro ao extrair: {e}")
         return False
 
 def apply_smart_crop_to_video(input_path: str, output_path: str, target_width: int, 
                               target_height: int, sample_frames: int = 10) -> bool:
-    """Calcula o melhor crop com rastreamento facial e aplica com FFmpeg preservando áudio."""
     tracker = FaceTracker()
     cap = cv2.VideoCapture(input_path)
+    
     if not cap.isOpened():
-        print(f"[crop] erro ao abrir: {input_path}")
+        print(f"❌ Erro ao abrir: {input_path}")
         return False
     
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
     frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     frame_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     frame_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     
+    # Amostragem para suavização
     sample_positions = []
-    frame_indices = np.linspace(0, frame_count - 1, min(sample_frames, max(1, frame_count)), dtype=int)
+    frame_indices = np.linspace(0, frame_count - 1, min(sample_frames, frame_count), dtype=int)
+    
     for idx in frame_indices:
         cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
         ret, frame = cap.read()
         if ret:
             crop_coords = tracker.calculate_smart_crop(frame, target_width, target_height)
             sample_positions.append(crop_coords)
-    cap.release()
     
+    # Posição média (suavizada)
     if sample_positions:
         avg_x = int(np.median([p[0] for p in sample_positions]))
         avg_y = int(np.median([p[1] for p in sample_positions]))
@@ -336,6 +212,7 @@ def apply_smart_crop_to_video(input_path: str, output_path: str, target_width: i
         crop_h = sample_positions[0][3]
         final_crop = (avg_x, avg_y, crop_w, crop_h)
     else:
+        # Fallback
         target_ar = target_width / target_height
         frame_ar = frame_w / frame_h
         if target_ar < frame_ar:
@@ -347,25 +224,39 @@ def apply_smart_crop_to_video(input_path: str, output_path: str, target_width: i
             crop_h = int(frame_w / target_ar)
             final_crop = (0, (frame_h - crop_h) // 2, crop_w, crop_h)
     
-    x, y, w, h = final_crop
-    print(f"[crop] final: x={x}, y={y}, w={w}, h={h} -> {target_width}x{target_height}")
+    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
     
-    vf = f"crop={w}:{h}:{x}:{y},scale={target_width}:{target_height}:flags=lanczos"
-    cmd = [
-        "ffmpeg", "-y", "-i", input_path,
-        "-vf", vf,
-        "-c:v", "libx264", "-preset", "veryfast", "-crf", "18",
-        "-c:a", "copy",
-        "-movflags", "+faststart",
-        output_path
-    ]
-    try:
-        subprocess.run(cmd, check=True, capture_output=True)
-        print(f"[crop] concluído: {output_path}")
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"[crop] erro ffmpeg: {e}")
+    # Writer
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (target_width, target_height))
+    
+    if not out.isOpened():
+        print(f"❌ Erro ao criar saída: {output_path}")
+        cap.release()
         return False
+    
+    print(f"🎬 Processando com crop: {final_crop}")
+    frame_num = 0
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        x, y, w, h = final_crop
+        cropped = frame[y:y+h, x:x+w]
+        resized = cv2.resize(cropped, (target_width, target_height), interpolation=cv2.INTER_LANCZOS4)
+        out.write(resized)
+        frame_num += 1
+        
+        if frame_num % 30 == 0:
+            progress = (frame_num / frame_count) * 100
+            print(f"  {progress:.1f}% ({frame_num}/{frame_count})")
+    
+    cap.release()
+    out.release()
+    print(f"✅ Concluído: {output_path}")
+    return True
 
 def apply_aspect_ratio(input_video: str, output_video: str, ar_mode: str, face_tracking: bool = False) -> bool:
     if ar_mode == "Original":
@@ -377,20 +268,20 @@ def apply_aspect_ratio(input_video: str, output_video: str, ar_mode: str, face_t
         "Quadrado 1:1": (1080, 1080),
         "Retrato 4:5": (1080, 1350),
     }
+    
     if ar_mode not in ar_dims:
         return False
     
     width, height = ar_dims[ar_mode]
+    
     if face_tracking:
         return apply_smart_crop_to_video(input_video, output_video, width, height)
     else:
+        # Crop centralizado tradicional
         cmd = [
             "ffmpeg", "-y", "-i", input_video,
             "-vf", f"scale={width}:{height}:force_original_aspect_ratio=increase,crop={width}:{height}",
-            "-c:v", "libx264", "-preset", "veryfast", "-crf", "18",
-            "-c:a", "copy",
-            "-movflags", "+faststart",
-            output_video
+            "-c:a", "copy", output_video
         ]
         try:
             subprocess.run(cmd, check=True, capture_output=True)
@@ -408,67 +299,362 @@ def concatenate_videos(video_files: List[str], output_file: str) -> bool:
             f.write(f"file '{os.path.abspath(vf)}'\n")
     
     try:
-        cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", "-movflags", "+faststart", output_file]
+        cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", output_file]
         subprocess.run(cmd, check=True, capture_output=True)
         return True
     except subprocess.CalledProcessError:
-        try:
-            cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file,
-                   "-c:v", "libx264", "-preset", "veryfast", "-crf", "18",
-                   "-c:a", "aac", "-movflags", "+faststart", output_file]
-            subprocess.run(cmd, check=True, capture_output=True)
-            return True
-        except subprocess.CalledProcessError:
-            return False
+        return False
     finally:
         Path(list_file).unlink(missing_ok=True)
 
-# ======================= HEURÍSTICAS VIRAL =======================
-
-IMPACT_WORDS = [
-    "problema", "não dá", "imaginar", "decisão", "escolha",
-    "compromisso", "vocês", "precisa", "eu tenho", "é o começo",
-    "querem que tudo mude", "caminho", "rede neural", "resultado", "responsável"
-]
-
-def emotional_score(text: str) -> float:
-    t = text.lower()
-    hits = sum(1 for w in IMPACT_WORDS if w in t)
-    # bonus por perguntas/provocações
-    bonus = 0.5 if "?" in t else 0.0
-    # normaliza 0..1
-    return min(1.0, (hits / max(1, len(IMPACT_WORDS))) * 4 + bonus)
-
-def semantic_continuity(a: str, b: str) -> float:
-    a_words = a.lower().split()[-12:]
-    b_words = b.lower().split()[:12]
-    seq = SequenceMatcher(None, " ".join(a_words), " ".join(b_words))
-    return seq.ratio()
-
-def iou(a: Tuple[float,float], b: Tuple[float,float]) -> float:
-    s1, e1 = a
-    s2, e2 = b
-    inter = max(0.0, min(e1, e2) - max(s1, s2))
-    union = (e1 - s1) + (e2 - s2) - inter
-    return 0.0 if union <= 0 else inter / union
+# ======================= LEGENDAS CRIATIVAS =======================
+
+def highlight_keywords(text: str) -> List[Tuple[str, bool]]:
+    """
+    Identifica palavras-chave para destaque.
+    Retorna lista de (palavra, is_highlighted)
+    """
+    keywords = [
+        # Ação/Imperativo
+        "tem que", "precisa", "deve", "faça", "veja", "olha", "escuta",
+        # Negação/Contraste
+        "não", "nunca", "jamais", "mas", "porém", "entretanto",
+        # Impacto
+        "problema", "solução", "segredo", "verdade", "realidade",
+        # Números
+        "milhão", "mil", "bilhão", "100%", "zero",
+        # Emoção
+        "incrível", "impossível", "fácil", "difícil", "importante",
+        # Ação mental
+        "imagina", "pensa", "considera", "decide", "escolhe"
+    ]
+    
+    words = text.split()
+    result = []
+    
+    for word in words:
+        word_lower = word.lower().strip(".,!?")
+        is_key = any(k in word_lower for k in keywords)
+        result.append((word, is_key))
+    
+    return result
+
+def create_subtitle_clip(text: str, start: float, end: float, 
+                        video_width: int, video_height: int,
+                        style: str = "hormozi") -> str:
+    """
+    Cria arquivo ASS (Advanced SubStation Alpha) com legendas estilizadas.
+    Retorna caminho do arquivo .ass
+    """
+    
+    if style == "hormozi":
+        # Estilo Alex Hormozi
+        style_def = """[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Montserrat,72,&H00FFFF,&H00FFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,2,2,10,10,80,1
+Style: Highlight,Montserrat,78,&H0000FFFF,&H0000FFFF,&H00000000,&H80000000,-1,0,0,0,110,110,0,0,1,4,3,2,10,10,80,1"""
+    
+    # Processa texto com highlights
+    words_with_highlight = highlight_keywords(text)
+    
+    # Divide em linhas (max 40 caracteres por linha)
+    lines = []
+    current_line = []
+    current_length = 0
+    
+    for word, is_highlight in words_with_highlight:
+        word_len = len(word) + 1
+        if current_length + word_len > 40 and current_line:
+            lines.append(current_line)
+            current_line = [(word, is_highlight)]
+            current_length = word_len
+        else:
+            current_line.append((word, is_highlight))
+            current_length += word_len
+    
+    if current_line:
+        lines.append(current_line)
+    
+    # Limita a 2 linhas
+    if len(lines) > 2:
+        lines = lines[:2]
+    
+    # Gera texto formatado
+    formatted_lines = []
+    for line in lines:
+        line_text = []
+        for word, is_highlight in line:
+            if is_highlight:
+                # Destaque: maior, amarelo vibrante, caps
+                line_text.append(f"{{\\1c&H00FFFF&\\fs78\\b1}}{word.upper()}{{\\r}}")
+            else:
+                line_text.append(word)
+        formatted_lines.append(" ".join(line_text))
+    
+    final_text = "\\N".join(formatted_lines)  # \N = quebra de linha no ASS
+    
+    # Cria arquivo ASS
+    fd, ass_path = tempfile.mkstemp(suffix=".ass")
+    
+    with os.fdopen(fd, 'w', encoding='utf-8') as f:
+        f.write("""[Script Info]
+Title: Viral Subtitles
+ScriptType: v4.00+
+WrapStyle: 0
+PlayResX: """ + str(video_width) + """
+PlayResY: """ + str(video_height) + """
+ScaledBorderAndShadow: yes
+
+""")
+        f.write(style_def + "\n\n")
+        f.write("""[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+""")
+        
+        # Converte tempo para formato ASS (0:00:00.00)
+        def format_time(seconds):
+            h = int(seconds // 3600)
+            m = int((seconds % 3600) // 60)
+            s = seconds % 60
+            return f"{h}:{m:02d}:{s:05.2f}"
+        
+        start_time = format_time(start)
+        end_time = format_time(end)
+        
+        f.write(f"Dialogue: 0,{start_time},{end_time},Default,,0,0,0,,{final_text}\n")
+    
+    return ass_path
+
+def add_subtitles_to_video(input_video: str, output_video: str, 
+                           segments: List[Segment], style: str = "hormozi") -> bool:
+    """
+    Adiciona legendas estilizadas ao vídeo usando FFmpeg + ASS.
+    """
+    
+    # Pega dimensões do vídeo
+    cap = cv2.VideoCapture(input_video)
+    video_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    video_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    cap.release()
+    
+    # Cria arquivo ASS completo com todos os segmentos
+    fd, ass_path = tempfile.mkstemp(suffix=".ass")
+    
+    with os.fdopen(fd, 'w', encoding='utf-8') as f:
+        # Header
+        f.write(f"""[Script Info]
+Title: Viral Subtitles
+ScriptType: v4.00+
+WrapStyle: 0
+PlayResX: {video_width}
+PlayResY: {video_height}
+ScaledBorderAndShadow: yes
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Montserrat,68,&H00FFFF00,&H00FFFF00,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,2,2,10,10,60,1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+""")
+        
+        # Adiciona cada segmento
+        for seg in segments:
+            words_with_highlight = highlight_keywords(seg.text)
+            
+            # Formata texto
+            formatted_words = []
+            for word, is_highlight in words_with_highlight:
+                if is_highlight:
+                    formatted_words.append(f"{{\\1c&H0000FFFF&\\fs76\\b1}}{word.upper()}{{\\r}}")
+                else:
+                    formatted_words.append(word)
+            
+            text = " ".join(formatted_words)
+            
+            # Quebra em linhas (max 40 chars)
+            words = text.split()
+            lines = []
+            current = []
+            length = 0
+            
+            for w in words:
+                w_len = len(w.replace("{\\1c&H0000FFFF&\\fs76\\b1}", "").replace("{\\r}", "")) + 1
+                if length + w_len > 40 and current:
+                    lines.append(" ".join(current))
+                    current = [w]
+                    length = w_len
+                else:
+                    current.append(w)
+                    length += w_len
+            
+            if current:
+                lines.append(" ".join(current))
+            
+            final_text = "\\N".join(lines[:2])  # Max 2 linhas
+            
+            # Formato de tempo ASS
+            def fmt_time(s):
+                h = int(s // 3600)
+                m = int((s % 3600) // 60)
+                sec = s % 60
+                return f"{h}:{m:02d}:{sec:05.2f}"
+            
+            start_str = fmt_time(seg.start)
+            end_str = fmt_time(seg.end)
+            
+            f.write(f"Dialogue: 0,{start_str},{end_str},Default,,0,0,0,,{final_text}\n")
+    
+    # Aplica legendas com FFmpeg
+    print(f"[legendas] Aplicando estilo {style}...")
+    
+    # Escape do caminho para FFmpeg (Windows/Linux)
+    ass_path_escaped = ass_path.replace('\\', '/').replace(':', '\\:')
+    
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", input_video,
+        "-vf", f"ass={ass_path_escaped}",
+        "-c:v", "libx264",
+        "-preset", "medium",
+        "-crf", "18",
+        "-c:a", "copy",
+        "-movflags", "+faststart",
+        output_video
+    ]
+    
+    try:
+        subprocess.run(cmd, check=True, capture_output=True)
+        print(f"[legendas] ✅ Concluído: {output_video}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"[legendas] ❌ Erro: {e}")
+        return False
+    finally:
+        try:
+            Path(ass_path).unlink(missing_ok=True)
+        except:
+            pass
+
+def score_segment_virality(seg: Segment, idx: int, total: int) -> float:
+    """
+    Pontua um segmento baseado em potencial viral.
+    Inspirado nos padrões do OpsClip.
+    """
+    score = 0.0
+    text = seg.text.lower()
+    
+    # GANCHOS (perguntas, provocações)
+    if any(w in text for w in ["?", "por que", "qual", "como", "você"]):
+        score += 15
+    
+    # FRASES DE IMPACTO
+    impact_phrases = [
+        "não dá", "problema", "esse é o", "imaginou", "é só",
+        "mas", "porém", "entretanto", "então", "olha",
+        "escuta", "presta atenção", "isso", "agora"
+    ]
+    for phrase in impact_phrases:
+        if phrase in text:
+            score += 8
+    
+    # NEGAÇÕES E CONTRASTES (criam tensão)
+    if any(w in text for w in ["não", "nunca", "jamais", "sem"]):
+        score += 5
+    
+    # AÇÃO/IMPERATIVO (engajamento)
+    if any(w in text for w in ["tem que", "precisa", "deve", "faça", "veja"]):
+        score += 7
+    
+    # NÚMEROS E DADOS (autoridade)
+    if any(c.isdigit() for c in text):
+        score += 6
+    
+    # DURAÇÃO IDEAL (15-45s = viral)
+    duration = seg.end - seg.start
+    if 15 <= duration <= 45:
+        score += 20
+    elif 10 <= duration <= 60:
+        score += 10
+    
+    # POSIÇÃO NO VÍDEO (meio tem mais contexto)
+    position_ratio = idx / max(1, total)
+    if 0.2 <= position_ratio <= 0.8:  # Evita extremos
+        score += 10
+    
+    # COMPLETUDE (evita frases cortadas)
+    if text.strip().endswith((".", "!", "?", "né", "tá")):
+        score += 8
+    
+    return score
+
+def find_viral_moments(segments: List[Segment], k: int = 5) -> List[Tuple[int, int, float]]:
+    """
+    Encontra os k melhores momentos virais.
+    Retorna lista de (start_idx, end_idx, score)
+    """
+    viral_windows = []
+    
+    # Janelas deslizantes de diferentes tamanhos
+    window_sizes = [1, 2, 3, 4, 5]  # Quantos segmentos consecutivos
+    
+    for window_size in window_sizes:
+        for i in range(len(segments) - window_size + 1):
+            window_segments = segments[i:i+window_size]
+            
+            # Calcula duração total da janela
+            total_duration = window_segments[-1].end - window_segments[0].start
+            
+            # Pula janelas muito longas ou curtas
+            if total_duration < 10 or total_duration > 60:
+                continue
+            
+            # Pontuação agregada da janela
+            window_score = sum(score_segment_virality(seg, i+j, len(segments)) 
+                             for j, seg in enumerate(window_segments))
+            
+            # Bonus para janelas com narrativa completa
+            combined_text = " ".join(s.text for s in window_segments)
+            if "?" in combined_text and any(w in combined_text.lower() for w in ["porque", "então", "mas", "porém"]):
+                window_score += 15  # Pergunta + resposta = narrativa completa
+            
+            viral_windows.append((i, i+window_size-1, window_score, total_duration))
+    
+    # Ordena por score e remove sobreposições
+    viral_windows.sort(key=lambda x: x[2], reverse=True)
+    
+    selected = []
+    used_indices = set()
+    
+    for start_idx, end_idx, score, duration in viral_windows:
+        # Verifica se não sobrepõe com já selecionados
+        if not any(idx in used_indices for idx in range(start_idx, end_idx + 1)):
+            selected.append((start_idx, end_idx, score))
+            used_indices.update(range(start_idx, end_idx + 1))
+            
+            if len(selected) >= k:
+                break
+    
+    return selected
 
 # ======================= GERAÇÃO DE CORTES =======================
 
 def generate_linear_cuts(video_file: str, segments: List[Segment], output_dir: str,
                         min_len: float = 600, max_len: float = 900, ideal_len: float = 900,
                         k: int = 2, gap_threshold: float = 0.60, pad: float = 0.08,
-                        ar_mode: str = "Original", face_tracking: bool = False) -> List[str]:
+                        ar_mode: str = "Original", face_tracking: bool = False,
+                        add_subtitles: bool = False) -> List[str]:
     if not segments:
         return []
     
     Path(output_dir).mkdir(parents=True, exist_ok=True)
     total_duration = segments[-1].end - segments[0].start
-    target_duration = min(max_len, max(min_len, total_duration / max(1, int(k))))
+    target_duration = min(max_len, max(min_len, total_duration / k))
     
     outputs = []
     current_start = segments[0].start
     
-    for i in range(int(k)):
+    for i in range(k):
         target_end = current_start + target_duration
         best_end = target_end
         
@@ -486,16 +672,15 @@ def generate_linear_cuts(video_file: str, segments: List[Segment], output_dir: s
         temp_file = Path(output_dir) / f"temp_linear_{i+1}.mp4"
         final_file = Path(output_dir) / f"cut_linear_{i+1}.mp4"
         
-        print(f"[linear] corte {i+1}/{k}: {start_with_pad:.1f}s - {end_with_pad:.1f}s")
+        print(f"✂️ Corte {i+1}/{k}: {start_with_pad:.1f}s - {end_with_pad:.1f}s")
         
-        src_path = resolve_video_path(video_file) or video_file
-        if extract_video_segment(src_path, str(temp_file), start_with_pad, end_with_pad):
+        if extract_video_segment(video_file, str(temp_file), start_with_pad, end_with_pad):
             if ar_mode != "Original":
                 if apply_aspect_ratio(str(temp_file), str(final_file), ar_mode, face_tracking):
-                    Path(temp_file).unlink(missing_ok=True)
+                    temp_file.unlink()
                     outputs.append(str(final_file))
             else:
-                Path(temp_file).rename(final_file)
+                temp_file.rename(final_file)
                 outputs.append(str(final_file))
         
         current_start = best_end + gap_threshold
@@ -508,14 +693,16 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
                           min_len: float = 600, max_len: float = 900, ideal_len: float = 900,
                           min_blocks: int = 3, max_blocks: int = 8, k: int = 2,
                           gap_threshold: float = 0.60, pad: float = 0.08,
-                          ar_mode: str = "Original", face_tracking: bool = False) -> List[str]:
+                          ar_mode: str = "Original", face_tracking: bool = False,
+                          add_subtitles: bool = False) -> List[str]:
     if not segments or len(segments) < min_blocks:
         return []
     
     Path(output_dir).mkdir(parents=True, exist_ok=True)
     outputs = []
     
-    for i in range(int(k)):
+    import random
+    for i in range(k):
         num_blocks = random.randint(min_blocks, min(max_blocks, len(segments)))
         step = max(1, len(segments) // num_blocks)
         selected_indices = [j * step for j in range(num_blocks)]
@@ -526,8 +713,8 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
             block_file = Path(output_dir) / f"temp_creative_{i+1}_block_{j+1}.mp4"
             start = max(0, seg.start - pad)
             end = seg.end + pad
-            src_path = resolve_video_path(video_file) or video_file
-            if extract_video_segment(src_path, str(block_file), start, end):
+            
+            if extract_video_segment(video_file, str(block_file), start, end):
                 block_files.append(str(block_file))
         
         if not block_files:
@@ -539,10 +726,10 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
             
             if ar_mode != "Original":
                 if apply_aspect_ratio(str(concat_file), str(final_file), ar_mode, face_tracking):
-                    Path(concat_file).unlink(missing_ok=True)
+                    concat_file.unlink()
                     outputs.append(str(final_file))
             else:
-                Path(concat_file).rename(final_file)
+                concat_file.rename(final_file)
                 outputs.append(str(final_file))
             
             for bf in block_files:
@@ -550,123 +737,15 @@ def generate_creative_cuts(video_file: str, segments: List[Segment], output_dir:
     
     return outputs
 
-# ======== NOVO: GERAÇÃO DE CORTES VIRAIS (semântica + emoção) ========
-
-def merge_adjacent_semantic(segments: List[Segment],
-                            cont_thresh: float = 0.35,
-                            max_gap: float = 2.0) -> List[Segment]:
-    """Une segmentos adjacentes que mantêm continuidade semântica."""
-    if not segments:
-        return []
-    merged: List[Segment] = []
-    i = 0
-    while i < len(segments):
-        cur = segments[i]
-        j = i + 1
-        while j < len(segments):
-            nxt = segments[j]
-            if (nxt.start - cur.end) > max_gap:
-                break
-            cont = semantic_continuity(cur.text, nxt.text)
-            if cont >= cont_thresh:
-                cur = Segment(cur.start, nxt.end, f"{cur.text} {nxt.text}")
-                j += 1
-            else:
-                break
-        merged.append(cur)
-        i = j
-    return merged
-
-def build_candidates(segments: List[Segment],
-                     min_len: float = 20.0,
-                     max_len: float = 60.0,
-                     ideal: float = 40.0) -> List[Tuple[Tuple[float,float], float, str]]:
-    """
-    Gera janelas [start,end] com score:
-    0.6 emoção + 0.3 continuidade média + 0.1 proximidade ao ideal.
-    """
-    cands = []
-    n = len(segments)
-    for i in range(n):
-        start = segments[i].start
-        text_acc = segments[i].text
-        cont_sum = 0.0
-        words = segments[i].text.split()
-        j = i
-        while j+1 < n:
-            j += 1
-            text_acc += " " + segments[j].text
-            cont_sum += semantic_continuity(segments[j-1].text, segments[j].text)
-            dur = segments[j].end - start
-            if dur < min_len:
-                continue
-            if dur > max_len:
-                break
-            emo = emotional_score(text_acc)
-            cont_avg = cont_sum / max(1, (j - i))
-            ideal_penalty = 1.0 - min(1.0, abs(dur - ideal) / ideal)  # 1 se ideal, 0 se muito longe
-            score = 0.6*emo + 0.3*cont_avg + 0.1*ideal_penalty
-            cands.append(((start, segments[j].end), score, text_acc))
-    # também considerar single-merge como candidato
-    for s in segments:
-        dur = s.end - s.start
-        if min_len <= dur <= max_len:
-            score = 0.6*emotional_score(s.text) + 0.3*0.5 + 0.1*(1 - abs(dur-40.0)/40.0)
-            cands.append(((s.start, s.end), score, s.text))
-    # ordenar por score desc
-    cands.sort(key=lambda x: x[1], reverse=True)
-    return cands
-
-def pick_top_non_overlapping(cands: List[Tuple[Tuple[float,float], float, str]],
-                             k: int = 3, iou_thresh: float = 0.15) -> List[Tuple[float,float,str]]:
-    picks: List[Tuple[float,float,str]] = []
-    for (win, score, text) in cands:
-        if len(picks) >= k:
-            break
-        if all(iou(win, (p[0], p[1])) < iou_thresh for p in picks):
-            picks.append((win[0], win[1], text))
-    return picks
-
-def generate_viral_cuts(video_file: str, segments: List[Segment], output_dir: str,
-                        k: int = 3, pad: float = 0.05,
-                        min_len: float = 20.0, max_len: float = 60.0, ideal: float = 40.0,
-                        ar_mode: str = "Original", face_tracking: bool = False) -> List[str]:
-    if not segments:
-        return []
-    Path(output_dir).mkdir(parents=True, exist_ok=True)
-
-    merged = merge_adjacent_semantic(segments, cont_thresh=0.35, max_gap=2.0)
-    cands = build_candidates(merged, min_len=min_len, max_len=max_len, ideal=ideal)
-    chosen = pick_top_non_overlapping(cands, k=k, iou_thresh=0.15)
-
-    outputs = []
-    for idx, (s, e, _txt) in enumerate(chosen, start=1):
-        start = max(0, s - pad)
-        end = e + pad
-        temp_file = Path(output_dir) / f"temp_viral_{idx}.mp4"
-        final_file = Path(output_dir) / f"cut_viral_{idx}.mp4"
-        print(f"[viral] corte {idx}/{len(chosen)}: {start:.1f}s - {end:.1f}s")
-        src_path = resolve_video_path(video_file) or video_file
-        if extract_video_segment(src_path, str(temp_file), start, end):
-            if ar_mode != "Original":
-                if apply_aspect_ratio(str(temp_file), str(final_file), ar_mode, face_tracking):
-                    Path(temp_file).unlink(missing_ok=True)
-                    outputs.append(str(final_file))
-            else:
-                Path(temp_file).rename(final_file)
-                outputs.append(str(final_file))
-    return outputs
-
 # ======================= INTERFACE GRADIO =======================
 
 SPACE_OUT = Path("outputs")
 SPACE_OUT.mkdir(exist_ok=True, parents=True)
 
 def do_transcribe(video_file, model_size):
-    true_path = resolve_video_path(video_file)
-    if not true_path or not os.path.exists(true_path):
-        return [], "Selecione um vídeo válido."
-    segs = transcribe(true_path, model_size=model_size)
+    if video_file is None:
+        return [], "Selecione um vídeo."
+    segs = transcribe(video_file, model_size=model_size)
     preview = "\n".join([f"[{s.start:.1f}–{s.end:.1f}] {s.text}" for s in segs[:12]])
     return segs, f"Transcrição ok. Segmentos: {len(segs)}\n\nPrévia:\n{preview}"
 
@@ -674,31 +753,19 @@ def run_linear(segs, video_file, out_subdir, min_len, max_len, ideal_len, k, gap
     if not segs:
         return [], "Transcreva antes de cortar."
     workdir = SPACE_OUT / (out_subdir or "cortes")
-    outs = generate_linear_cuts(video_file, segs, str(workdir),
-                                min_len=float(min_len), max_len=float(max_len), ideal_len=float(ideal_len),
-                                k=int(k), gap_threshold=float(gap), pad=float(pad),
-                                ar_mode=str(ar_mode), face_tracking=bool(face_tracking))
+    outs = generate_linear_cuts(video_file, segs, str(workdir), min_len=min_len, max_len=max_len,
+                                ideal_len=ideal_len, k=k, gap_threshold=gap, pad=pad,
+                                ar_mode=ar_mode, face_tracking=face_tracking)
     return [str(Path(p)) for p in outs], f"Gerados: {len(outs)} arquivo(s)."
 
 def run_creative(segs, video_file, out_subdir, min_len, max_len, ideal_len, minb, maxb, k, gap, pad, ar_mode, face_tracking):
     if not segs:
         return [], "Transcreva antes de cortar."
     workdir = SPACE_OUT / (out_subdir or "cortes")
-    outs = generate_creative_cuts(video_file, segs, str(workdir),
-                                  min_len=float(min_len), max_len=float(max_len), ideal_len=float(ideal_len),
-                                  min_blocks=int(minb), max_blocks=int(maxb), k=int(k),
-                                  gap_threshold=float(gap), pad=float(pad),
-                                  ar_mode=str(ar_mode), face_tracking=bool(face_tracking))
-    return [str(Path(p)) for p in outs], f"Gerados: {len(outs)} arquivo(s)."
-
-def run_viral(segs, video_file, out_subdir, k, pad, min_len, max_len, ideal_len, ar_mode, face_tracking):
-    if not segs:
-        return [], "Transcreva antes de cortar."
-    workdir = SPACE_OUT / (out_subdir or "cortes")
-    outs = generate_viral_cuts(video_file, segs, str(workdir),
-                               k=int(k), pad=float(pad),
-                               min_len=float(min_len), max_len=float(max_len), ideal=float(ideal_len),
-                               ar_mode=str(ar_mode), face_tracking=bool(face_tracking))
+    outs = generate_creative_cuts(video_file, segs, str(workdir), min_len=min_len, max_len=max_len,
+                                  ideal_len=ideal_len, min_blocks=minb, max_blocks=maxb,
+                                  k=k, gap_threshold=gap, pad=pad, ar_mode=ar_mode,
+                                  face_tracking=face_tracking)
     return [str(Path(p)) for p in outs], f"Gerados: {len(outs)} arquivo(s)."
 
 css = """
@@ -722,7 +789,7 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
     gr.HTML("""
     <link href="https://fonts.googleapis.com/css2?family=Manrope:wght@400;600;800&display=swap" rel="stylesheet">
     <div style="text-align: center; padding: 24px 0;">
-        <h1>Editor de Cortes Automático</h1>
+        <h1>🎬 Editor de Cortes Automático</h1>
         <p style="color: #6b7280;">Gere cortes com rastreamento facial inteligente</p>
     </div>
     """)
@@ -733,11 +800,11 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
             with gr.Row():
                 model_size = gr.Dropdown(["tiny","base","small","medium"], value="small", label="Modelo Whisper")
                 out_subdir = gr.Textbox(label="Pasta de saída", value="cortes")
-            transcribe_btn = gr.Button("1) Transcrever", variant="primary")
+            transcribe_btn = gr.Button("🎙️ 1) Transcrever", variant="primary")
             transcript_preview = gr.Textbox(label="Status", lines=10)
         
         with gr.Column():
-            with gr.Tab("Cortes Simples"):
+            with gr.Tab("✂️ Cortes Simples"):
                 with gr.Row():
                     min_len = gr.Number(value=600, label="Min (s)")
                     max_len = gr.Number(value=900, label="Max (s)")
@@ -749,12 +816,12 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
                     pad = gr.Number(value=0.08, label="Pad")
                 ar_mode = gr.Dropdown(["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
                                      value="Original", label="Formato")
-                face_tracking = gr.Checkbox(label="Rastreamento facial", value=True)
-                go_linear = gr.Button("2) Gerar Cortes", variant="primary")
+                face_tracking = gr.Checkbox(label="👤 Rastreamento facial", value=True)
+                go_linear = gr.Button("🚀 2) Gerar Cortes", variant="primary")
                 out_linear = gr.Files(label="Arquivos gerados")
                 status_linear = gr.Textbox(label="Status", lines=2)
             
-            with gr.Tab("Cortes Criativos"):
+            with gr.Tab("🎨 Cortes Criativos"):
                 with gr.Row():
                     minb = gr.Number(value=3, label="Blocos min")
                     maxb = gr.Number(value=8, label="Blocos max")
@@ -764,35 +831,18 @@ with gr.Blocks(title="Editor de Cortes Automático", css=css) as demo:
                     pad2 = gr.Number(value=0.08, label="Pad")
                 ar_mode2 = gr.Dropdown(["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
                                       value="Original", label="Formato")
-                face_tracking2 = gr.Checkbox(label="Rastreamento facial", value=True)
-                go_creative = gr.Button("3) Gerar Criativos", variant="primary")
+                face_tracking2 = gr.Checkbox(label="👤 Rastreamento facial", value=True)
+                go_creative = gr.Button("🎬 3) Gerar Criativos", variant="primary")
                 out_creative = gr.Files(label="Arquivos gerados")
                 status_creative = gr.Textbox(label="Status", lines=2)
-
-            with gr.Tab("Cortes Virais (Opus-style)"):
-                with gr.Row():
-                    kv = gr.Number(value=3, label="Qtde de cortes")
-                    padv = gr.Number(value=0.05, label="Pad (s)")
-                with gr.Row():
-                    minv = gr.Number(value=20, label="Min (s)")
-                    maxv = gr.Number(value=60, label="Max (s)")
-                    idealv = gr.Number(value=40, label="Ideal (s)")
-                ar_modev = gr.Dropdown(["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"],
-                                      value="Original", label="Formato")
-                face_trackingv = gr.Checkbox(label="Rastreamento facial", value=True)
-                go_viral = gr.Button("4) Gerar Virais", variant="primary")
-                out_viral = gr.Files(label="Arquivos gerados")
-                status_viral = gr.Textbox(label="Status", lines=2)
     
     segs_state = gr.State([])
     
     transcribe_btn.click(do_transcribe, inputs=[video, model_size], outputs=[segs_state, transcript_preview])
-    go_linear.click(run_linear, inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode, face_tracking],
+    go_linear.click(run_linear, inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode, face_tracking, add_subs],
                    outputs=[out_linear, status_linear])
-    go_creative.click(run_creative, inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, minb, maxb, k2, gap2, pad2, ar_mode2, face_tracking2],
+    go_creative.click(run_creative, inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, minb, maxb, k2, gap2, pad2, ar_mode2, face_tracking2, add_subs2],
                      outputs=[out_creative, status_creative])
-    go_viral.click(run_viral, inputs=[segs_state, video, out_subdir, kv, padv, minv, maxv, idealv, ar_modev, face_trackingv],
-                   outputs=[out_viral, status_viral])
 
 if __name__ == "__main__":
-    demo.queue(max_size=20).launch()
+    demo.launch()