Update app.py

app.py

@@ -17,14 +17,11 @@ try:
         genai.configure(api_key=GEMINI_API_KEY)
         LLM = genai.GenerativeModel(LLM_MODEL_NAME)
         LLM_AVAILABLE = True
-        print("✓ IA Gemini configurada com sucesso")
     else:
         LLM = None
-        print("⚠ GEMINI_API_KEY não encontrada")
-except Exception as e:
+except Exception:
     LLM = None
     LLM_AVAILABLE = False
-    print(f"⚠ Erro ao configurar IA: {e}")
 
 # Config
 FPS = 24
@@ -42,16 +39,14 @@ class Segment:
 
 # ============ TIMECODE FUNCTIONS ============
 def parse_timecode_to_frames(tc: str, fps: int = FPS) -> int:
-    """Converte timecode para frames"""
     tc = tc.strip()
-    m = re.match(r"^(\d{2}):(\d{2}):(\d{2})[:;](\d{2})$", tc)
+    m = re.match(r'^(\d{2}):(\d{2}):(\d{2})[:;](\d{2})$', tc)
     if not m:
         raise ValueError(f"Timecode inválido: {tc}")
     hh, mm, ss, ff = map(int, m.groups())
     return hh*3600*fps + mm*60*fps + ss*fps + ff
 
 def frames_to_timecode(frames: int, fps: int = FPS) -> str:
-    """Converte frames para timecode"""
     hh = frames // (3600*fps)
     rem = frames % (3600*fps)
     mm = rem // (60*fps)
@@ -61,22 +56,25 @@ def frames_to_timecode(frames: int, fps: int = FPS) -> str:
     return f"{hh:02d}:{mm:02d}:{ss:02d}:{ff:02d}"
 
 # ============ TRANSCRIPT PARSING ============
-def parse_transcript_full(txt: str) -> List[Segment]:
-    """Parse transcrição com diferentes formatos"""
+def parse_transcript(txt: str) -> List[Segment]:
+    """Parse transcrição - aceita vários formatos"""
     if not txt or not txt.strip():
+        print("⚠️ Transcrição vazia")
         return []
     
-    lines = txt.splitlines()
-    results: List[Segment] = []
+    lines = txt.strip().splitlines()
+    results = []
     
+    # Regex flexível
     pattern = re.compile(
-        r'^\s*\[?\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*[-—–]\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*\]?\s*(.*)$'
+        r'^\s*\[?\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*[-—–]\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*\]?\s*(.*)$',
+        re.IGNORECASE
     )
     
-    for line in lines:
+    for idx, line in enumerate(lines):
         line = line.strip()
         
-        if not line or line == "Desconhecido":
+        if not line or line.lower() == "desconhecido":
             continue
         
         match = pattern.match(line)
@@ -85,7 +83,7 @@ def parse_transcript_full(txt: str) -> List[Segment]:
             start_tc, end_tc, text = match.groups()
             text = text.strip()
             
-            if not text or text == "Desconhecido":
+            if not text or text.lower() == "desconhecido":
                 continue
             
             try:
@@ -102,73 +100,50 @@ def parse_transcript_full(txt: str) -> List[Segment]:
                         score=0.0
                     ))
             except Exception as e:
-                print(f"⚠ Erro ao processar linha: {e}")
+                print(f"⚠️ Erro linha {idx}: {str(e)}")
                 continue
     
-    print(f"✓ Encontrados {len(results)} segmentos na transcrição")
+    print(f"✅ {len(results)} segmentos encontrados")
     return results
 
 # ============ MANUAL TIMECODES ============
 def parse_manual_timecodes(manual_input: str) -> List[Tuple[str, str]]:
-    """Parse timecodes manuais"""
     if not manual_input or not manual_input.strip():
         return []
     
     manual_ranges = []
-    normalized = manual_input.replace(",", "\n")
-    lines = [l.strip() for l in normalized.splitlines() if l.strip()]
+    lines = manual_input.replace(",", "\n").splitlines()
     
-    pat = re.compile(r'(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*[-–—]\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})')
+    pattern = re.compile(r'(\d{2}:\d{2}:\d{2}[:;]\d{2})\s*[-–—]\s*(\d{2}:\d{2}:\d{2}[:;]\d{2})')
     
     for line in lines:
-        m = pat.search(line)
+        m = pattern.search(line.strip())
         if m:
-            start_tc, end_tc = m.groups()
-            manual_ranges.append((start_tc, end_tc))
+            manual_ranges.append((m.group(1), m.group(2)))
     
     return manual_ranges
 
