Update app.py

app.py

@@ -1,5 +1,6 @@
 import os
 import re
+import json
 import xml.etree.ElementTree as ET
 from dataclasses import dataclass
 from typing import List, Tuple, Optional
@@ -13,7 +14,7 @@ OUTPUT_DIR = "./Output"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 # =========================
-# LLM (opcional - Gemini)
+# LLM (Gemini)
 # =========================
 USE_LLM_DEFAULT = True
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
@@ -53,13 +54,11 @@ def _tc_to_hmsf(tc: str, fps: int = FPS) -> Tuple[int, int, int, int]:
     """Converte timecode para (hh, mm, ss, ff)."""
     s = tc.strip()
 
-    # HH:MM:SS:FF ou HH:MM:SS;FF
     m = re.match(r'^(\d{1,2}):(\d{2}):(\d{2})[:;](\d{2})$', s)
     if m:
         hh, mm, ss, ff = map(int, m.groups())
         return hh, mm, ss, ff
 
-    # HH:MM:SS[.,]mmm
     m = re.match(r'^(\d{1,2}):(\d{2}):(\d{2})[.,](\d{1,3})$', s)
     if m:
         hh, mm, ss, ms = map(int, m.groups())
@@ -69,7 +68,6 @@ def _tc_to_hmsf(tc: str, fps: int = FPS) -> Tuple[int, int, int, int]:
             ff = 0
         return hh, mm, ss, ff
 
-    # H:MM:SS
     m = re.match(r'^(\d{1,2}):(\d{2}):(\d{2})$', s)
     if m:
         hh, mm, ss = map(int, m.groups())
@@ -97,7 +95,7 @@ def frames_to_timecode(frames: int, fps: int = FPS) -> str:
 # Parser de Transcrição
 # =========================
 def parse_transcript(txt: str) -> List[Segment]:
-    """Parser robusto para múltiplos formatos de transcrição."""
+    """Parser robusto para múltiplos formatos."""
     if not txt or not txt.strip():
         return []
 
@@ -120,7 +118,6 @@ def parse_transcript(txt: str) -> List[Segment]:
             i += 1
             continue
 
-        # Formato com traço
         m = line_range.match(raw)
         if m:
             start_tc, end_tc, trailing_text = m.groups()
@@ -132,13 +129,7 @@ def parse_transcript(txt: str) -> List[Segment]:
                 j = i + 1
                 while j < len(lines):
                     nxt = lines[j].strip()
-                    if not nxt:
-                        break
-                    if line_range.match(nxt):
-                        break
-                    if re.match(r'^\d+\s*$', nxt):
-                        break
-                    if arrow.search(nxt):
+                    if not nxt or line_range.match(nxt) or re.match(r'^\d+\s*$', nxt) or arrow.search(nxt):
                         break
                     text_parts.append(nxt)
                     j += 1
@@ -162,7 +153,6 @@ def parse_transcript(txt: str) -> List[Segment]:
             i += 1
             continue
 
-        # Formato SRT/VTT
         if arrow.search(raw) or (i + 1 < len(lines) and arrow.search(lines[i + 1])):
             line_with_tc = raw if arrow.search(raw) else lines[i + 1]
             mm = arrow.search(line_with_tc)
@@ -223,406 +213,206 @@ def parse_manual_timecodes(manual_input: str) -> List[Tuple[str, str]]:
 
 
 # =========================
-# Interpretação do Comando (NLP otimizado)
+# IA: Análise Inteligente com Gemini
 # =========================
-@dataclass
-class CommandSpec:
-    total_segments: int
-    per_segment_seconds: Optional[int]
-    total_minutes: Optional[float]
-    start_timecode: Optional[str]
-    end_timecode: Optional[str]
-    keywords: List[str]
-    use_best_moments: bool
-    search_mode: str
-
-
-def parse_natural_command(text: str) -> CommandSpec:
-    """Parser NLP robusto com múltiplos padrões."""
-    s = text.strip().lower()
+def ai_analyze_and_select(segments: List[Segment], command: str, progress_callback=None) -> List[Segment]:
+    """
+    Usa Gemini para analisar a transcrição completa e identificar os melhores trechos.
+    Processo em 2 etapas para máxima precisão.
+    """
+    if not LLM_AVAILABLE or not segments:
+        raise ValueError("IA não disponível ou sem segmentos para analisar")
     