-# ============ AI HELPER FUNCTIONS ============
-def extract_duration_and_keywords(instructions: str) -> Tuple[Optional[float], List[str]]:
-    """Extrai duração e palavras-chave das instruções"""
-    instructions_lower = instructions.lower()
+# ============ AI HELPERS ============
+def extract_duration_minutes(text: str) -> Optional[float]:
+    """Extrai duração em minutos"""
+    text_lower = text.lower()
     
-    # Extrai duração
-    duration = None
-    duration_patterns = [
+    patterns = [
         r'(\d+)\s*minutos?',
         r'(\d+)\s*min\b',
         r'(\d+)m\b',
         r'corte\s+de\s+(\d+)'
     ]
     
-    for pattern in duration_patterns:
-        match = re.search(pattern, instructions_lower)
+    for pattern in patterns:
+        match = re.search(pattern, text_lower)
         if match:
-            duration = float(match.group(1))
-            print(f"✓ Duração extraída: {duration} minutos")
-            break
-    
-    # Extrai palavras-chave importantes
-    keywords = []
-    
-    topic_keywords = {
-        'tenista': ['tenista', 'tênis', 'jogador', 'kinguios'],
-        'maria': ['maria', 'josé', 'casal', 'seguro', 'carro'],
-        'protocolo': ['protocolo', 'rodar', 'dependência'],
-        'emoção': ['medo', 'culpa', 'raiva', 'emoção'],
-        'negócio': ['empresa', 'negócio', 'faturamento', 'dinheiro'],
-    }
-    
-    for key, terms in topic_keywords.items():
-        if any(term in instructions_lower for term in terms):
-            keywords.append(key)
+            return float(match.group(1))
     
-    print(f"✓ Keywords encontradas: {keywords}")
-    return duration, keywords
+    return None
 
-def find_segment_by_content(segs: List[Segment], keywords: List[str]) -> int:
-    """Encontra o índice do segmento que melhor corresponde às palavras-chave"""
+def find_keyword_in_segments(segs: List[Segment], keywords: List[str]) -> int:
+    """Busca simples por palavras-chave"""
     if not keywords:
         return 0
     
@@ -177,494 +152,373 @@ def find_segment_by_content(segs: List[Segment], keywords: List[str]) -> int:
     
     for idx, seg in enumerate(segs):
         text_lower = seg.text.lower()
-        score = sum(1 for kw in keywords if kw in text_lower)
+        score = sum(1 for kw in keywords if kw.lower() in text_lower)
         
         if score > best_score:
             best_score = score
             best_idx = idx
     
-    print(f"✓ Melhor match no segmento {best_idx} (score: {best_score})")
     return best_idx
 
-def ai_find_start_point(segs: List[Segment], instructions: str, keywords: List[str]) -> int:
-    """Usa IA para encontrar ponto de início"""
-    if not LLM_AVAILABLE:
-        print("⚠ IA não disponível, usando busca por keywords")
-        return find_segment_by_content(segs, keywords)
-    
-    # Cria resumo dos primeiros 150 segmentos
-    segments_preview = []
-    for i, s in enumerate(segs[:150]):
-        duration = (s.end_f - s.start_f) / FPS
-        segments_preview.append(
-            f"{i}. [{s.start_tc}] ({duration:.1f}s) {s.text[:80]}"
-        )
-    
-    prompt = f"""Você é um editor de vídeo. Encontre o índice do segmento onde deve COMEÇAR o corte.
-
-INSTRUÇÕES DO USUÁRIO:
-{instructions}
-
-SEGMENTOS DISPONÍVEIS:
-{chr(10).join(segments_preview)}
-
-IMPORTANTE:
-- Analise onde está o conteúdo solicitado
-- Retorne APENAS o número do índice (exemplo: 87)
-- Considere o contexto e o início da história relevante
-
-RESPONDA APENAS COM O NÚMERO:"""
-
-    try:
-        print("🤖 Consultando IA...")
-        response = LLM.generate_content(prompt, generation_config={
-            "temperature": 0.1,
-            "max_output_tokens": 50
-        })
-        
-        text = (response.text or "").strip()
-        print(f"IA respondeu: {text}")
-        
-        match = re.search(r'\b(\d+)\b', text)
-        
-        if match:
-            idx = int(match.group(1))
-            if 0 <= idx < len(segs):
-                print(f"✓ IA encontrou início no segmento {idx}: {segs[idx].start_tc}")
-                return idx
-    
-    except Exception as e:
-        print(f"⚠ Erro na IA: {e}")
-    
-    # Fallback
-    fallback_idx = find_segment_by_content(segs, keywords)
-    print(f"✓ Usando fallback no segmento {fallback_idx}")
-    return fallback_idx
-
-def create_continuous_cut(segs: List[Segment], start_idx: int, duration_minutes: float) -> List[Segment]:
-    """Cria um corte contínuo"""
+def create_continuous_segment(segs: List[Segment], start_idx: int, duration_min: float) -> Segment:
+    """Cria um segmento contínuo"""
     if start_idx >= len(segs):
         start_idx = 0
     
-    target_frames = int(duration_minutes * 60 * FPS)
-    
     start_seg = segs[start_idx]
     start_frame = start_seg.start_f
-    end_frame = start_frame + target_frames
-    
-    # Garante que não ultrapassa o último segmento
-    max_frame = segs[-1].end_f
-    if end_frame > max_frame:
-        end_frame = max_frame
-        actual_duration = (end_frame - start_frame) / FPS / 60
-        print(f"⚠ Ajustado para {actual_duration:.1f} min (limite da transcrição)")
-    
-    # Cria texto combinado
-    involved_segs = []
-    for seg in segs[start_idx:]:
-        if seg.start_f < end_frame:
-            involved_segs.append(seg)
-        else:
-            break
-    
-    combined_text = " ".join([s.text[:100] for s in involved_segs[:10]])
-    
-    result = Segment(
+    duration_frames = int(duration_min * 60 * FPS)
+    end_frame = start_frame + duration_frames
+    
+    # Pega texto dos primeiros segmentos
+    text_parts = []
+    for seg in segs[start_idx:min(start_idx+10, len(segs))]:
+        text_parts.append(seg.text[:80])
+    
+    combined_text = " ".join(text_parts)[:300]
+    
+    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=f"Corte contínuo ({duration_minutes}min): {combined_text[:200]}...",
+        text=f"Corte contínuo ({duration_min}min): {combined_text}",
         score=100.0
     )
-    
-    print(f"✓ Corte criado: {result.start_tc} → {result.end_tc}")
-    return [result]
 
-def ai_select_segments(segs: List[Segment], instructions: str) -> List[Segment]:
-    """Processa instruções em linguagem natural"""
-    if not segs:
-        raise ValueError("Nenhum segmento disponível")
+def process_with_ai(segs: List[Segment], instructions: str) -> List[Segment]:
+    """Processa com IA"""
     
-    print(f"📝 Processando instruções: {instructions[:100]}...")
+    # Extrai duração
+    duration = extract_duration_minutes(instructions)
     
-    # Extrai duração e palavras-chave
-    duration, keywords = extract_duration_and_keywords(instructions)
+    # Identifica palavras-chave importantes
+    keywords = []
+    text_lower = instructions.lower()
     
-    if duration:
-        # Modo: corte contínuo de X minutos
-        print(f"Modo: CORTE CONTÍNUO de {duration} minutos")
-        start_idx = ai_find_start_point(segs, instructions, keywords)
-        result = create_continuous_cut(segs, start_idx, duration)
-        return result
+    keyword_map = {
+        'tenista': ['tenista', 'tênis', 'tenis', 'jogador', 'kinguios'],
+        'maria': ['maria', 'josé', 'jose', 'casal', 'seguro'],
+        'protocolo': ['protocolo', 'rodar', 'dependência', 'dependencia'],
+    }
     
-    else:
-        # Modo: seleção múltipla (fallback)
-        print("⚠ Duração não especificada, usando modo de seleção múltipla")
-        start_idx = ai_find_start_point(segs, instructions, keywords)
-        selected = segs[start_idx:start_idx + 10]
-        
-        if not selected:
-            selected = segs[:10]
-        
-        return selected
+    for key, terms in keyword_map.items():
+        if any(term in text_lower for term in terms):
+            keywords.extend(terms)
+    
+    print(f"📊 Duração: {duration}min | Keywords: {keywords[:3]}")
+    
+    # Encontra ponto de início
+    start_idx = 0
+    
+    if LLM_AVAILABLE and keywords:
+        try:
+            # Cria preview dos segmentos
+            preview = []
+            for i, s in enumerate(segs[:100]):
+                preview.append(f"{i}|{s.start_tc}|{s.text[:60]}")
+            
+            preview_text = "\n".join(preview[:80])
+            
+            prompt = f"""Encontre o índice onde começa o assunto solicitado.
+
+BUSCAR: {' '.join(keywords[:3])}
+
+SEGMENTOS (formato: índice|timecode|texto):
+{preview_text}
 
-# ============ KEYWORD SCORING ============
-def keyword_score(text: str, custom_keywords: str = "", weights: dict = None) -> float:
-    """Pontuação por palavras-chave"""
-    if weights is None:
-        weights = {"emotion": 2.0, "break": 1.5, "learn": 1.2, "viral": 1.0}
-    
-    t = text.lower()
-    score = 0.0
-    
-    kw_emotion = ["medo", "coragem", "raiva", "chorei", "feliz", "triste"]
-    kw_break = ["nunca", "de repente", "contraintuitivo", "virada"]
-    kw_learn = ["aprendi", "descobri", "lição", "entendi"]
-    kw_viral = ["segredo", "verdade", "3 passos"]
-    
-    for kw in kw_emotion:
-        if kw in t:
-            score += weights["emotion"]
-    for kw in kw_break:
-        if kw in t:
-            score += weights["break"]
-    for kw in kw_learn:
-        if kw in t:
-            score += weights["learn"]
-    for kw in kw_viral:
-        if kw in t:
-            score += weights["viral"]
-    
-    if custom_keywords.strip():
-        for kw in custom_keywords.split(","):
-            kw = kw.strip().lower()
-            if kw and kw in t:
-                score += 3.0
-    
-    return score
+Retorne APENAS o número do índice (exemplo: 42)"""
+
+            response = LLM.generate_content(
+                prompt,
+                generation_config={"temperature": 0.1, "max_output_tokens": 20}
+            )
+            
+            text = (response.text or "").strip()
+            match = re.search(r'\b(\d+)\b', text)
+            
+            if match:
+                idx = int(match.group(1))
+                if 0 <= idx < len(segs):
+                    start_idx = idx
+                    print(f"✅ IA encontrou: segmento {start_idx} ({segs[start_idx].start_tc})")
+        
+        except Exception as e:
+            print(f"⚠️ IA falhou: {e}")
+    
+    # Fallback: busca por keywords
+    if start_idx == 0 and keywords:
+        start_idx = find_keyword_in_segments(segs, keywords)
+        print(f"✅ Busca por keyword: segmento {start_idx} ({segs[start_idx].start_tc})")
+    
+    # Cria corte
+    if duration:
+        result = create_continuous_segment(segs, start_idx, duration)
+        print(f"✅ Corte: {result.start_tc} → {result.end_tc} ({duration}min)")
+        return [result]
+    else:
+        # Sem duração: retorna múltiplos segmentos
+        return segs[start_idx:start_idx+10]
 
-# ============ MAIN SELECTION LOGIC ============
-def select_segments(transcript_txt: str, use_llm: bool, num_segments: int, 
+# ============ MAIN SELECTION ============
+def select_segments(transcript_txt: str, use_llm: bool, num_segments: int,
                    custom_keywords: str, manual_timecodes: str, natural_instructions: str,
-                   weight_emotion: float, weight_break: float, 
+                   weight_emotion: float, weight_break: float,
                    weight_learn: float, weight_viral: float) -> List[Segment]:
-    """Função principal de seleção"""
-    
-    print("\n" + "="*60)
-    print("INICIANDO SELEÇÃO DE SEGMENTOS")
-    print("="*60)
-    
-    # Prioridade 1: Timecodes manuais
-    manual_ranges = parse_manual_timecodes(manual_timecodes)
-    if manual_ranges:
-        print(f"✓ Modo: MANUAL - {len(manual_ranges)} ranges")
-        result_segs = []
-        for start_tc, end_tc in manual_ranges:
+    
+    # Prioridade 1: Manual
+    manual = parse_manual_timecodes(manual_timecodes)
+    if manual:
+        print(f"🔧 Modo MANUAL: {len(manual)} cortes")
+        result = []
+        for start_tc, end_tc in manual:
             try:
-                start_f = parse_timecode_to_frames(start_tc)
-                end_f = parse_timecode_to_frames(end_tc)
-                if end_f > start_f:
-                    result_segs.append(Segment(
-                        start_tc=start_tc,
-                        end_tc=end_tc,
-                        start_f=start_f,
-                        end_f=end_f,
-                        text=f"Corte manual: {start_tc} - {end_tc}",
-                        score=100.0
-                    ))
-            except Exception as e:
-                print(f"⚠ Erro: {e}")
-        return result_segs if result_segs else []
+                result.append(Segment(
+                    start_tc=start_tc,
+                    end_tc=end_tc,
+                    start_f=parse_timecode_to_frames(start_tc),
+                    end_f=parse_timecode_to_frames(end_tc),
+                    text=f"Manual: {start_tc}-{end_tc}",
+                    score=100.0
+                ))
+            except:
+                pass
+        return result
     
     # Parse transcrição
-    segs = parse_transcript_full(transcript_txt)
+    segs = parse_transcript(transcript_txt)
     
     if not segs:
-        raise ValueError("Nenhum segmento válido encontrado. Formato esperado: 00:00:00:00 - 00:00:10:00 Texto")
+        raise ValueError("❌ Nenhum segmento encontrado. Formato esperado: 00:00:00:00 - 00:00:10:00 Texto")
     
-    # Prioridade 2: Instruções em linguagem natural
-    if natural_instructions.strip():
-        print(f"✓ Modo: LINGUAGEM NATURAL")
-        print(f"   Instruções: {natural_instructions[:100]}...")
-        print(f"   IA disponível: {LLM_AVAILABLE}")
-        
-        # Funciona mesmo sem IA, usando keywords
-        return ai_select_segments(segs, natural_instructions)
-    
-    # Prioridade 3: Modo automático com pontuação
-    print(f"✓ Modo: AUTOMÁTICO por pontuação")
-    weights = {
-        "emotion": weight_emotion,
-        "break": weight_break,
-        "learn": weight_learn,
-        "viral": weight_viral
-    }
+    # Prioridade 2: IA com linguagem natural
+    if natural_instructions.strip() and use_llm:
+        print("🤖 Modo IA")
+        return process_with_ai(segs, natural_instructions)
+    
+    # Prioridade 3: Automático por score
+    print("⚙️ Modo AUTOMÁTICO")
     
     for s in segs:
-        s.score = keyword_score(s.text, custom_keywords, weights)
+        score = 0
+        text = s.text.lower()
+        
+        if "medo" in text or "coragem" in text:
+            score += weight_emotion
+        if "nunca" in text or "de repente" in text:
+            score += weight_break
+        if "aprendi" in text or "descobri" in text:
+            score += weight_learn
+        if "segredo" in text or "verdade" in text:
+            score += weight_viral
+        
+        if custom_keywords:
+            for kw in custom_keywords.split(","):
+                if kw.strip().lower() in text:
+                    score += 3.0
+        
+        s.score = score
     
     segs.sort(key=lambda x: x.score, reverse=True)
     return segs[:num_segments]
 
 # ============ XML EDITING ============
-def edit_sequence_with_segments(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
-    """Edita a sequência do XML com os segmentos"""
+def deep_copy_element(elem: ET.Element) -> ET.Element:
+    new = ET.Element(elem.tag, attrib=dict(elem.attrib))
+    new.text = elem.text
+    new.tail = elem.tail
+    for child in elem:
+        new.append(deep_copy_element(child))
+    return new
+
+def edit_xml(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
     root = tree.getroot()
     seq = root.find(".//sequence")
     
     if seq is None:
-        raise ValueError("Nenhuma <sequence> encontrada no XML")
+        raise ValueError("Sequence não encontrada no XML")
     
-    video_track = seq.find("./media/video/track")
-    audio_track = seq.find("./media/audio/track")
+    v_track = seq.find(".//media/video/track")
+    a_track = seq.find(".//media/audio/track")
     
-    if not video_track or not audio_track:
-        raise ValueError("Estrutura de trilhas não encontrada no XML")
+    if not v_track or not a_track:
+        raise ValueError("Trilhas de vídeo/áudio não encontradas")
     
-    v_tpl = video_track.find("./clipitem")
-    a_tpl = audio_track.find("./clipitem")
+    v_template = v_track.find("./clipitem")
+    a_template = a_track.find("./clipitem")
     
-    if v_tpl is None or a_tpl is None:
-        raise ValueError("Clipitem template não encontrado")
-    
-    def deep_copy(elem):
-        new = ET.Element(elem.tag, attrib=elem.attrib)
-        new.text = elem.text
-        new.tail = elem.tail
-        for child in list(elem):
-            new.append(deep_copy(child))
-        return new
-    
-    # Limpa trilhas
-    for ci in list(video_track.findall("./clipitem")):
-        video_track.remove(ci)
-    for ci in list(audio_track.findall("./clipitem")):
-        audio_track.remove(ci)
+    # Limpa clips existentes
+    for clip in list(v_track.findall("./clipitem")):
+        v_track.remove(clip)
+    for clip in list(a_track.findall("./clipitem")):
+        a_track.remove(clip)
     
     # Adiciona novos clips
-    cursor = 0
+    timeline_pos = 0
     
-    for idx, seg in enumerate(segs, start=1):
+    for i, seg in enumerate(segs, 1):
         duration = seg.end_f - seg.start_f
-        start = cursor
-        end = cursor + duration
-        
-        v_id = f"clip-v-{idx}"
-        a_id = f"clip-a-{idx}"
-        
-        # Video clip
-        v_ci = ET.Element("clipitem", {"id": v_id})
-        v_name = ET.SubElement(v_ci, "name")
-        v_name.text = f"Clip {idx}"
-        
-        v_rate = deep_copy(v_tpl.find("rate"))
-        v_ci.append(v_rate)
-        
-        ET.SubElement(v_ci, "start").text = str(start)
-        ET.SubElement(v_ci, "end").text = str(end)
-        ET.SubElement(v_ci, "in").text = str(seg.start_f)
-        ET.SubElement(v_ci, "out").text = str(seg.end_f)
-        
-        v_file = deep_copy(v_tpl.find("./file"))
-        if v_file is not None:
-            v_ci.append(v_file)
-        
-        v_link = ET.SubElement(v_ci, "link")
-        ET.SubElement(v_link, "linkclipref").text = a_id
-        
-        # Audio clip
-        a_ci = ET.Element("clipitem", {"id": a_id})
-        a_name = ET.SubElement(a_ci, "name")
-        a_name.text = f"Clip {idx}"
         
-        a_rate = deep_copy(a_tpl.find("rate"))
-        a_ci.append(a_rate)
-        
-        ET.SubElement(a_ci, "start").text = str(start)
-        ET.SubElement(a_ci, "end").text = str(end)
-        ET.SubElement(a_ci, "in").text = str(seg.start_f)
-        ET.SubElement(a_ci, "out").text = str(seg.end_f)
-        
-        a_file = deep_copy(a_tpl.find("./file"))
-        if a_file is not None:
-            a_ci.append(a_file)
-        
-        a_link = ET.SubElement(a_ci, "link")
-        ET.SubElement(a_link, "linkclipref").text = v_id
-        
-        video_track.append(v_ci)
-        audio_track.append(a_ci)
-        
-        cursor = end
+        # Vídeo clip
+        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)
+        ET.SubElement(v_clip, "end").text = str(timeline_pos + duration)
+        ET.SubElement(v_clip, "in").text = str(seg.start_f)
+        ET.SubElement(v_clip, "out").text = str(seg.end_f)
+        
+        if v_template is not None:
+            rate = v_template.find("rate")
+            if rate is not None:
+                v_clip.append(deep_copy_element(rate))
+            file_elem = v_template.find("file")
+            if file_elem is not None:
+                v_clip.append(deep_copy_element(file_elem))
+        
+        # Áudio clip
+        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)
+        ET.SubElement(a_clip, "end").text = str(timeline_pos + duration)
+        ET.SubElement(a_clip, "in").text = str(seg.start_f)
+        ET.SubElement(a_clip, "out").text = str(seg.end_f)
+        
+        if a_template is not None:
+            rate = a_template.find("rate")
+            if rate is not None:
+                a_clip.append(deep_copy_element(rate))
+            file_elem = a_template.find("file")
+            if file_elem is not None:
+                a_clip.append(deep_copy_element(file_elem))
+        
+        v_track.append(v_clip)
+        a_track.append(a_clip)
+        
+        timeline_pos += duration
     
     return tree
 
-# ============ GRADIO INTERFACE ============
-def process_xml_and_transcript(xml_file, txt_file, use_llm, num_segments, 
-                               custom_keywords, manual_timecodes, natural_instructions,
-                               weight_emotion, weight_break, weight_learn, weight_viral):
-    """Processa XML e transcrição"""
+# ============ GRADIO ============
+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):
     
     if not xml_file:
-        return "❌ Envie o arquivo XML do Premiere", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-    
-    manual_ranges = parse_manual_timecodes(manual_timecodes)
-    has_instructions = natural_instructions.strip() != ""
+        return "❌ Envie o XML", None, f"LLM: {LLM_AVAILABLE}"
     
-    # Determina modo
-    if manual_ranges:
-        mode = "MANUAL"
+    try:
+        # Lê transcrição se necessário
         transcript = ""
-    elif has_instructions:
-        mode = "IA (Linguagem Natural)" if (use_llm and LLM_AVAILABLE) else "Linguagem Natural (sem IA)"
-        if not txt_file:
-            return "❌ Para usar linguagem natural, envie a transcrição (.txt)", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
+        manual = parse_manual_timecodes(manual_timecodes)
         
-        with open(txt_file.name, "r", encoding="utf-8") as f:
-            transcript = f.read()
-    else:
-        mode = "AUTOMÁTICO"
-        if not txt_file:
-            return "❌ Envie a transcrição (.txt)", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
+        if not manual:
+            if not txt_file:
+                return "❌ Envie a transcrição (.txt)", None, f"LLM: {LLM_AVAILABLE}"
+            
+            with open(txt_file.name, "r", encoding="utf-8") as f:
+                transcript = f.read()
         
-        with open(txt_file.name, "r", encoding="utf-8") as f:
-            transcript = f.read()
-    
-    try:
         # Seleciona segmentos
-        segs = select_segments(
+        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
         )
         
-        if not segs:
-            return "❌ Nenhum segmento foi selecionado", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
+        if not segments:
+            return "❌ Nenhum segmento selecionado", None, f"LLM: {LLM_AVAILABLE}"
         
         # Edita XML
         tree = ET.parse(xml_file.name)
-        tree = edit_sequence_with_segments(tree, segs)
-        
-        # Salva resultado
-        base = os.path.splitext(os.path.basename(xml_file.name))[0]
-        out_path = os.path.join(OUTPUT_DIR, f"{base}_EDITADO.xml")
-        tree.write(out_path, encoding="utf-8", xml_declaration=True)
+        tree = edit_xml(tree, segments)
         
-        # Gera resumo
-        total_duration = sum((s.end_f - s.start_f) / FPS for s in segs)
+        # Salva
+        basename = os.path.splitext(os.path.basename(xml_file.name))[0]
+        output = os.path.join(OUTPUT_DIR, f"{basename}_EDITADO.xml")
+        tree.write(output, encoding="utf-8", xml_declaration=True)
         
-        resumo = f"✅ {len(segs)} corte(s) criado(s) | Duração total: {total_duration/60:.1f} min | Modo: {mode}\n\n"
+        # Resumo
+        total_sec = sum((s.end_f - s.start_f) / FPS for s in segments)
+        total_min = total_sec / 60
         
-        for i, s in enumerate(segs, 1):
-            dur = (s.end_f - s.start_f) / FPS
-            resumo += f"{i}. {s.start_tc} → {s.end_tc} ({dur/60:.1f} min / {dur:.0f}s)\n"
-            if s.text and not manual_ranges:
-                resumo += f"   {s.text[:150]}\n"
-            resumo += "\n"
+        mode = "MANUAL" if manual else ("IA" if natural_instructions.strip() else "AUTOMÁTICO")
         
-        status = f"✅ Sucesso! | Modo: {mode} | Duração: {total_duration/60:.1f} min | LLM: {'✓' if LLM_AVAILABLE else '✗'}"
+        summary = f"✅ {len(segments)} corte(s) | {total_min:.1f} min total | Modo: {mode}\n\n"
         
-        print(f"\n{status}\n")
+        for i, seg in enumerate(segments, 1):
+            dur_sec = (seg.end_f - seg.start_f) / FPS
+            summary += f"{i}. {seg.start_tc} → {seg.end_tc} ({dur_sec/60:.1f}min)\n"
+            if seg.text and len(seg.text) > 50:
+                summary += f"   {seg.text[:120]}...\n"
+            summary += "\n"
         
-        return resumo, out_path, status
+        status = f"✅ Sucesso | {mode} | {total_min:.1f}min | LLM: {LLM_AVAILABLE}"
         
+        return summary, output, status
+    
     except Exception as e:
         import traceback
-        error_detail = traceback.format_exc()
-        print(f"\n❌ ERRO:\n{error_detail}\n")
-        return f"❌ Erro: {str(e)}\n\nDetalhes no console", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
+        traceback.print_exc()
+        return f"❌ Erro: {str(e)}", None, f"LLM: {LLM_AVAILABLE}"
 
-# ============ CSS & GRADIO APP ============
-css = """
-:root { --primary: #39FF14; --text: #1a1a1a; --muted: #6b7280; }
-.gradio-container { font-family: 'Inter', system-ui, sans-serif !important; }
-.gradio-container h1, .gradio-container label { color: var(--text) !important; font-weight: 600 !important; }
-.gradio-container button.primary { 
-    background: var(--primary) !important; 
-    color: #000 !important; 
-    font-weight: 700 !important;
-    border-radius: 8px !important;
-}
-.gradio-container .block { border-radius: 12px !important; }
-"""
-
-with gr.Blocks(theme=gr.themes.Soft(), css=css, title="Editor XML Premiere") as demo:
+# ============ UI ============
+with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere") as demo:
     gr.Markdown("# 🎬 Editor XML Premiere - IA")
-    gr.Markdown("Cortes inteligentes com linguagem natural | Powered by Gemini AI")
+    gr.Markdown("Cortes inteligentes com linguagem natural")
     
     with gr.Row():
-        with gr.Column():
-            xml_in = gr.File(label="📁 XML do Premiere (FCP XML)", file_types=[".xml"])
-            txt_in = gr.File(label="📄 Transcrição com timecodes (.txt)", file_types=[".txt"])
-        
-        with gr.Column():
-            use_llm = gr.Checkbox(
-                label="🤖 Usar IA (Gemini)", 
-                value=USE_LLM_DEFAULT and LLM_AVAILABLE,
-                info="Requer GEMINI_API_KEY configurada" if not LLM_AVAILABLE else "IA configurada ✓"
-            )
-            num_segments = gr.Slider(
-                2, 20, 5, step=1,
-                label="Número de segmentos (modo automático)"
-            )
+        xml_in = gr.File(label="📁 XML do Premiere", file_types=[".xml"])
+        txt_in = gr.File(label="📄 Transcrição (.txt)", file_types=[".txt"])
     
-    with gr.Accordion("💬 IA - Linguagem Natural (RECOMENDADO)", open=True):
+    with gr.Row():
+        use_llm = gr.Checkbox(label="🤖 Usar IA", value=USE_LLM_DEFAULT and LLM_AVAILABLE)
+        num_segments = gr.Slider(2, 20, 5, 1, label="Segmentos (automático)")
+    
+    with gr.Accordion("💬 IA - Linguagem Natural", open=True):
         gr.Markdown("""
-**Exemplos de comandos que funcionam:**
+**Exemplos:**
 - `Extraia um corte de 10 minutos começando da parte do tenista`
-- `Crie um corte de 15 minutos com os melhores momentos`
-- `Faça um corte de 5 minutos sobre Maria e José`
-- `Corte de 8 minutos a partir de onde fala sobre protocolo`
-
-**IMPORTANTE:** Sempre especifique a duração desejada (ex: "10 minutos")
+- `Crie 15 minutos com os melhores momentos`
+- `5 minutos sobre Maria e José`
         """)
         natural_instructions = gr.Textbox(
             label="Suas instruções",
-            placeholder='Ex: "Extraia um corte de 10 minutos começando da parte do tenista"',
-            lines=3
+            placeholder='Ex: "10 minutos começando da parte do tenista"',
+            lines=2
         )
     
     with gr.Accordion("⏱️ Minutagens Manuais", open=False):
-        gr.Markdown("**Formato:** `00:01:23:15 - 00:02:45:10` (um por linha)")
         manual_timecodes = gr.Textbox(
-            label="Timecodes exatos",
-            placeholder="00:01:23:15 - 00:02:45:10\n00:05:30:00 - 00:07:15:22",
-            lines=4
+            label="Timecodes (um por linha)",
+            placeholder="00:21:18:09 - 00:31:18:09",
+            lines=3
         )
     
-    with gr.Accordion("⚙️ Modo Automático (Palavras-chave)", open=False):
-        custom_keywords = gr.Textbox(
-            label="Palavras-chave personalizadas (separadas por vírgula)",
-            placeholder="transformação, resultado, superação"
-        )
+    with gr.Accordion("⚙️ Modo Automático", open=False):
+        custom_keywords = gr.Textbox(label="Palavras-chave")
         with gr.Row():
-            weight_emotion = gr.Slider(0, 5, 2.0, 0.1, label="Peso: Emoção")
-            weight_break = gr.Slider(0, 5, 1.5, 0.1, label="Peso: Quebra")
+            weight_emotion = gr.Slider(0, 5, 2.0, 0.1, label="Emoção")
+            weight_break = gr.Slider(0, 5, 1.5, 0.1, label="Quebra")
         with gr.Row():
-            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")
+            weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="Aprendizado")
+            weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="Viral")
     