-    # Quantidade
-    count = 1
-    patterns = [
-        r'(\d+)\s*(?:cortes?|clipes?|segmentos?|trechos?|partes?)',
-        r'(?:crie?|faça?|faca|gere?|monte?|extraia?)\s+(\d+)',
-        r'quero\s+(\d+)',
-        r'preciso\s+(?:de\s+)?(\d+)'
-    ]
-    for pattern in patterns:
-        m = re.search(pattern, s)
-        if m:
-            count = max(1, int(m.group(1)))
-            break
-
-    # Duração em segundos
-    per_seg_sec = None
-    patterns_sec = [
-        r'(?:cortes?|clipes?|trechos?)\s+de\s+(\d+)\s*(?:segundos?|s\b)',
-        r'(\d+)\s*(?:segundos?|s\b)\s+(?:cada|por)',
-        r'(?:duração|duracao)\s+(?:de\s+)?(\d+)\s*s\b',
-        r'com\s+(\d+)\s*segundos?'
-    ]
-    for pattern in patterns_sec:
-        m = re.search(pattern, s)
-        if m:
-            per_seg_sec = int(m.group(1))
-            break
-
-    # Duração em minutos
-    if per_seg_sec is None:
-        patterns_min = [
-            r'(?:cortes?|clipes?|trechos?)\s+de\s+(\d+(?:\.\d+)?)\s*(?:minutos?|min\b)',
-            r'(\d+(?:\.\d+)?)\s*(?:minutos?|min\b)\s+(?:cada|por)',
-            r'(?:duração|duracao)\s+(?:de\s+)?(\d+(?:\.\d+)?)\s*min',
-            r'com\s+(\d+(?:\.\d+)?)\s*minutos?'
-        ]
-        for pattern in patterns_min:
-            m = re.search(pattern, s)
-            if m:
-                per_seg_sec = int(float(m.group(1)) * 60)
-                break
-
-    # Duração total
-    total_min = None
-    patterns_total = [
-        r'(?:corte|video|vídeo)\s+(?:de|com)\s+(\d+(?:\.\d+)?)\s*(?:minutos?|min\b)',
-        r'(?:totalizando|total\s+de)\s+(\d+(?:\.\d+)?)\s*min',
-        r'(?:faça|faca|crie)\s+(\d+(?:\.\d+)?)\s*minutos?',
-        r'(\d+(?:\.\d+)?)\s*minutos?\s+no\s+total'
-    ]
-    for pattern in patterns_total:
-        m = re.search(pattern, s)
-        if m:
-            total_min = float(m.group(1))
-            break
-
-    # Timecode início
-    start_tc = None
-    patterns_start = [
-        r'(?:começando|comecando|iniciando|a partir de|desde|starting at|from)\s+(?:em\s+|às\s+|as\s+)?(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)',
-        r'(?:do|no)\s+(?:tempo|timecode|tc)\s+(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)'
-    ]
-    for pattern in patterns_start:
-        m = re.search(pattern, s)
-        if m:
-            start_tc = m.group(1)
-            break
-
-    # Timecode fim
-    end_tc = None
-    patterns_end = [
-        r'(?:até|ate|terminando em|até o|finalizando em)\s+(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)',
-        r'(?:ao|no)\s+(?:tempo|timecode|tc)\s+(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)'
-    ]
-    for pattern in patterns_end:
-        m = re.search(pattern, s)
-        if m:
-            end_tc = m.group(1)
-            break
-
-    # Keywords
-    kw = []
-    patterns_kw = [
-        r'(?:sobre|falando sobre|abordando|tratando de|relacionado a)\s+([^,\.]+)',
-        r'(?:da parte|trecho|momento|cena)\s+(?:do|da|dos|das)\s+([^,\.]+)',
-        r'(?:tema|assunto|tópico|topico|conteúdo|conteudo)\s+([^,\.]+)',
-        r'(?:com|contendo|que menciona?|que fala sobre)\s+([^,\.]+)',
-        r'(?:onde|quando|que)\s+(?:fala|menciona|cita|aparece)\s+([^,\.]+)'
-    ]
-    for pattern in patterns_kw:
-        m = re.search(pattern, s)
-        if m:
-            keywords_text = m.group(1)
-            keywords_text = re.sub(r'\s+(?:e|ou|,)\s+', ',', keywords_text)
-            kw = [k.strip() for k in keywords_text.split(',') if k.strip()]
-            stopwords = {'o', 'a', 'os', 'as', 'de', 'do', 'da', 'dos', 'das', 'em', 'no', 'na'}
-            kw = [k for k in kw if k.lower() not in stopwords]
-            break
-
-    if not kw:
-        for word in ['sobre', 'do', 'da', 'dos', 'das']:
-            if word in s:
-                idx = s.index(word)
-                tail = s[idx + len(word):].strip()
-                end_words = ['começando', 'comecando', 'iniciando', 'de', 'com', 'em']
-                for ew in end_words:
-                    if ew in tail:
-                        tail = tail[:tail.index(ew)]
-                if tail:
-                    kw = [w.strip() for w in tail.split() if len(w.strip()) > 2][:5]
-                    break
-
-    # Melhores momentos
-    best = bool(re.search(r'melhor(?:es)?\s+momento|mais\s+interessante|destaque|highlight', s))
-
-    # Modo de busca
-    search_mode = 'continuous'
-    if best:
-        search_mode = 'best_moments'
-    elif kw:
-        search_mode = 'keyword'
+    if progress_callback:
+        progress_callback("🤖 Etapa 1/3: Preparando dados para análise...")
     
-    return CommandSpec(
-        total_segments=count,
-        per_segment_seconds=per_seg_sec,
-        total_minutes=total_min,
-        start_timecode=start_tc,
-        end_timecode=end_tc,
-        keywords=kw,
-        use_best_moments=best,
-        search_mode=search_mode
-    )
-
-
-# =========================
-# Utilidades (melhoradas)
-# =========================
-def find_keyword_in_segments(segs: List[Segment], keywords: List[str]) -> Tuple[int, float]:
-    """Retorna (índice, score) do melhor match."""
-    if not segs or not keywords:
-        return 0, 0.0
+    # Prepara a transcrição completa com índices
+    transcript_data = []
+    for i, seg in enumerate(segments):
+        duration_sec = (seg.end_f - seg.start_f) / FPS
+        transcript_data.append({
+            "index": i,
+            "timecode": seg.start_tc,
+            "duration_sec": round(duration_sec, 1),
+            "text": seg.text[:200]  # Limita texto para não estourar tokens
+        })
     
-    best_idx, best_score = 0, 0.0
-    kw_lower = [kw.lower() for kw in keywords]
+    # Converte para JSON para análise estruturada
+    transcript_json = json.dumps(transcript_data, ensure_ascii=False, indent=2)
     
-    for idx, seg in enumerate(segs):
-        text_lower = seg.text.lower()
-        score = 0.0
-        
-        for kw in kw_lower:
-            if kw in text_lower:
-                score += len(kw.split()) * 5.0
-        
-        words = text_lower.split()
-        for kw in kw_lower:
-            kw_words = kw.split()
-            for kw_word in kw_words:
-                if len(kw_word) > 2:
-                    for word in words:
-                        if kw_word in word or word in kw_word:
-                            score += 1.0
-        
-        if score > best_score:
-            best_idx, best_score = idx, score
+    if progress_callback:
+        progress_callback(f"🤖 Etapa 2/3: Analisando {len(segments)} segmentos com IA (pode levar 30-60s)...")
     
-    return best_idx, best_score
-
+    # Prompt detalhado para análise completa
+    prompt = f"""Você é um especialista em edição de vídeo. Analise a transcrição e identifique os MELHORES trechos baseado no comando do usuário.
+
+COMANDO DO USUÁRIO:
+{command}
+
+TRANSCRIÇÃO COMPLETA (formato JSON com index, timecode, duração e texto):
+{transcript_json}
+
+INSTRUÇÕES:
+1. Leia o comando com atenção e identifique:
+   - Quantidade de cortes desejada
+   - Duração de cada corte (em segundos)
+   - Tema/assunto/palavras-chave mencionados
+   - Timecode de início (se mencionado)
+
+2. Analise TODA a transcrição e identifique os segmentos que melhor correspondem ao comando
+
+3. Para cada corte, retorne no formato JSON:
+{{
+  "cuts": [
+    {{
+      "start_index": <índice do segmento inicial>,
+      "duration_seconds": <duração desejada em segundos>,
+      "reason": "<breve explicação de por que escolheu este trecho>"
+    }}
+  ]
+}}
+
+IMPORTANTE:
+- Seja PRECISO na identificação dos trechos
+- Considere o contexto completo ao redor das palavras-chave
+- Se o comando pedir "sobre X", encontre onde X é realmente discutido
+- Se houver timecode, priorize começar próximo a ele
+- Retorne APENAS o JSON, sem texto adicional
+
+Responda com o JSON:"""
 
-def find_llm_segment(segs: List[Segment], keywords: List[str], command: str) -> Tuple[Optional[int], float]:
-    """Usa LLM para encontrar segmento. Retorna (índice, confiança)."""
-    if not LLM_AVAILABLE or not segs:
-        return None, 0.0
-    
     try:
-        preview_lines = []
-        for i, s in enumerate(segs[:100]):
-            text_preview = (s.text or '')[:120]
-            duration_sec = (s.end_f - s.start_f) / FPS
-            preview_lines.append(f"{i}|{s.start_tc}|{duration_sec:.1f}s|{text_preview}")
-        
-        preview_text = "\n".join(preview_lines)
-        keywords_str = ", ".join(keywords[:10]) if keywords else "não especificado"
-        
-        prompt = f"""Analise os segmentos e retorne APENAS o número do índice onde o conteúdo solicitado começa.
-
-IMPORTANTE: Responda SOMENTE com o número do índice (ex: 42). Não explique.
-
-COMANDO DO USUÁRIO: {command}
-
-PALAVRAS-CHAVE: {keywords_str}
-
-SEGMENTOS (formato: índice|timecode|duração|texto):
-{preview_text}
-
-Qual índice melhor corresponde ao início do conteúdo solicitado?
-Responda apenas o número:"""
-
         response = LLM.generate_content(
             prompt,
             generation_config={
-                "temperature": 0.1,
-                "max_output_tokens": 30,
-                "top_p": 0.8
+                "temperature": 0.2,
+                "max_output_tokens": 2000,
             }
         )
         
-        text = (response.text or "").strip()
+        response_text = response.text.strip()
         
-        patterns = [
-            r'^\s*(\d+)\s*$',
-            r'(?:índice|index|segmento)\s*(\d+)',
-            r'(?:número|numero|#)\s*(\d+)',
-            r'\b(\d+)\b'
-        ]
+        if progress_callback:
+            progress_callback("🤖 Etapa 3/3: Processando resposta da IA...")
+        
+        # Extrai JSON da resposta
+        json_match = re.search(r'\{[\s\S]*"cuts"[\s\S]*\}', response_text)
+        if not json_match:
+            raise ValueError("IA não retornou JSON válido")
         
-        for pattern in patterns:
-            m = re.search(pattern, text, re.IGNORECASE)
-            if m:
-                idx = int(m.group(1))
-                if 0 <= idx < len(segs):
-                    confidence = 0.9 if pattern == patterns[0] else 0.7
-                    return idx, confidence
+        result = json.loads(json_match.group(0))
+        cuts_data = result.get("cuts", [])
         
-        return None, 0.0
+        if not cuts_data:
+            raise ValueError("IA não encontrou cortes adequados")
         