-    run_btn = gr.Button("🚀 Processar e Gerar XML Editado", variant="primary", size="lg")
-    
-    gr.Markdown("---")
+    btn = gr.Button("🚀 Processar", variant="primary", size="lg")
     
     with gr.Row():
         with gr.Column(scale=2):
-            resumo_out = gr.Textbox(label="📊 Resumo dos Cortes", lines=15, show_copy_button=True)
+            summary_out = gr.Textbox(label="📊 Resumo", lines=12)
         with gr.Column(scale=1):
             status_out = gr.Textbox(label="Status")
-            file_out = gr.File(label="⬇️ Download do XML Editado")
-    
-    run_btn.click(
-        process_xml_and_transcript,
-        inputs=[xml_in, txt_in, use_llm, num_segments, custom_keywords,
-                manual_timecodes, natural_instructions,
-                weight_emotion, weight_break, weight_learn, weight_viral],
-        outputs=[resumo_out, file_out, status_out]
+            file_out = gr.File(label="⬇️ Download")
+    
+    btn.click(
+        process_files,
+        [xml_in, txt_in, use_llm, num_segments, custom_keywords,
+         manual_timecodes, natural_instructions,
+         weight_emotion, weight_break, weight_learn, weight_viral],
+        [summary_out, file_out, status_out]
     )
-    
-    gr.Markdown("""
-    ---
-    **💡 Dicas:**
-    - Formato da transcrição: `00:00:00:00 - 00
+
+if __name__ == "__main__":
+    demo.launch()