+        # Cria os segmentos baseado na análise da IA
+        selected_segments = []
+        
+        for cut_info in cuts_data:
+            start_idx = cut_info.get("start_index", 0)
+            duration_sec = cut_info.get("duration_seconds", 60)
+            reason = cut_info.get("reason", "")
+            
+            if start_idx < 0 or start_idx >= len(segments):
+                continue
+            
+            start_seg = segments[start_idx]
+            start_frame = start_seg.start_f
+            duration_frames = int(duration_sec * FPS)
+            end_frame = start_frame + duration_frames
+            
+            # Coleta texto dos segmentos envolvidos
+            text_parts = [f"[IA: {reason}]"] if reason else []
+            for seg in segments[start_idx:]:
+                if seg.start_f < end_frame:
+                    if seg.text:
+                        text_parts.append(seg.text[:150])
+                else:
+                    break
+            
+            combined_text = " [...] ".join(text_parts)[:500]
+            
+            selected_segments.append(Segment(
+                start_tc=frames_to_timecode(start_frame),
+                end_tc=frames_to_timecode(end_frame),
+                start_f=start_frame,
+                end_f=end_frame,
+                text=combined_text,
+                score=100.0
+            ))
+        
+        return selected_segments
+        
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Erro ao processar resposta da IA (JSON inválido): {str(e)}\nResposta: {response_text[:300]}")
     except Exception as e:
-        print(f"Erro no LLM: {e}")
-        return None, 0.0
+        raise ValueError(f"Erro na análise da IA: {str(e)}")
 
 
-def create_continuous_segment_from(start_frame: int, duration_frames: int, segs_preview: List[Segment]) -> Segment:
-    end_frame = max(start_frame + duration_frames, start_frame + 1)
-    
-    text_parts = []
-    for seg in segs_preview[:15]:
-        if seg.text and len(seg.text.strip()) > 5:
-            text_parts.append(seg.text[:100])
+# =========================
+# Processamento com Comando Manual (sem IA)
+# =========================
+def manual_command_processing(segments: List[Segment], command: str) -> List[Segment]:
+    """
+    Fallback: processamento básico sem IA para comandos simples.
+    """
+    s = command.lower()
     
-    combined = " [...] ".join(text_parts)[:400] if text_parts else ""
+    # Extrai quantidade
+    count = 1
+    m = re.search(r'(\d+)\s*(?:cortes?|clipes?|segmentos?)', s)
+    if m:
+        count = int(m.group(1))
     
-    return Segment(
-        start_tc=frames_to_timecode(start_frame),
-        end_tc=frames_to_timecode(end_frame),
-        start_f=start_frame,
-        end_f=end_frame,
-        text=combined if combined else f"Corte contínuo de {duration_frames/FPS:.1f}s",
-        score=100.0
-    )
-
-
-def process_with_command(segs: List[Segment], command: str, use_llm: bool) -> List[Segment]:
-    """Processa instruções naturais com sistema multi-camadas."""
-    spec = parse_natural_command(command)
-
-    # Calcula duração
-    if spec.per_segment_seconds:
-        per_seg_seconds = spec.per_segment_seconds
-        total_segments = max(1, spec.total_segments)
-    elif spec.total_minutes:
-        total_seconds = int(spec.total_minutes * 60)
-        if spec.total_segments > 1:
-            per_seg_seconds = max(5, total_seconds // spec.total_segments)
-            total_segments = spec.total_segments
-        else:
-            per_seg_seconds = total_seconds
-            total_segments = 1
+    # Extrai duração
+    duration_sec = 60
+    m = re.search(r'(\d+)\s*(?:segundos?|s\b)', s)
+    if m:
+        duration_sec = int(m.group(1))
     else:
-        per_seg_seconds = 60
-        total_segments = max(1, spec.total_segments)
-
-    # Determina início com fallback
-    start_frame = 0
-    start_idx = None
-    search_confidence = 0.0
-    
-    # Timecode explícito
-    if spec.start_timecode:
-        try:
-            start_frame = parse_timecode_to_frames(spec.start_timecode)
-            search_confidence = 1.0
-        except Exception:
-            pass
-    
-    # LLM
-    if search_confidence < 0.8 and use_llm and segs and (spec.keywords or spec.search_mode == 'llm'):
-        llm_idx, llm_conf = find_llm_segment(segs, spec.keywords, command)
-        if llm_idx is not None and llm_conf > search_confidence:
-            start_idx = llm_idx
-            start_frame = segs[start_idx].start_f
-            search_confidence = llm_conf
-    
-    # Keywords
-    if search_confidence < 0.6 and segs and spec.keywords:
-        kw_idx, kw_score = find_keyword_in_segments(segs, spec.keywords)
-        kw_conf = min(0.9, kw_score / 10.0)
-        if kw_conf > search_confidence:
-            start_idx = kw_idx
-            start_frame = segs[start_idx].start_f
-            search_confidence = kw_conf
-    
-    # Melhores momentos
-    if spec.use_best_moments and segs:
-        scored = [(i, s) for i, s in enumerate(segs) if s.score > 0]
-        if scored:
-            scored.sort(key=lambda x: x[1].score, reverse=True)
-            start_idx = scored[0][0]
-            start_frame = segs[start_idx].start_f
-            search_confidence = 0.8
+        m = re.search(r'(\d+)\s*(?:minutos?|min\b)', s)
+        if m:
+            duration_sec = int(m.group(1)) * 60
     
-    # Determina fim
-    end_frame = None
-    if spec.end_timecode:
+    # Extrai timecode inicial
+    start_frame = 0
+    m = re.search(r'(?:começando|a partir de)\s+(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)', s)
+    if m:
         try:
-            end_frame = parse_timecode_to_frames(spec.end_timecode)
-        except Exception:
+            start_frame = parse_timecode_to_frames(m.group(1))
+        except:
             pass
     
-    # Construção dos cortes
-    segments_out: List[Segment] = []
-    
-    # Intervalo específico
-    if end_frame and end_frame > start_frame:
-        duration_frames = end_frame - start_frame
-        if total_segments == 1:
-            seg_preview = []
-            if segs and start_idx is not None:
-                seg_preview = segs[start_idx:start_idx + 20]
-            seg = create_continuous_segment_from(start_frame, duration_frames, seg_preview)
-            segments_out.append(seg)
-        else:
-            frames_per_seg = duration_frames // total_segments
-            base = start_frame
-            for i in range(total_segments):
-                seg_preview = []
-                if segs and start_idx is not None:
-                    seg_preview = segs[start_idx + i:start_idx + i + 10]
-                seg = create_continuous_segment_from(base, frames_per_seg, seg_preview)
-                segments_out.append(seg)
-                base = seg.end_f
-        return segments_out
-    
-    # Cortes sequenciais
+    # Cria cortes contínuos
+    results = []
     base_frame = start_frame
     
-    if not segs:
-        for _ in range(total_segments):
-            duration_frames = int(per_seg_seconds * FPS)
-            seg = create_continuous_segment_from(base_frame, duration_frames, [])
-            segments_out.append(seg)
-            base_frame = seg.end_f
-        return segments_out
-    
-    # Com transcrição
-    for i in range(total_segments):
-        duration_frames = int(per_seg_seconds * FPS)
+    for i in range(count):
+        duration_frames = duration_sec * FPS
+        end_frame = base_frame + duration_frames
         
-        seg_start_idx = None
-        if start_idx is not None:
-            for idx in range(start_idx, len(segs)):
-                if segs[idx].start_f >= base_frame:
-                    seg_start_idx = idx
-                    break
-        else:
-            for idx, s in enumerate(segs):
-                if s.start_f >= base_frame:
-                    seg_start_idx = idx
-                    break
+        # Coleta texto
+        text_parts = []
+        for seg in segments:
+            if seg.start_f >= base_frame and seg.start_f < end_frame:
+                if seg.text:
+                    text_parts.append(seg.text[:100])
         
-        seg_preview = []
-        if seg_start_idx is not None:
-            end_of_cut = base_frame + duration_frames
-            for s in segs[seg_start_idx:]:
-                if s.start_f < end_of_cut:
-                    seg_preview.append(s)
-                else:
-                    break
+        combined_text = " [...] ".join(text_parts[:10])[:400]
+        
+        results.append(Segment(
+            start_tc=frames_to_timecode(base_frame),
+            end_tc=frames_to_timecode(end_frame),
+            start_f=base_frame,
+            end_f=end_frame,
+            text=combined_text if combined_text else f"Corte {i+1}",
+            score=50.0
+        ))
         
-        seg = create_continuous_segment_from(base_frame, duration_frames, seg_preview)
-        segments_out.append(seg)
-        base_frame = seg.end_f
+        base_frame = end_frame
     
-    return segments_out
+    return results
 
 
 # =========================
@@ -637,15 +427,11 @@ def auto_score_segments(
     weight_learn: float,
     weight_viral: float
 ) -> List[Segment]:
-    """Sistema de pontuação expandido."""
-    emotion_words = ['medo', 'coragem', 'amor', 'ódio', 'paixão', 'alegria', 'tristeza', 
-                     'ansiedade', 'felicidade', 'emoção', 'sentimento', 'coração']
-    break_words = ['nunca', 'de repente', 'surpreendente', 'inesperado', 'incrível',
-                   'chocante', 'virada', 'mudança', 'momento', 'aconteceu']
-    learn_words = ['aprendi', 'descobri', 'entendi', 'percebi', 'compreendi', 'lição',
-                   'ensinamento', 'experiência', 'conhecimento', 'insight']
-    viral_words = ['segredo', 'verdade', 'ninguém sabe', 'revelação', 'exclusivo',
-                   'primeira vez', 'confissão', 'polêmica', 'controverso']
+    """Sistema de pontuação automática."""
+    emotion_words = ['medo', 'coragem', 'amor', 'ódio', 'paixão', 'alegria', 'tristeza']
+    break_words = ['nunca', 'de repente', 'surpreendente', 'inesperado', 'incrível']
+    learn_words = ['aprendi', 'descobri', 'entendi', 'percebi', 'lição']
+    viral_words = ['segredo', 'verdade', 'revelação', 'exclusivo', 'confissão']
     
     for s in segs:
         score = 0.0
@@ -671,14 +457,7 @@ def auto_score_segments(
             for kw in custom_keywords.split(","):
                 kw_clean = kw.strip().lower()
                 if kw_clean and kw_clean in text:
-                    score += 3.0 * len(kw_clean.split())
-        
-        duration_sec = (s.end_f - s.start_f) / FPS
-        if 10 <= duration_sec <= 120:
-            score += 0.5
-        
-        if len(text) > 100:
-            score += 0.3
+                    score += 5.0
         
         s.score = score
     
@@ -723,7 +502,6 @@ def edit_xml(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
         if duration <= 0:
             continue
 
-        # Vídeo
         v_clip = ET.Element("clipitem", {"id": f"clip-v{i}"})
         ET.SubElement(v_clip, "name").text = f"Clip {i}"
         ET.SubElement(v_clip, "start").text = str(timeline_pos)
@@ -739,7 +517,6 @@ def edit_xml(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
             if file_elem is not None:
                 v_clip.append(deep_copy_element(file_elem))
 
-        # Áudio
         a_clip = ET.Element("clipitem", {"id": f"clip-a{i}"})
         ET.SubElement(a_clip, "name").text = f"Clip {i}"
         ET.SubElement(a_clip, "start").text = str(timeline_pos)
@@ -775,7 +552,8 @@ def select_segments(
     weight_emotion: float,
     weight_break: float,
     weight_learn: float,
-    weight_viral: float
+    weight_viral: float,
+    progress_callback=None
 ) -> List[Segment]:
 
     # 1) Manual
@@ -799,9 +577,16 @@ def select_segments(
     # 2) Parser de transcrição
     segs = parse_transcript(transcript_txt) if transcript_txt else []
 
-    # 3) Linguagem natural
+    # 3) Linguagem natural COM IA
     if natural_instructions.strip():
-        return process_with_command(segs, natural_instructions, use_llm and LLM_AVAILABLE)
+        if use_llm and LLM_AVAILABLE and segs:
+            # USA IA PARA ANÁLISE COMPLETA
+            return ai_analyze_and_select(segs, natural_instructions, progress_callback)
+        elif segs:
+            # Fallback sem IA
+            return manual_command_processing(segs, natural_instructions)
+        else:
+            raise ValueError("Para usar comandos em linguagem natural, forneça uma transcrição ou ative as minutagens manuais.")
 
     # 4) Automático
     if not segs:
@@ -818,7 +603,8 @@ def select_segments(
 def process_files(
     xml_file, txt_file, use_llm, num_segments,
     custom_keywords, manual_timecodes, natural_instructions,
-    weight_emotion, weight_break, weight_learn, weight_viral
+    weight_emotion, weight_break, weight_learn, weight_viral,
+    progress=gr.Progress()
 ):
     if not xml_file:
         return "⚠️ Envie o XML do Premiere", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
@@ -826,22 +612,31 @@ def process_files(
     try:
         debug_info = []
         
+        def progress_callback(msg):
+            progress(0.5, desc=msg)
+            debug_info.append(msg)
+        
+        progress(0.1, desc="📂 Carregando arquivos...")
+        
         transcript = ""
         manual = parse_manual_timecodes(manual_timecodes)
 
         if not manual and txt_file:
             with open(txt_file.name, "r", encoding="utf-8-sig") as f:
                 transcript = f.read()
-            debug_info.append(f"📄 Transcrição carregada: {len(transcript)} caracteres")
+            debug_info.append(f"📄 Transcrição: {len(transcript)} caracteres")
 
+        progress(0.2, desc="🔍 Selecionando segmentos...")
+        
         segments = select_segments(
             transcript, use_llm and LLM_AVAILABLE, num_segments,
             custom_keywords, manual_timecodes, natural_instructions,
-            weight_emotion, weight_break, weight_learn, weight_viral
+            weight_emotion, weight_break, weight_learn, weight_viral,
+            progress_callback
         )
 
         if not segments:
-            return "⚠️ Nenhum segmento selecionado. Verifique os parâmetros.", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
+            return "⚠️ Nenhum segmento selecionado", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
 
         valid_segments = []
         for seg in segments:
@@ -849,11 +644,13 @@ def process_files(
                 valid_segments.append(seg)
         
         if not valid_segments:
-            return "⚠️ Segmentos inválidos (duração muito curta). Ajuste os parâmetros.", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
+            return "⚠️ Segmentos inválidos (duração muito curta)", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
         
         segments = valid_segments
         debug_info.append(f"✓ {len(segments)} segmento(s) válido(s)")
 
+        progress(0.7, desc="✂️ Editando XML...")
+        
         tree = ET.parse(xml_file.name)
         tree = edit_xml(tree, segments)
 
@@ -861,25 +658,25 @@ def process_files(
         output = os.path.join(OUTPUT_DIR, f"{basename}_EDITADO.xml")
         tree.write(output, encoding="utf-8", xml_declaration=True)
 
+        progress(0.9, desc="📊 Gerando resumo...")
+        
         total_sec = sum((s.end_f - s.start_f) / FPS for s in segments)
         total_min = total_sec / 60.0
         
         if manual:
             mode = "🎯 MANUAL"
+        elif natural_instructions.strip() and use_llm and LLM_AVAILABLE:
+            mode = "🤖 IA COMPLETA (Gemini)"
         elif natural_instructions.strip():
-            spec = parse_natural_command(natural_instructions)
-            if spec.keywords:
-                mode = f"🤖 IA + BUSCA ({', '.join(spec.keywords[:3])})"
-            else:
-                mode = "📐 IA + CONTÍNUO"
+            mode = "📐 BÁSICO (sem IA)"
         else:
             mode = "⚙️ AUTOMÁTICO"
 
         summary_lines = [
-            "═" * 60,
+            "═" * 70,
             f"✨ RESULTADO: {len(segments)} corte(s) | {total_min:.1f} min total",
             f"📊 Modo: {mode}",
-            "═" * 60,
+            "═" * 70,
             ""
         ]
         
@@ -888,28 +685,26 @@ def process_files(
             dur_min = dur_sec / 60.0
             
             line = f"🎬 Corte {i}:"
-            line += f"\n   ⏱️  {seg.start_tc} → {seg.end_tc} ({dur_min:.2f} min)"
+            line += f"\n   ⏱️  {seg.start_tc} → {seg.end_tc} ({dur_min:.2f} min / {dur_sec:.0f}s)"
             
             if seg.text and len(seg.text.strip()) > 10:
-                text_preview = seg.text[:150].strip()
-                if len(seg.text) > 150:
+                text_preview = seg.text[:200].strip()
+                if len(seg.text) > 200:
                     text_preview += "..."
                 line += f"\n   💬 {text_preview}"
             
-            if seg.score > 0:
-                line += f"\n   ⭐ Score: {seg.score:.1f}"
-            
             summary_lines.append(line)
             summary_lines.append("")
         
         if debug_info:
-            summary_lines.append("═" * 60)
-            summary_lines.append("🔍 Debug:")
+            summary_lines.append("═" * 70)
+            summary_lines.append("🔍 Log do Processamento:")
             summary_lines.extend(f"   {info}" for info in debug_info)
         
         summary = "\n".join(summary_lines)
         status = f"✅ Sucesso | {mode} | {total_min:.1f} min | LLM: {'✓' if LLM_AVAILABLE else '✗'}"
         
+        progress(1.0, desc="✅ Concluído!")
         return summary, output, status
 
     except Exception as e:
@@ -917,78 +712,98 @@ def process_files(
         error_trace = traceback.format_exc()
         print(error_trace)
         
-        error_msg = f"❌ Erro: {str(e)}\n\n🔍 Detalhes técnicos:\n{error_trace[:500]}"
+        error_msg = f"❌ Erro: {str(e)}\n\n🔍 Detalhes:\n{error_trace[:800]}"
         return error_msg, None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
 
 
 # =========================
 # Interface Gradio
 # =========================
-with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere") as demo:
-    gr.Markdown("# 🎬 Editor XML Premiere - IA Avançada")
-    gr.Markdown("Sistema inteligente de cortes com IA (Gemini), busca por keywords e timecodes manuais.")
+with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere - IA") as demo:
+    gr.Markdown("# 🎬 Editor XML Premiere - IA Completa (Gemini)")
+    gr.Markdown("Sistema que **REALMENTE ENTENDE** seu comando usando análise completa com IA.")
     
-    status_inicial = f"{'🟢 IA Disponível (Gemini 2.0)' if LLM_AVAILABLE else '🟡 Modo básico (IA desabilitada - configure GEMINI_API_KEY)'}"
+    status_inicial = f"{'🟢 IA Gemini Ativa - Análise Completa Habilitada' if LLM_AVAILABLE else '🔴 IA Desabilitada - Configure GEMINI_API_KEY para análise inteligente'}"
     gr.Markdown(f"**Status:** {status_inicial}")
+    
+    if LLM_AVAILABLE:
+        gr.Markdown("""
+        ### 🚀 Como funciona a IA:
+        1. **Você descreve** o que quer em linguagem natural
+        2. **IA analisa** toda a transcrição (pode levar 30-60s)
+        3. **IA identifica** os trechos exatos que correspondem ao seu pedido
+        4. **Sistema cria** os cortes precisos automaticamente
+        
+        ⚡ **Mais lento, mas MUITO mais preciso!**
+        """)
+    else:
+        gr.Markdown("""
+        ### ⚠️ IA Desabilitada
+        Configure a variável de ambiente `GEMINI_API_KEY` para ativar análise inteligente.
+        No modo básico, apenas comandos simples e timecodes manuais funcionam bem.
+        """)
 
     with gr.Row():
         xml_in = gr.File(label="📄 XML do Premiere", file_types=[".xml"])
-        txt_in = gr.File(label="📝 Transcrição (.txt) - opcional", file_types=[".txt"])
+        txt_in = gr.File(label="📝 Transcrição (.txt) - OBRIGATÓRIA para IA", file_types=[".txt"])
 
     with gr.Row():
         use_llm = gr.Checkbox(
-            label="🤖 Usar IA (Gemini) para busca inteligente", 
+            label="🤖 Usar IA Gemini (análise completa - RECOMENDADO)", 
             value=USE_LLM_DEFAULT and LLM_AVAILABLE,
-            interactive=LLM_AVAILABLE
+            interactive=LLM_AVAILABLE,
+            info="Quando ativo, a IA lê TODA a transcrição e encontra os melhores trechos"
         )
-        num_segments = gr.Slider(2, 20, 5, 1, label="📊 Segmentos (modo automático)")
+        num_segments = gr.Slider(2, 20, 5, 1, label="📊 Segmentos (apenas modo automático)")
 
-    with gr.Accordion("💬 Comando em linguagem natural (RECOMENDADO)", open=True):
+    with gr.Accordion("💬 Comando em Linguagem Natural (MODO PRINCIPAL)", open=True):
         gr.Markdown("""
-**Exemplos de comandos suportados:**
-
-📌 **Duração e quantidade:**
-- "Crie 3 cortes de 30 segundos"
-- "Faça 1 corte de 10 minutos"
-- "Quero 5 clipes de 45s cada"
-
-📍 **Com timecode:**
-- "2 cortes de 1min começando em 00:02:10:00"
-- "Corte de 5 minutos a partir de 00:05:00:00"
-
-🔍 **Com busca de conteúdo (requer transcrição + IA):**
-- "3 cortes de 30s sobre Maria e José"
-- "1 corte de 10 minutos da parte do tenista"
-- "2 clipes de 45s falando sobre coragem"
-- "Corte sobre disciplina começando em 00:02:00"
-
-🎯 **Intervalo específico:**
-- "Corte de 00:10:00:00 até 00:15:00:00"
-- "3 segmentos começando em 00:02:00 até 00:05:00"
-
-💡 **Dicas:**
-- Com transcrição + IA: busca automática do conteúdo
-- Sem transcrição: cortes contínuos a partir do timecode
-- Seja específico nas durações e palavras-chave
+        ### ✨ Exemplos de comandos que a IA entende:
+        
+        **📌 Simples:**
+        - "Crie 3 cortes de 30 segundos sobre futebol"
+        - "Quero 2 clipes de 1 minuto falando sobre Maria"
+        - "Faça 5 cortes de 45s sobre o tema educação"
+        
+        **🎯 Específicos:**
+        - "1 corte de 10 minutos da parte onde ele fala sobre a infância"
+        - "3 cortes de 30s sobre os momentos engraçados"
+        - "2 clipes de 1min sobre superação e disciplina"
+        
+        **📍 Com timecode:**
+        - "Corte de 5 minutos começando em 00:02:00:00 sobre tecnologia"
+        - "3 cortes de 45s a partir de 00:10:00 falando sobre amor"
+        
+        **🔍 Busca temática:**
+        - "Os melhores momentos sobre família, cada um com 40s"
+        - "Trechos emocionantes de 1 minuto cada"
+        - "Partes onde menciona desafios e conquistas"
+        
+        ### 💡 Dicas para melhores resultados:
+        - ✅ Seja específico sobre o tema/assunto
+        - ✅ Especifique duração e quantidade
+        - ✅ Use a transcrição completa
+        - ✅ Deixe a IA trabalhar (30-60s de análise)
+        - ❌ Evite comandos vagos como "faça algo legal"
         """)
         natural_instructions = gr.Textbox(
-            label="Seu comando",
-            placeholder='Ex: "Crie 2 cortes de 45s sobre disciplina, começando em 00:01:00:00"',
-            lines=3
+            label="Digite seu comando aqui",
+            placeholder='Ex: "Crie 3 cortes de 45 segundos sobre os momentos onde ele fala de disciplina e superação"',
+            lines=4
         )
 
-    with gr.Accordion("🎯 Minutagens manuais (alta precisão)", open=False):
-        gr.Markdown("Use este modo quando souber exatamente os timecodes. Um por linha ou separados por vírgula.")
+    with gr.Accordion("🎯 Minutagens Manuais (precisão total)", open=False):
+        gr.Markdown("Use quando souber exatamente os timecodes. Ignora IA e outros modos.")
         manual_timecodes = gr.Textbox(
-            label="Timecodes (formato: HH:MM:SS:FF - HH:MM:SS:FF)",
+            label="Timecodes (um por linha)",
             placeholder="00:21:18:09 - 00:31:18:09\n00:45:20:15 - 00:50:10:22",
             lines=4
         )
 
-    with gr.Accordion("⚙️ Modo automático (com transcrição)", open=False):
-        gr.Markdown("Sistema de pontuação automática baseado em palavras-chave e pesos.")
+    with gr.Accordion("⚙️ Modo Automático (sem comando)", open=False):
+        gr.Markdown("Sistema de pontuação simples. **Não recomendado** - use comandos em linguagem natural.")
         custom_keywords = gr.Textbox(
-            label="Palavras-chave personalizadas (separadas por vírgula)",
+            label="Palavras-chave (separadas por vírgula)",
             placeholder="coragem, superação, vitória"
         )
         with gr.Row():
@@ -998,11 +813,11 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere") as demo:
             weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="🎓 Peso: aprendizado")
             weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="🔥 Peso: viral")
 
-    btn = gr.Button("🚀 Processar e Gerar XML", variant="primary", size="lg")
+    btn = gr.Button("🚀 Processar com IA (pode levar 30-60s)", variant="primary", size="lg")
 
     with gr.Row():
         with gr.Column(scale=2):
-            summary_out = gr.Textbox(label="📋 Resumo dos Cortes", lines=15, max_lines=25)
+            summary_out = gr.Textbox(label="📋 Resumo dos Cortes", lines=20, max_lines=30)
         with gr.Column(scale=1):
             status_out = gr.Textbox(label="📊 Status", lines=3)
             file_out = gr.File(label="⬇️ Download XML Editado")
@@ -1017,15 +832,26 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere") as demo:
     
     gr.Markdown("""
 ---
-### 📚 Como usar:
-1. **Envie o XML** exportado do Premiere (File > Export > Final Cut Pro XML)
-2. **Opcional:** Envie transcrição para buscas inteligentes
-3. **Escolha um modo:**
-   - 💬 Linguagem natural (mais fácil)
-   - 🎯 Minutagens manuais (mais preciso)
-   - ⚙️ Automático (experimental)
-4. Clique em **Processar** e faça download do XML editado
-5. Importe de volta no Premiere (File > Import)
+### 📚 Guia Rápido:
+
+**🎯 Para melhores resultados:**
+1. ✅ Envie XML + Transcrição completa
+2. ✅ Ative a IA (checkbox)
+3. ✅ Escreva comando claro e específico
+4. ✅ Aguarde 30-60s para análise completa
+5. ✅ Baixe e importe no Premiere
+
+**⚡ Ordem de prioridade:**
+1. **Minutagens Manuais** (ignora tudo, máxima precisão)
+2. **Comando + IA** (análise completa, muito preciso)
+3. **Comando sem IA** (básico, menos preciso)
+4. **Modo Automático** (não recomendado)
+
+**🔧 Troubleshooting:**
+- Erro "IA não disponível": Configure `GEMINI_API_KEY`
+- Cortes errados: Seja mais específico no comando
+- Demora muito: Normal para IA completa (30-60s)
+- Sem transcrição: Use minutagens manuais
     """)
 
 if __name__ == "__main__":