Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

import os import time import threading import random import subprocess import string…

  1. User

    import os import time import threading import random import subprocess import string import re import shutil import pickle import sqlite3 from datetime import datetime, timedelta, timezone from tkinter import ( Tk, Frame, Button, Text, Entry, Label, messagebox, END, Scrollbar, filedialog, simpledialog, Listbox, VERTICAL, SINGLE, RIGHT, Y, LEFT, BOTH, StringVar, OptionMenu, scrolledtext, Toplevel ) import tkinter as tk from tkinter import LabelFrame from tkinter.ttk import Notebook, Progressbar, Combobox, Style import pyperclip import cv2 from pydub import AudioSegment from pydub.silence import detect_nonsilent import numpy as np from googleapiclient.discovery import build from googleapiclient.http import MediaFileUpload import pytz

    CONSTANTES E PASTAS

    PASTA_CATEGORIAS = r"C:\Users\jonathan\Desktop\AUTLAND\CATEGORIAS DE IMAGENS VIDEO" AUDIO_FUNDO = r"C:\Users\jonathan\Desktop\AUTLAND\TRILHA SONORA\soundfund.mp3" PASTA_DESTINO_VIDEOS = r"C:\Users\jonathan\Desktop\FINANCE CHANEEL\VIDEO PARA POSTAR PRONTOS" PASTA_TRUMP_AUDIOS = r"C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS TRUMP" PASTA_WARREN_AUDIOS = r"C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS WARREN" PASTA_TRUMP_IMAGENS = r"C:\Users\jonathan\Desktop\AUTLAND\CATEGORIAS DE IMAGENS VIDEO\TRUMP" PASTA_WARREN_IMAGENS = r"C:\Users\jonathan\Desktop\AUTLAND\CATEGORIAS DE IMAGENS VIDEO\WARREN" PASTA_TRUMP_DESTINO = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO TRUMP" PASTA_WARREN_DESTINO = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO WARREN"

    DOWNLOADS_FOLDER = r'C:\Users\jonathan\Downloads' OUTPUT_WARREN = r'C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS WARREN' OUTPUT_TRUMP = r'C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS TRUMP'

    DB_PATH = r"C:\Users\jonathan\Desktop\FINANCE CHANEEL\monitorador_juntador.db" HORARIOS_DIA = [5, 6, 7, 8]

    DEFAULT_DESCRIPTION = """ In this video, we reveal the shocking truth behind Warren Buffett’s boldest move ever — and what it could mean for the future of the market. Is a crash on the horizon? Don’t miss these crucial insights! ⏱️ Chapters 0:00 - Introduction 0:45 - What Just Happened 2:10 - Deep Dive into the Situation 3:00 - Final Thoughts and Predictions 8:45 - Outro

    📢 Subscribe now for more eye-opening financial insights! #finance #investing #stockmarket #breakingnews #wealth """

    DEFAULT_TAGS = [ "Warren Buffett sells biggest stock", "Buffett stock sale 2025", "Wall Street reaction Buffett", "Warren Buffett stock market news", "Buffett biggest investment sold", "Buffett stock dump explained", "Warren Buffett investing", "stock market news 2025", "Buffett sell off impact", "Warren Buffett market strategy", "investment advice Buffett", "Buffett latest moves", "Wall Street freak out Buffett", "trump", "trump tarrifs" ]

    MONITOR_PASTA_TRUMP = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO TRUMP" MONITOR_PASTA_WARREN = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO WARREN"

    THUMB_TRUMP_FOLDER = r"C:\Users\jonathan\Desktop\AUTLAND\THUMBNAILS\TUMB TRUMP" THUMB_WARREN_FOLDER = r"C:\Users\jonathan\Desktop\AUTLAND\THUMBNAILS\TUMB WARREN"

    Helper para limpar nomes de arquivos

    def limpar_nome(texto): return re.sub(r'[/*?:"<>|]', "", texto.strip())

    class MainApp: COR_FUNDO = "#000000" COR_TEXTO = "#FFFFFF" COR_BOTAO = "#00FF00" COR_BOTAO_HOVER = "#00CC00" COR_TEXTO_BOTAO = "#FFFFFF" FONT_TITULO = ("Segoe UI Semibold", 14) FONT_DEFAULT = ("Segoe UI", 11) FONT_LOG = ("Consolas", 11)

    def __init__(self, root):
        self.root = root
        root.title("Sistema Integrado - Criador, Editor, Monitor e Agendador")
        root.geometry("1920x1080")
        root.configure(bg=self.COR_FUNDO)
        root.state('zoomed')  # maximiza a janela
    
        style = Style()
        style.theme_use('default')
        style.configure('TNotebook', background=self.COR_FUNDO, borderwidth=0)
        style.configure('TNotebook.Tab', background="#003300", foreground=self.COR_TEXTO,
                        font=("Segoe UI Semibold", 11))
        style.map('TNotebook.Tab', background=[('selected', '#00FF00')], foreground=[('selected', '#000000')])
    
        # Layout: Usaremos 1 Frame principal com 3 grandes áreas verticais:
        self.main_frame = Frame(root, bg=self.COR_FUNDO)
        self.main_frame.pack(expand=True, fill=BOTH)
    
        # Frame topo - buttons de controle rápido
        self.top_controls_frame = Frame(self.main_frame, bg=self.COR_FUNDO)
        self.top_controls_frame.pack(side='top', fill='x', padx=10, pady=5)
    
        self.master_monitor_button = Button(self.top_controls_frame, text="Ativar TODOS Monitores",
                                            bg=self.COR_BOTAO, fg=self.COR_TEXTO_BOTAO,
                                            font=self.FONT_DEFAULT, relief='flat', padx=10, pady=6,
                                            command=self.toggle_all_monitors)
        self.master_monitor_button.pack(side='left', padx=5)
    
        self.refresh_stats_button = Button(self.top_controls_frame, text="Atualizar Estatísticas",
                                           bg=self.COR_BOTAO, fg=self.COR_TEXTO_BOTAO,
                                           font=self.FONT_DEFAULT, relief='flat', padx=10, pady=6,
                                           command=self.atualizar_estatisticas)
        self.refresh_stats_button.pack(side='left', padx=5)
    
        # Frame meio - notebook para organizar seções
        self.notebook = Notebook(self.main_frame)
        self.notebook.pack(expand=True, fill='both', padx=15, pady=10)
    
        # Criar frames para cada funcionalidade e adicionar ao notebook
        self.frame_criador_enredo = CriadorEnredoFrame(self.notebook, self)
        self.frame_video_editor = VideoEditorFrame(self.notebook, self)
        self.frame_monitor_conversion = MonitorConversionFrame(self.notebook, self)
        self.frame_agendador_upload = AgendadorFrame(self.notebook, self)
    
        self.notebook.add(self.frame_criador_enredo, text="Criador de Enredo")
        self.notebook.add(self.frame_video_editor, text="Criar Vídeos")
        self.notebook.add(self.frame_monitor_conversion, text="Monitor Conversão")
        self.notebook.add(self.frame_agendador_upload, text="Agendador & Upload")
    
        # Frame lado direito flutuante - mini monitor de pastas (janela separada)
        self.mini_monitor_window = MiniMonitorWindow(self.root)
    
        # Inicializar variáveis
        self.monitors_ativos = {
            'audio_folder_monitor': False,
            'video_conversion_monitor': False,
            'youtube_upload_monitor': False,
        }
    
        self.monitor_threads = {}
        self.perfis_autorizados = {}
        self.botoes_perfis = {}
    
        # Variáveis globais para estatísticas upload
        self.enviado_por_perfil = {}
    
        # Inicializar DB
        self.init_db()
    
        # Atualizar perfis e autorizações
        self.atualizar_perfis()
        self.construir_lista_perfis_autorizados()
    
        # Ativar atualização estatísticas periódica (para janela estatísticas se estiver aberta)
        self.root.after(30000, self.periodic_estatisticas_update)  # atualiza a cada 30s
    
    # ====== Métodos para gerenciamento DB, perfis etc ======
    def init_db(self):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute('''
            CREATE TABLE IF NOT EXISTS videos (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                filename TEXT UNIQUE,
                title TEXT,
                channel TEXT,
                schedule_time TEXT
            )
        ''')
        c.execute('''
            CREATE TABLE IF NOT EXISTS perfis (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                nome TEXT UNIQUE,
                credentials BLOB,
                canal TEXT
            )
        ''')
        conn.commit()
        conn.close()
    
    def get_perfis(self):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT id, nome, canal FROM perfis")
        perfis = c.fetchall()
        conn.close()
        return perfis
    
    def add_perfil(self, nome, credentials_blob, canal):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("INSERT OR REPLACE INTO perfis (nome, credentials, canal) VALUES (?, ?, ?)", (nome, credentials_blob, canal))
        conn.commit()
        conn.close()
    
    def delete_perfil(self, nome):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("DELETE FROM perfis WHERE nome=?", (nome,))
        conn.commit()
        conn.close()
    
    def atualizar_perfis(self):
        perfis = self.get_perfis()
        self.frame_agendador_upload.atualizar_dropdown_perfis(perfis)
    
    def construir_lista_perfis_autorizados(self):
        perfis = self.get_perfis()
        for widget in self.frame_agendador_upload.frame_autorizacao.winfo_children():
            widget.destroy()
        self.botoes_perfis = {}
        self.perfis_autorizados = {}
        for p in perfis:
            nome = p[1]
            self.perfis_autorizados[nome] = False
            btn = Button(self.frame_agendador_upload.frame_autorizacao, text=nome, width=15,
                         bg="red", fg="white", relief="raised", font=self.FONT_DEFAULT)
            btn.pack(side="left", padx=3, pady=3)
            btn.config(command=lambda n=nome, b=btn: self.toggle_autorizacao(n, b))
            self.botoes_perfis[nome] = btn
    
    def toggle_autorizacao(self, nome_perfil, botao):
        atual = self.perfis_autorizados.get(nome_perfil, False)
        self.perfis_autorizados[nome_perfil] = not atual
        botao.config(bg="green" if not atual else "red")
        self.rebuild_perfis_enviar_ordenados()
    
    def rebuild_perfis_enviar_ordenados(self):
        self.perfis_enviar_ordenados = [p for p, aut in self.perfis_autorizados.items() if aut]
        self.indice_proximo_perfil = 0 if not hasattr(self, 'indice_proximo_perfil') else self.indice_proximo_perfil
        if self.indice_proximo_perfil >= len(self.perfis_enviar_ordenados):
            self.indice_proximo_perfil = 0
    
    # ====== Botão master monitor: ativa TODOS monitoramentos ======
    def toggle_all_monitors(self):
        novo_estado = not all(self.monitors_ativos.values())
        if novo_estado:
            # Ativar todos
            if not self.monitors_ativos['audio_folder_monitor']:
                self.frame_video_editor.toggle_monitoring(force_state=True)
            if not self.monitors_ativos['video_conversion_monitor']:
                self.frame_monitor_conversion.toggle_monitoring(force_state=True)
            if not self.monitors_ativos['youtube_upload_monitor']:
                self.frame_agendador_upload.toggle_monitoramento(force_state=True)
            messagebox.showinfo("Monitores", "Todos os monitores ativados.")
        else:
            # Desativar todos
            if self.monitors_ativos['audio_folder_monitor']:
                self.frame_video_editor.toggle_monitoring(force_state=False)
            if self.monitors_ativos['video_conversion_monitor']:
                self.frame_monitor_conversion.toggle_monitoring(force_state=False)
            if self.monitors_ativos['youtube_upload_monitor']:
                self.frame_agendador_upload.toggle_monitoramento(force_state=False)
            messagebox.showinfo("Monitores", "Todos os monitores desativados.")
        # Atualizar variáveis e botões
        self.monitors_ativos['audio_folder_monitor'] = self.frame_video_editor.monitoring_active
        self.monitors_ativos['video_conversion_monitor'] = self.frame_monitor_conversion.monitorando
        self.monitors_ativos['youtube_upload_monitor'] = self.frame_agendador_upload.monitorando_youtube
    
    # ====== Estatísticas e atualização periódica ======
    def atualizar_estatisticas(self):
        self.frame_agendador_upload.criar_ou_atualizar_estatisticas()
    
    def periodic_estatisticas_update(self):
        self.atualizar_estatisticas()
        # agenda próxima atualização em 30 segundos
        self.root.after(30000, self.periodic_estatisticas_update)
    
    # ====== Método para iniciar GUI ======
    def start(self):
        self.root.mainloop()
    
    ############## --- PARTES DOS FRAMES INTEGRADOS VIERAM EM SEÇÕES SEGUINTES --- #####################
    

    Reescrever função gerar_prompt para manter indentação correta

    def gerar_prompt(titulo): return f"""Agora você é um roteirista profissional de YouTube e vai criar um script sobre:{titulo}. Por favor, faça isso sem marcações de transições ou cenas, quero apenas a frase do narrador não coloque o titulo no começoapenas texto. . Introdução (300-500 palavras): Apresente o tema de forma clara e envolvente. Use uma anedota ou pergunta intrigante para capturar a atenção. Explique brevemente o que será abordado no vídeo e por que é relevante para o espectador. Desenvolvimento (2.000-2.200 palavras): Divida em seções claras e bem organizadas, cada uma abordando um ponto específico. Mantenha a fluidez e transições suaves entre as seções. Ofereça informações relevantes, dados, exemplos, e insights que agreguem valor. Faça perguntas retóricas para estimular o pensamento e a reflexão. Interação com o Público (200-300 palavras): No meio do vídeo, introduza um momento para incentivar os espectadores a se inscreverem no canal. Relacione isso ao conteúdo que está sendo apresentado. Peça para os espectadores compartilharem suas opiniões nos comentários sobre o tema abordado. Conclusão (300-500 palavras): Resuma os pontos principais discutidos no vídeo. Reforce a importância do tema e convide os espectadores a aplicarem o que aprenderam. Finalize com um convite para que assistam a outros vídeos do canal e deixem o like se gostaram do conteúdo. Dicas Adicionais: Mantenha um tom de conversa natural e envolvente. Evite longas explicações e vá direto ao ponto. Use exemplos práticos e histórias pessoais para conectar com o público. E se você quer ir além, assista esse vídeo aqui do lado que aprofunda ainda mais no passo 2 que falei aqui."O vídeo deve terminar com um gancho para outro conteúdo (evitando um final seco). Incentive a interação de forma natural. Exemplo: “Se achou isso absurdo, espere até descobrir o que acontece no Catar…” Forneça um script contendo aproximadamente 3000 palavras para um vídeo do YouTube, vou contar as palavras, então, não tente me enganar!. 2 partes de 1500 totalizando 3000 palavras. Forneça o texto em inglês, adaptando para a cultura daquele país quando necessário, deixando ele fluído e natural, adicione o título escolhido e por favor não divida o texto, quero apenas o que deve ser dito pelo narrador. É importante que seja um texto longo sobre [assunto]. Não inclua títulos, subtítulos, perguntas ou qualquer tipo de formatação extra. Quero apenas o texto bruto, sem nada além da escrita. Nada disso "Sure. Here’s Part 1 of the full script, written exactly as requested — dense, conversational, and designed for YouTube high-retention storytelling, all in English. It contains exactly 3000 words." nada disso no final. "Let me know se você quer que eu continue com a Parte 2, com mais 3000 palavras, seguindo exatamente o mesmo estilo." não pergunte e nem escreva nada no final quero que você crie algo único que nunca tenha feito ATENÇÃO QUERO SOMENTE O TEXTO NADA DE TITULO NEM SUBTITULO, NADA DE PERGUNTAS APENAS O CAMPO COM TEXTO E HISTORIA PÓS IREI COPIAR E NÃO QUERO QUE COPIE NADA ALÉM DO TEXTO. . em ingles"""

    class CriadorEnredoFrame(Frame): def init(self, parent, main_app): super().init(parent, bg=main_app.COR_FUNDO) self.main_app = main_app self.titulos = [] self.index = 0 self.titulo_atual = ""

        Label(self, text="Criador de Enredo", font=main_app.FONT_TITULO,
              bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO).pack(pady=7)
    
        Label(self, text="Cole os títulos (um por linha):",
              bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO, font=main_app.FONT_DEFAULT).pack()
        self.text_input = Text(self, height=10, width=80,
                               bg="#101010", fg=main_app.COR_TEXTO,
                               insertbackground=main_app.COR_TEXTO, font=main_app.FONT_DEFAULT)
        self.text_input.pack()
    
        btn_copiar_titulo_frame = Frame(self, bg=main_app.COR_FUNDO)
        btn_copiar_titulo_frame.pack(pady=(7, 12))
        self.btn_copiar_titulo_atual = Button(btn_copiar_titulo_frame, text="Copiar Título Atual",
                                              command=self.copiar_titulo_atual,
                                              state="disabled", bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                                              relief="flat", activebackground=main_app.COR_BOTAO_HOVER,
                                              activeforeground=main_app.COR_TEXTO_BOTAO,
                                              font=main_app.FONT_DEFAULT, padx=10, pady=5)
        self.btn_copiar_titulo_atual.pack()
    
        self.avancar_button = Button(self, text="Avançar", command=self.iniciar_prompts,
                                    bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                                    relief="flat", activebackground=main_app.COR_BOTAO_HOVER,
                                    activeforeground=main_app.COR_TEXTO_BOTAO,
                                    font=main_app.FONT_DEFAULT, padx=12, pady=6)
        self.avancar_button.pack(pady=12)
    
        self.prompt_output = Text(self, height=20, width=100, wrap="word",
                                 bg="#101010", fg=main_app.COR_TEXTO, insertbackground=main_app.COR_TEXTO,
                                 font=main_app.FONT_LOG)
        self.prompt_output.pack()
        self.prompt_output.config(state="disabled")
    
        btn_frame = Frame(self, bg=main_app.COR_FUNDO)
        btn_frame.pack(pady=8)
        Button(btn_frame, text="Copiar Prompt", command=self.copiar_prompt,
               bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO, relief="flat",
               activebackground=main_app.COR_BOTAO_HOVER, activeforeground=main_app.COR_TEXTO_BOTAO,
               font=main_app.FONT_DEFAULT, padx=10, pady=5).grid(row=0, column=0, padx=8)
        Button(btn_frame, text="Próximo", command=self.proxima_prompt,
               bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO, relief="flat",
               activebackground=main_app.COR_BOTAO_HOVER, activeforeground=main_app.COR_TEXTO_BOTAO,
               font=main_app.FONT_DEFAULT, padx=10, pady=5).grid(row=0, column=1, padx=8)
    
    def iniciar_prompts(self):
        self.titulos = [linha.strip() for linha in self.text_input.get("1.0", END).splitlines() if linha.strip()]
        self.index = 0
        if not self.titulos:
            messagebox.showerror("Erro", "Por favor, insira pelo menos um título.")
            self.btn_copiar_titulo_atual.config(state="disabled")
            return
        self.mostrar_prompt()
    
    def mostrar_prompt(self):
        if self.index < len(self.titulos):
            self.titulo_atual = self.titulos[self.index]
            self.btn_copiar_titulo_atual.config(state="normal")
            prompt = gerar_prompt(self.titulo_atual)
            self.prompt_output.config(state="normal")
            self.prompt_output.delete("1.0", END)
            self.prompt_output.insert(END, prompt)
            self.prompt_output.config(state="disabled")
        else:
            self.titulo_atual = ""
            self.btn_copiar_titulo_atual.config(state="disabled")
            self.prompt_output.config(state="normal")
            self.prompt_output.delete("1.0", END)
            self.prompt_output.insert(END, "Todos os prompts foram gerados.")
            self.prompt_output.config(state="disabled")
    
    def copiar_prompt(self):
        texto = self.prompt_output.get("1.0", END).strip()
        pyperclip.copy(texto)
        messagebox.showinfo("Copiado", "Prompt copiado para a área de transferência!")
    
    def copiar_titulo_atual(self):
        if self.titulo_atual:
            pyperclip.copy(self.titulo_atual)
            messagebox.showinfo("Copiado", f"Título '{self.titulo_atual}' copiado para a área de transferência!")
        else:
            messagebox.showwarning("Aviso", "Nenhum título para copiar.")
    
    def proxima_prompt(self):
        self.index += 1
        self.mostrar_prompt()
    

    class VideoEditorFrame(Frame): def init(self, parent, main_app): super().init(parent, bg=main_app.COR_FUNDO) self.main_app = main_app self.audio_paths = [] self.monitor = None self.monitoring_active = False

        label_style = {"bg": main_app.COR_FUNDO, "fg": main_app.COR_TEXTO, "font": main_app.FONT_DEFAULT}
        btn_style = {"bg": main_app.COR_BOTAO, "fg": main_app.COR_TEXTO_BOTAO, "activebackground": main_app.COR_BOTAO_HOVER,
                     "font": main_app.FONT_DEFAULT, "relief": "flat", "borderwidth": 0,
                     "highlightthickness": 0, "highlightbackground": main_app.COR_BOTAO,
                     "padx": 10, "pady": 6}
    
        Label(self, text="Editor Automático com OpenCV", **label_style).pack(pady=(15, 5))
    
        self.btn_select_audio = Button(self, text="Selecionar Áudios", command=self.select_audios, **btn_style)
        self.btn_select_audio.pack(pady=6)
    
        Label(self, text="Escolha a Categoria de Imagens:", **label_style).pack(pady=(15, 5))
        self.category_combo = Combobox(self, state="readonly", font=main_app.FONT_DEFAULT)
        self.category_combo.pack(pady=6)
    
        style = Style()
        style.theme_use('default')
        style.configure("TCombobox",
                        fieldbackground="#101010",
                        background="#101010",
                        foreground=main_app.COR_TEXTO,
                        arrowcolor=main_app.COR_TEXTO)
    
        self.btn_start = Button(self, text="Começar Edição", command=self.start_editing, **btn_style)
        self.btn_start.pack(pady=15)
    
        self.progress = Progressbar(self, orient='horizontal', length=400, mode='determinate')
        self.progress.pack(pady=10)
    
        self.progress_label = Label(self, text="0%", **label_style)
        self.progress_label.pack()
    
        self.eta_label = Label(self, text="", **label_style)
        self.eta_label.pack()
    
        self.status_label = Label(self, text="", **label_style)
        self.status_label.pack(pady=(5, 15))
    
        self.btn_toggle_monitor = Button(
            self, text="Ativar Monitoramento", command=self.toggle_monitoring,
            bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
            relief="flat", activebackground=main_app.COR_BOTAO_HOVER,
            activeforeground=main_app.COR_TEXTO_BOTAO,
            font=main_app.FONT_DEFAULT, padx=10, pady=6
        )
        self.btn_toggle_monitor.pack(pady=10)
    
        self.monitor_status_label = Label(self, text="Monitoramento desativado",
                                          bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO, font=main_app.FONT_DEFAULT)
        self.monitor_status_label.pack(pady=(0, 10))
    
        self.load_categories()
    
    def load_categories(self):
        if not os.path.isdir(PASTA_CATEGORIAS):
            messagebox.showerror("Erro", "Pasta de categorias não encontrada!")
            return
    
        subpastas = [nome for nome in os.listdir(PASTA_CATEGORIAS) if os.path.isdir(os.path.join(PASTA_CATEGORIAS, nome))]
    
        if not subpastas:
            messagebox.showwarning("Aviso", "Nenhuma subpasta encontrada em categorias.")
            return
    
        self.category_combo['values'] = subpastas
        self.category_combo.current(0)
    
    def select_audios(self):
        files = filedialog.askopenfilenames(filetypes=[("Áudios", "*.mp3 *.wav")])
        if files:
            self.audio_paths = list(files)
            messagebox.showinfo("Sucesso", f"{len(files)} áudio(s) selecionado(s).")
    
    def update_progress(self, percent, eta):
        self.progress['value'] = percent
        self.progress_label.config(text=f"{percent}%")
        self.eta_label.config(text=f"Tempo estimado restante: {eta}")
        self.update_idletasks()
    
    def run_editing(self):
        selected_category = self.category_combo.get()
        if not selected_category:
            messagebox.showwarning("Aviso", "Selecione uma categoria de imagens!")
            return
    
        if not self.audio_paths:
            messagebox.showwarning("Aviso", "Nenhum áudio selecionado!")
            return
    
        images_folder = os.path.join(PASTA_CATEGORIAS, selected_category)
    
        self.btn_select_audio.config(state='disabled')
        self.btn_start.config(state='disabled')
        self.status_label.config(text="Processando vídeos...")
    
        try:
            for idx, audio_path in enumerate(self.audio_paths, start=1):
                self.status_label.config(text=f"Processando áudio {idx} de {len(self.audio_paths)}: {os.path.basename(audio_path)}")
                create_video_with_audio(audio_path, images_folder, progress_callback=self.update_progress)
    
            self.status_label.config(text="Todos os vídeos foram gerados com sucesso!")
            messagebox.showinfo("Concluído", "Todos os vídeos foram gerados!")
        except Exception as e:
            messagebox.showerror("Erro", f"Ocorreu um erro: {e}")
            self.status_label.config(text="Erro durante processamento.")
    
        self.progress['value'] = 0
        self.progress_label.config(text="0%")
        self.eta_label.config(text="")
        self.btn_select_audio.config(state='normal')
        self.btn_start.config(state='normal')
    
    def start_editing(self):
        thread = threading.Thread(target=self.run_editing, daemon=True)
        thread.start()
    
    def update_monitor_status(self, status):
        def update():
            self.monitor_status_label.config(text=status)
            self.update_idletasks()
        self.after(0, update)
    
    def toggle_monitoring(self, force_state=None):
        if force_state is not None:
            should_run = force_state
        else:
            should_run = not self.monitoring_active
    
        if not should_run:
            if self.monitor:
                self.monitor.stop()
                self.monitor = None
            self.monitoring_active = False
            self.btn_toggle_monitor.config(text="Ativar Monitoramento")
            self.update_monitor_status("Monitoramento desativado")
            self.main_app.monitors_ativos['audio_folder_monitor'] = False
        else:
            self.monitor = FolderMonitor(callback_video_process=self.process_audio_for_monitor,
                                         update_status_callback=self.update_monitor_status)
            self.monitor.start()
            self.monitoring_active = True
            self.btn_toggle_monitor.config(text="Desativar Monitoramento")
            self.update_monitor_status("Monitoramento ativado e aguardando arquivos...")
            self.main_app.monitors_ativos['audio_folder_monitor'] = True
    
    def process_audio_for_monitor(self, audio_path, category_folder, dest_folder):
        try:
            def progress_callback(percent, eta):
                self.update_monitor_status(f"Processando '{os.path.basename(audio_path)}': {percent}% ETA {eta}")
            create_video_with_audio(audio_path, category_folder, progress_callback=progress_callback)
        except Exception as e:
            self.update_monitor_status(f"Erro no processamento do áudio {audio_path}: {e}")
    

    class FolderMonitor(threading.Thread): def init(self, callback_video_process, update_status_callback): super().init(daemon=True) self.callback_video_process = callback_video_process self.update_status_callback = update_status_callback self.running = False

        self.watch_folders = {
            PASTA_TRUMP_AUDIOS: {"category": PASTA_TRUMP_IMAGENS, "dest": PASTA_TRUMP_DESTINO, "queue": []},
            PASTA_WARREN_AUDIOS: {"category": PASTA_WARREN_IMAGENS, "dest": PASTA_WARREN_DESTINO, "queue": []},
        }
        self.processing_lock = threading.Lock()
    
    def run(self):
        self.running = True
        self.update_status_callback("Monitoramento ativado.")
        while self.running:
            self.scan_folders()
            self.process_queues()
            time.sleep(5)
        self.update_status_callback("Monitoramento desativado.")
    
    def stop(self):
        self.running = False
    
    def scan_folders(self):
        for folder, info in self.watch_folders.items():
            try:
                arquivos = [f for f in os.listdir(folder) if f.lower().endswith((".mp3", ".wav"))]
            except Exception as e:
                self.update_status_callback(f"Erro ao listar {folder}: {e}")
                continue
            for arquivo in arquivos:
                caminho_completo = os.path.join(folder, arquivo)
                if caminho_completo not in info["queue"]:
                    if self.is_file_stable(caminho_completo):
                        info["queue"].append(caminho_completo)
                        self.update_status_callback(f"Novo áudio detectado e enfileirado: {arquivo}")
    
    def is_file_stable(self, filepath, wait_time=3):
        try:
            tamanho1 = os.path.getsize(filepath)
            time.sleep(wait_time)
            tamanho2 = os.path.getsize(filepath)
            return tamanho1 == tamanho2
        except Exception:
            return False
    
    def process_queues(self):
        with self.processing_lock:
            for folder, info in self.watch_folders.items():
                if info["queue"]:
                    audio_path = info["queue"][0]
                    self.update_status_callback(f"Processando áudio: {os.path.basename(audio_path)}")
                    try:
                        self.callback_video_process(audio_path, info["category"], info["dest"])
    
                        audio_basename = os.path.splitext(os.path.basename(audio_path))[0]
                        video_gerado = f"{audio_basename}.mp4"
                        if os.path.exists(video_gerado):
                            destino_final = os.path.join(info["dest"], video_gerado)
                            shutil.move(video_gerado, destino_final)
                            self.update_status_callback(f"Vídeo movido para: {destino_final}")
                        else:
                            self.update_status_callback(f"Vídeo não encontrado após criação para: {video_gerado}")
    
                        info["queue"].pop(0)
                        if os.path.exists(audio_path):
                            os.remove(audio_path)
                            self.update_status_callback(f"Áudio removido: {audio_path}")
    
                    except Exception as e:
                        self.update_status_callback(f"Erro ao processar {audio_path}: {e}")
                        info["queue"].pop(0)
    

    class MonitorConversionFrame(Frame): def init(self, parent, main_app): super().init(parent, bg=main_app.COR_FUNDO) self.main_app = main_app self.titulos = [] self.monitorando = False self.modo = "WARREN" self.thread_monitor = None

        # Títulos
        Label(self, text="Títulos (um por linha):", bg=main_app.COR_FUNDO,
              fg=main_app.COR_TEXTO, font=main_app.FONT_DEFAULT).pack(anchor="w", padx=10, pady=5)
        self.campo_titulos = scrolledtext.ScrolledText(self, height=10, bg="#101010",
                                                       fg=main_app.COR_TEXTO, insertbackground=main_app.COR_TEXTO,
                                                       font=main_app.FONT_DEFAULT)
        self.campo_titulos.pack(fill=BOTH, expand=False, padx=10)
    
        # Botões modo
        frame_botoes = Frame(self, bg=main_app.COR_FUNDO)
        frame_botoes.pack(pady=8)
        self.btn_warren = Button(frame_botoes, text="WARREN", width=10, relief=tk.SUNKEN, command=self.selecionar_warren,
                                 bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO, font=main_app.FONT_DEFAULT)
        self.btn_warren.pack(side=LEFT, padx=5)
        self.btn_trump = Button(frame_botoes, text="TRUMP", width=10, relief=tk.RAISED, command=self.selecionar_trump,
                                bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO, font=main_app.FONT_DEFAULT)
        self.btn_trump.pack(side=LEFT, padx=5)
    
        # Ativar/Desativar monitor
        self.btn_iniciar = Button(self, text="Ativar / Desativar Monitoramento", bg="orange",
                                  command=self.iniciar_monitoramento)
        self.btn_iniciar.pack(pady=10)
    
        self.label_status = Label(self, text="Status: Parado", fg="red", bg=main_app.COR_FUNDO,
                                  font=main_app.FONT_DEFAULT)
        self.label_status.pack()
    
    def limpar_nome(self, texto):
        return re.sub(r'[\/*?:"<>|]', "", texto.strip())
    
    def atualizar_titulos(self):
        texto = self.campo_titulos.get("1.0", END).strip()
        linhas = texto.split("\n")
        self.titulos[:] = [self.limpar_nome(l) for l in linhas if l.strip()]
    
    def selecionar_warren(self):
        self.modo = "WARREN"
        self.btn_warren.config(relief=tk.SUNKEN)
        self.btn_trump.config(relief=tk.RAISED)
    
    def selecionar_trump(self):
        self.modo = "TRUMP"
        self.btn_trump.config(relief=tk.SUNKEN)
        self.btn_warren.config(relief=tk.RAISED)
    
    def iniciar_monitoramento(self, force_state=None):
        if force_state is not None:
            self.monitorando = force_state
        else:
            self.monitorando = not self.monitorando
    
        if self.monitorando:
            self.atualizar_titulos()
            self.label_status.config(text="Status: Monitorando", fg="green")
            if self.thread_monitor is None or not self.thread_monitor.is_alive():
                self.thread_monitor = threading.Thread(target=self.monitorar_pasta, daemon=True)
                self.thread_monitor.start()
        else:
            self.label_status.config(text="Status: Parado", fg="red")
    
    def atualizar_titulos_na_interface(self):
        self.campo_titulos.delete("1.0", tk.END)
        for titulo in self.titulos:
            self.campo_titulos.insert(tk.END, titulo + "\n")
    
    def converter_para_mp3(self, caminho_video, caminho_saida):
        comando = [
            'ffmpeg', '-y', '-i', caminho_video, '-vn',
            '-acodec', 'libmp3lame', '-q:a', '3', caminho_saida
        ]
        result = subprocess.run(comando, capture_output=True, text=True)
        if result.returncode != 0:
            raise Exception(f"Erro na conversão:\n{result.stderr}")
    
    def juntar_mp3(self, arquivo1, arquivo2, arquivo_saida):
        lista_txt = os.path.join(DOWNLOADS_FOLDER, 'lista.txt')
        with open(lista_txt, 'w', encoding='utf-8') as f:
            f.write(f"file '{arquivo1.replace('\\', '/')}'\n")
            f.write(f"file '{arquivo2.replace('\\', '/')}'\n")
    
        comando = [
            'ffmpeg', '-y', '-f', 'concat', '-safe', '0',
            '-i', lista_txt, '-c', 'copy', arquivo_saida
        ]
        result = subprocess.run(comando, capture_output=True, text=True)
        if result.returncode != 0:
            raise Exception(f"Erro na junção:\n{result.stderr}")
        os.remove(lista_txt)
    
    def processar_videos(self, arquivos):
        try:
            caminhos_videos = [os.path.join(DOWNLOADS_FOLDER, a) for a in arquivos]
    
            mp3_arquivos = []
            for idx, caminho in enumerate(caminhos_videos):
                mp3_nome = f"temp_audio_{idx}.mp3"
                mp3_caminho = os.path.join(DOWNLOADS_FOLDER, mp3_nome)
                self.converter_para_mp3(caminho, mp3_caminho)
                mp3_arquivos.append(mp3_caminho)
    
            if self.titulos:
                nome_saida = self.titulos.pop(0) + ".mp3"
            else:
                nome_saida = "output.mp3"
    
            self.atualizar_titulos_na_interface()
    
            destino = OUTPUT_WARREN if self.modo == "WARREN" else OUTPUT_TRUMP
            caminho_saida = os.path.join(destino, nome_saida)
    
            self.juntar_mp3(mp3_arquivos[0], mp3_arquivos[1], caminho_saida)
    
            # Deleta temporários e vídeos
            for arquivo in mp3_arquivos + caminhos_videos:
                if os.path.exists(arquivo):
                    os.remove(arquivo)
        except Exception as e:
            messagebox.showerror("Erro", str(e))
    
    def monitorar_pasta(self):
        while self.monitorando:
            try:
                arquivos_video = [
                    f for f in os.listdir(DOWNLOADS_FOLDER)
                    if f.lower().endswith(('.mp4', '.mkv', '.avi', '.mov'))
                    and not f.endswith('.crdownload')
                ]
    
                if len(arquivos_video) >= 2:
                    arquivos_ordenados = sorted(
                        arquivos_video,
                        key=lambda x: os.path.getmtime(os.path.join(DOWNLOADS_FOLDER, x))
                    )
                    self.processar_videos(arquivos_ordenados[:2])
                time.sleep(3)
            except Exception as e:
                print("Erro no monitoramento:", e)
                time.sleep(5)
    

    class AgendadorFrame(Frame): def init(self, parent, main_app): super().init(parent, bg=main_app.COR_FUNDO) self.main_app = main_app

        self.monitorando_youtube = False
        self.monitor_thread_youtube = None
        self.perfis_autorizados = {}
        self.perfis_enviar_ordenados = []
        self.indice_proximo_perfil = 0
        self.enviado_por_perfil = {}
        self.botoes_perfis = {}
    
        # Widgets layout
        # Video file selection
        lbl_video = Label(self, text="Arquivo de Vídeo (.mp4):", bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO,
                          font=main_app.FONT_DEFAULT)
        lbl_video.pack(pady=(10, 0))
        self.ent_video = Entry(self, width=80)
        self.ent_video.pack()
    
        def escolher_video():
            path = filedialog.askopenfilename(title="Selecione o arquivo de vídeo", filetypes=[("MP4 files", "*.mp4")])
            if path:
                self.ent_video.delete(0, END)
                self.ent_video.insert(0, path)
    
        btn_video = Button(self, text="Selecionar Vídeo", command=escolher_video,
                           bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                           font=main_app.FONT_DEFAULT, relief="flat", padx=10, pady=6)
        btn_video.pack(pady=(0, 10))
    
        # Thumbnail selection
        lbl_thumb = Label(self, text="Thumbnail (opcional):", bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO,
                          font=main_app.FONT_DEFAULT)
        lbl_thumb.pack()
        self.ent_thumb = Entry(self, width=80)
        self.ent_thumb.pack()
    
        def escolher_thumb():
            path = filedialog.askopenfilename(title="Selecione o thumbnail",
                                              filetypes=[("Image files", "*.jpg *.png *.jpeg")])
            if path:
                self.ent_thumb.delete(0, END)
                self.ent_thumb.insert(0, path)
    
        btn_thumb = Button(self, text="Selecionar Thumbnail", command=escolher_thumb,
                           bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                           font=main_app.FONT_DEFAULT, relief="flat", padx=10, pady=6)
        btn_thumb.pack(pady=(0, 10))
    
        # Perfil selection
        lbl_perfil = Label(self, text="Perfil para Upload:", bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO,
                           font=main_app.FONT_DEFAULT)
        lbl_perfil.pack()
        self.var_perfil = StringVar()
        self.opt_perfis = OptionMenu(self, self.var_perfil, '')
        self.opt_perfis.pack()
        btn_gerenciar_perfis = Button(self, text="Gerenciar Perfis", command=self.mostrar_gestao_perfis,
                                      bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                                      font=main_app.FONT_DEFAULT, relief="flat", padx=10, pady=6)
        btn_gerenciar_perfis.pack(pady=(0, 10))
    
        # Description
        lbl_desc = Label(self, text="Descrição:", bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO,
                         font=main_app.FONT_DEFAULT)
        lbl_desc.pack()
        self.txt_desc = Text(self, height=10, width=80)
        self.txt_desc.insert(END, DEFAULT_DESCRIPTION)
        self.txt_desc.pack(pady=(0, 10))
    
        # Tags
        lbl_tags = Label(self, text="Tags (separadas por vírgula):", bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO,
                         font=main_app.FONT_DEFAULT)
        lbl_tags.pack()
        self.ent_tags = Entry(self, width=80)
        self.ent_tags.insert(0, ",".join(DEFAULT_TAGS))
        self.ent_tags.pack(pady=(0, 10))
    
        # Botões envio vídeo individual e automático
        btn_enviar = Button(self, text="Enviar Vídeo", command=self.enviar_video,
                            bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                            font=main_app.FONT_DEFAULT, relief="flat", padx=10, pady=6)
        btn_enviar.pack(pady=(0, 20))
    
        frame_lotes = Frame(self)
        frame_lotes.pack()
        lbl_lotes = Label(frame_lotes, text="Número de lotes de 4 vídeos:", bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO,
                          font=main_app.FONT_DEFAULT)
        lbl_lotes.pack(side="left", padx=(0, 5))
        self.ent_lotes = Entry(frame_lotes, width=5)
        self.ent_lotes.insert(0, "1")
        self.ent_lotes.pack(side="left", padx=(0, 15))
        btn_enviar_4 = Button(frame_lotes, text="Enviar 4 Automático", command=self.enviar_4_automatico,
                              bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                              font=main_app.FONT_DEFAULT, relief="flat", padx=10, pady=6)
        btn_enviar_4.pack(side="left")
    
        # Autorizações monitoramento
        self.frame_autorizacao = LabelFrame(self, text="Perfis para monitoramento (clique para ativar/desativar)",
                                            padx=5, pady=5, bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO)
        self.frame_autorizacao.pack(padx=10, pady=10, fill="x")
    
        # Botão monitoramento Youtube
        self.btn_monitorar = Button(self, text="Monitorar: DESLIGADO", bg="red", fg="white", width=20,
                                   command=self.toggle_monitoramento,
                                   font=main_app.FONT_DEFAULT, relief="flat", padx=10, pady=6)
        self.btn_monitorar.pack(pady=10)
    
        # Botão Estatísticas
        self.btn_estatisticas = Button(self, text="Mostrar Estatísticas de Envios",
                                      command=self.criar_ou_atualizar_estatisticas,
                                      bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                                      font=main_app.FONT_DEFAULT, relief="flat", padx=10, pady=6)
        self.btn_estatisticas.pack(pady=10)
    
        self.atualizar_dropdown_perfis(self.main_app.get_perfis())
        self.construir_lista_perfis_autorizados()
    
    def atualizar_dropdown_perfis(self, perfis):
        menu = self.opt_perfis["menu"]
        menu.delete(0, "end")
        for p in perfis:
            menu.add_command(label=p[1], command=lambda value=p[1]: self.var_perfil.set(value))
        if perfis:
            self.var_perfil.set(perfis[0][1])
        else:
            self.var_perfil.set("")
    
    def mostrar_gestao_perfis(self):
        janela = Toplevel(self.main_app.root)
        janela.title("Gerenciar Perfis")
        janela.geometry("600x400")
        perfis = self.main_app.get_perfis()
    
        frame_listar = Frame(janela)
        frame_listar.pack(fill=BOTH, expand=True)
    
        lb_perfis = Listbox(frame_listar)
        lb_perfis.pack(fill=BOTH, expand=True)
    
        for p in perfis:
            lb_perfis.insert(END, f"{p[1]} (Canal: {p[2]})")
    
        def adicionar_perfil():
            nome = simpledialog.askstring("Adicionar Perfil", "Nome do Perfil:")
            canal = simpledialog.askstring("Canal do Perfil", "Nome do Canal:")
            if not nome or not canal:
                messagebox.showwarning("Aviso", "Nome e canal são obrigatórios")
                return
    
            cred_path = filedialog.askopenfilename(
                title="Selecione o arquivo pickle das credenciais",
                filetypes=[("Pickle files", "*.pickle")]
            )
            if not cred_path:
                return
    
            with open(cred_path, "rb") as f:
                cred_blob = f.read()
    
            try:
                self.main_app.add_perfil(nome, cred_blob, canal)
                lb_perfis.insert(END, f"{nome} (Canal: {canal})")
                messagebox.showinfo("Sucesso", f"Perfil {nome} adicionado!")
                self.atualizar_dropdown_perfis(self.main_app.get_perfis())
                self.construir_lista_perfis_autorizados()
            except Exception as e:
                messagebox.showerror("Erro", f"Falha ao adicionar perfil: {e}")
    
        def remover_perfil():
            sel = lb_perfis.curselection()
            if not sel:
                messagebox.showwarning("Aviso", "Selecione um perfil para remover")
                return
            nome_remover = lb_perfis.get(sel[0]).split(" ")[0]
            if messagebox.askyesno("Confirmar", f"Remover perfil {nome_remover}?"):
                try:
                    self.main_app.delete_perfil(nome_remover)
                    lb_perfis.delete(sel[0])
                    messagebox.showinfo("Sucesso", "Perfil removido")
                    self.atualizar_dropdown_perfis(self.main_app.get_perfis())
                    self.construir_lista_perfis_autorizados()
                except Exception as e:
                    messagebox.showerror("Erro", f"Falha ao remover perfil: {e}")
    
        btn_add = Button(janela, text="Adicionar Perfil", command=adicionar_perfil)
        btn_add.pack(side="left", padx=10, pady=10)
        btn_remover = Button(janela, text="Remover Perfil", command=remover_perfil)
        btn_remover.pack(side="left", padx=10, pady=10)
    
    def construir_lista_perfis_autorizados(self):
        for widget in self.frame_autorizacao.winfo_children():
            widget.destroy()
    
        perfis = self.main_app.get_perfis()
        for p in perfis:
            nome = p[1]
            if nome not in self.perfis_autorizados:
                self.perfis_autorizados[nome] = False
    
        for p in perfis:
            nome = p[1]
            btn = Button(self.frame_autorizacao, text=nome, width=15,
                         bg="green" if self.perfis_autorizados.get(nome, False) else "red",
                         fg="white", relief="raised", font=self.main_app.FONT_DEFAULT)
            btn.pack(side="left", padx=3, pady=3)
            btn.config(command=lambda n=nome, b=btn: self.toggle_autorizacao(n, b))
            self.botoes_perfis[nome] = btn
        self.rebuild_perfis_enviar_ordenados()
    
    def toggle_autorizacao(self, nome_perfil, botao):
        atual = self.perfis_autorizados.get(nome_perfil, False)
        self.perfis_autorizados[nome_perfil] = not atual
        botao.config(bg="green" if not atual else "red")
        self.rebuild_perfis_enviar_ordenados()
    
    def rebuild_perfis_enviar_ordenados(self):
        self.perfis_enviar_ordenados = [p for p, autorizado in self.perfis_autorizados.items() if autorizado]
        if self.indice_proximo_perfil >= len(self.perfis_enviar_ordenados):
            self.indice_proximo_perfil = 0
    
    def carregar_credenciais_do_blob(self, blob):
        filename_temp = "temp_creds.pickle"
        with open(filename_temp, "wb") as f:
            f.write(blob)
        with open(filename_temp, "rb") as f:
            creds = pickle.load(f)
        os.remove(filename_temp)
        return creds
    
    def get_canal_por_perfil(self, nome):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT canal FROM perfis WHERE nome=?", (nome,))
        row = c.fetchone()
        conn.close()
        return row[0] if row else None
    
    def get_title_from_db(self, filename):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT title FROM videos WHERE filename=?", (filename,))
        row = c.fetchone()
        conn.close()
        return row[0] if row else None
    
    def set_video_entry(self, filename, title, channel, schedule_time):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute('''
            INSERT OR REPLACE INTO videos (filename, title, channel, schedule_time)
            VALUES (?, ?, ?, ?)
        ''', (filename, title, channel, schedule_time))
        conn.commit()
        conn.close()
    
    def upload_video_to_youtube(self, credentials_blob, title, description, tags, video_path,
                                thumbnail_path, publish_now, publish_at=None):
        creds = self.carregar_credenciais_do_blob(credentials_blob)
    
        youtube = build("youtube", "v3", credentials=creds)
    
        if not os.path.exists(video_path):
            raise FileNotFoundError(f"Arquivo não encontrado: {video_path}")
    
        if publish_at:
            dt_local = datetime.fromisoformat(publish_at)
            publish_at_utc = dt_local.astimezone(timezone.utc).isoformat()
        else:
            publish_at_utc = None
    
        body = {
            "snippet": {
                "title": title,
                "description": description,
                "tags": tags,
                "categoryId": "22"
            },
            "status": {
                "privacyStatus": "private" if not publish_now else "public",
                "publishAt": publish_at_utc
            }
        }
    
        media = MediaFileUpload(video_path, mimetype="video/mp4", resumable=True, chunksize=10 * 1024 * 1024)
    
        request = youtube.videos().insert(
            part="snippet,status",
            body=body,
            media_body=media
        )
    
        response = None
        while response is None:
            status, response = request.next_chunk()
            if status:
                print(f"Upload {int(status.progress() * 100)}%")
    
        if thumbnail_path and os.path.exists(thumbnail_path):
            youtube.thumbnails().set(
                videoId=response["id"],
                media_body=MediaFileUpload(thumbnail_path)
            ).execute()
    
        return response["id"]
    
    def get_scheduled_times_for_channel(self, channel):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT schedule_time FROM videos WHERE channel=?", (channel,))
        horarios = [row[0] for row in c.fetchall()]
        conn.close()
        return horarios
    
    def get_next_available_time(self, profile_name):
        canal = self.get_canal_por_perfil(profile_name)
        horarios_ocupados = self.get_scheduled_times_for_channel(canal)
    
        br_tz = pytz.timezone("America/Sao_Paulo")
        agora = datetime.now(br_tz)
    
        parsed_ocupados = []
        for h in horarios_ocupados:
            try:
                dt = datetime.fromisoformat(h)
            except ValueError:
                naive = datetime.fromisoformat(h)
                dt = br_tz.localize(naive)
            parsed_ocupados.append(dt)
    
        for dia_offset in range(0, 7):
            data_ver = agora.date() + timedelta(days=dia_offset)
            for hora in HORARIOS_DIA:
                dt_naive = datetime.combine(data_ver, datetime.min.time()).replace(hour=hora, minute=0, second=0, microsecond=0)
                dt_local = br_tz.localize(dt_naive)
                if dt_local <= agora:
                    continue
                if not any(dt_local == ocupado for ocupado in parsed_ocupados):
                    return dt_local.isoformat()
    
        if parsed_ocupados:
            ultimo = max(parsed_ocupados)
            proximo_dia = (ultimo + timedelta(days=1)).date()
        else:
            proximo_dia = agora.date() + timedelta(days=1)
    
        proximo_naive_cinco = datetime.combine(proximo_dia, datetime.min.time()).replace(hour=5, minute=0, second=0, microsecond=0)
        proximo_cinco_local = br_tz.localize(proximo_naive_cinco)
        return proximo_cinco_local.isoformat()
    
    def processar_envio(self, profile_nome, video_path, description, tags, thumbnail_path,
                        publicar_agora=False, notify=True):
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT credentials, canal FROM perfis WHERE nome=?", (profile_nome,))
        row = c.fetchone()
        conn.close()
    
        if not row:
            if notify:
                messagebox.showerror("Erro", "Perfil não encontrado")
            return False
    
        credentials_blob, canal = row
        publish_at = self.get_next_available_time(profile_nome)
    
        filename_base = os.path.basename(video_path)
        filename_sem_ext = os.path.splitext(filename_base)[0]
    
        titulo_bd = self.get_title_from_db(filename_sem_ext)
        titulo_final = titulo_bd or filename_sem_ext
    
        try:
            vid_id = self.upload_video_to_youtube(
                credentials_blob,
                titulo_final,
                description,
                tags,
                video_path,
                thumbnail_path,
                False,
                publish_at
            )
            self.set_video_entry(filename_sem_ext, titulo_final, canal, publish_at)
            if notify:
                messagebox.showinfo("Sucesso", f"Vídeo agendado! ID: {vid_id}")
            return True
        except Exception as e:
            if notify:
                messagebox.showerror("Erro", f"Falha no upload: {e}")
            return False
    
    def enviar_video(self):
        video_path = self.ent_video.get()
        thumbnail_path = self.ent_thumb.get()
        profile_nome = self.var_perfil.get()
        description = self.txt_desc.get("1.0", END).strip()
        tags = [tag.strip() for tag in self.ent_tags.get().split(",") if tag.strip()]
    
        if not video_path or not profile_nome:
            messagebox.showwarning("Aviso", "Selecione um vídeo e um perfil")
            return
    
        self.processar_envio(profile_nome, video_path, description, tags, thumbnail_path, publicar_agora=False, notify=True)
    
    def enviar_4_automatico(self):
        profile_nome = self.var_perfil.get()
        if not profile_nome:
            messagebox.showwarning("Aviso", "Selecione um perfil antes de enviar automaticamente.")
            return
    
        try:
            lotes = int(self.ent_lotes.get())
            if lotes < 1:
                lotes = 1
        except ValueError:
            lotes = 1
    
        enviados_sucesso_total = 0
        lotes_realizados = 0
    
        for lote in range(lotes):
            pasta_trump = MONITOR_PASTA_TRUMP
            pasta_warren = MONITOR_PASTA_WARREN
    
            thumb_trump_folder = THUMB_TRUMP_FOLDER
            thumb_warren_folder = THUMB_WARREN_FOLDER
    
            arquivos_trump = [os.path.join(pasta_trump, f) for f in os.listdir(pasta_trump) if f.lower().endswith(".mp4")]
            arquivos_warren = [os.path.join(pasta_warren, f) for f in os.listdir(pasta_warren) if f.lower().endswith(".mp4")]
    
            thumbs_trump = [os.path.join(thumb_trump_folder, f) for f in os.listdir(thumb_trump_folder)
                            if f.lower().endswith((".jpg", ".jpeg", ".png"))]
            thumbs_warren = [os.path.join(thumb_warren_folder, f) for f in os.listdir(thumb_warren_folder)
                             if f.lower().endswith((".jpg", ".jpeg", ".png"))]
    
            if len(arquivos_trump) < 2 or len(arquivos_warren) < 2 or len(thumbs_trump) < 2 or len(thumbs_warren) < 2:
                break
    
            selecionados_trump = random.sample(arquivos_trump, 2)
            selecionados_warren = random.sample(arquivos_warren, 2)
    
            enviados_sucesso_lote = 0
    
            for i in range(2):
                video_trump = selecionados_trump[i]
                thumb_trump = random.choice(thumbs_trump)
                sucesso_trump = self.processar_envio(profile_nome, video_trump, DEFAULT_DESCRIPTION, DEFAULT_TAGS, thumb_trump, notify=False)
                if sucesso_trump:
                    enviados_sucesso_lote += 1
                    try:
                        os.remove(video_trump)
                    except Exception as e:
                        print(f"Falha ao deletar vídeo Trump {video_trump}: {e}")
                    try:
                        os.remove(thumb_trump)
                        thumbs_trump.remove(thumb_trump)
                    except Exception as e:
                        print(f"Falha ao deletar thumbnail Trump {thumb_trump}: {e}")
    
                video_warren = selecionados_warren[i]
                thumb_warren = random.choice(thumbs_warren)
                sucesso_warren = self.processar_envio(profile_nome, video_warren, DEFAULT_DESCRIPTION, DEFAULT_TAGS, thumb_warren, notify=False)
                if sucesso_warren:
                    enviados_sucesso_lote += 1
                    try:
                        os.remove(video_warren)
                    except Exception as e:
                        print(f"Falha ao deletar vídeo Warren {video_warren}: {e}")
                    try:
                        os.remove(thumb_warren)
                        thumbs_warren.remove(thumb_warren)
                    except Exception as e:
                        print(f"Falha ao deletar thumbnail Warren {thumb_warren}: {e}")
    
            enviados_sucesso_total += enviados_sucesso_lote
            lotes_realizados += 1
    
        if lotes_realizados == lotes:
            messagebox.showinfo("Concluído", f"Foram realizados {lotes_realizados} lote(s) e {enviados_sucesso_total} vídeo(s) enviados com sucesso.")
        else:
            messagebox.showwarning(
                "Concluído Parcialmente",
                f"Apenas {lotes_realizados} lote(s) foram realizados devido à quantidade insuficiente de vídeos/thumbnails.\n"
                f"Total de vídeos enviados: {enviados_sucesso_total}."
            )
    
    def criar_ou_atualizar_estatisticas(self):
        if hasattr(self, 'estatisticas_janela') and self.estatisticas_janela.winfo_exists():
            self.estatisticas_janela.destroy()
    
        self.estatisticas_janela = Toplevel(self.main_app.root)
        self.estatisticas_janela.title("Estatísticas de Envios")
        self.estatisticas_janela.geometry("400x300")
        self.estatisticas_janela.resizable(False, False)
    
        frame = Frame(self.estatisticas_janela)
        frame.pack(fill=BOTH, expand=True)
    
        header = Label(frame, text="Perfil | Canal | Lotes Enviados | Vídeos Enviados",
                       font=("Arial", 10, "bold"))
        header.pack(pady=5)
    
        stats_frame = Frame(frame)
        stats_frame.pack(fill=BOTH, expand=True)
    
        for perfil, stats in self.enviado_por_perfil.items():
            canal = self.get_canal_por_perfil(perfil) or "Desconhecido"
            texto = f"{perfil} | {canal} | {stats['lotes']} | {stats['videos']}"
            lbl = Label(stats_frame, text=texto, anchor="w")
            lbl.pack(anchor="w")
    
    def toggle_monitoramento(self, force_state=None):
        if force_state is not None:
            should_run = force_state
        else:
            should_run = not self.monitorando_youtube
    
        if should_run:
            if not any(self.perfis_autorizados.values()):
                messagebox.showwarning("Aviso", "Selecione ao menos um perfil para autorizar antes de ativar o monitoramento.")
                return
            self.monitorando_youtube = True
            self.btn_monitorar.config(text="Monitorar: LIGADO", bg="green")
            self.monitor_thread_youtube = threading.Thread(target=self.monitorar_pastas_loop, daemon=True)
            self.monitor_thread_youtube.start()
            self.main_app.monitors_ativos['youtube_upload_monitor'] = True
        else:
            self.monitorando_youtube = False
            self.btn_monitorar.config(text="Monitorar: DESLIGADO", bg="red")
            self.main_app.monitors_ativos['youtube_upload_monitor'] = False
    
    def monitorar_pastas_loop(self, pausa_segundos=60):
        while self.monitorando_youtube:
            perfis_ativos = [p for p, aut in self.perfis_autorizados.items() if aut]
            if not perfis_ativos:
                time.sleep(pausa_segundos)
                continue
    
            try:
                vids_trump = [os.path.join(MONITOR_PASTA_TRUMP, f) for f in os.listdir(MONITOR_PASTA_TRUMP) if
                             f.lower().endswith(".mp4")]
            except Exception as e:
                print(f"Erro ao listar vídeos Trump: {e}")
                vids_trump = []
    
            try:
                vids_warren = [os.path.join(MONITOR_PASTA_WARREN, f) for f in os.listdir(MONITOR_PASTA_WARREN) if
                              f.lower().endswith(".mp4")]
            except Exception as e:
                print(f"Erro ao listar vídeos Warren: {e}")
                vids_warren = []
    
            if len(vids_trump) < 2 or len(vids_warren) < 2:
                time.sleep(pausa_segundos)
                continue
    
            try:
                thumbs_trump = [os.path.join(THUMB_TRUMP_FOLDER, f) for f in os.listdir(THUMB_TRUMP_FOLDER) if
                                f.lower().endswith((".jpg", ".jpeg", ".png"))]
            except Exception as e:
                print(f"Erro ao listar thumbnails Trump: {e}")
                thumbs_trump = []
    
            try:
                thumbs_warren = [os.path.join(THUMB_WARREN_FOLDER, f) for f in os.listdir(THUMB_WARREN_FOLDER) if
                                 f.lower().endswith((".jpg", ".jpeg", ".png"))]
            except Exception as e:
                print(f"Erro ao listar thumbnails Warren: {e}")
                thumbs_warren = []
    
            if len(thumbs_trump) < 2 or len(thumbs_warren) < 2:
                time.sleep(pausa_segundos)
                continue
    
            self.rebuild_perfis_enviar_ordenados()
            if not self.perfis_enviar_ordenados:
                time.sleep(pausa_segundos)
                continue
    
            perfil_atual = self.perfis_enviar_ordenados[self.indice_proximo_perfil]
    
            canal_atual = self.get_canal_por_perfil(perfil_atual)
            if canal_atual is None:
                self.indice_proximo_perfil = (self.indice_proximo_perfil + 1) % len(self.perfis_enviar_ordenados)
                continue
    
            enviados_lote = 0
            try:
                selecionados_trump = random.sample(vids_trump, 2)
                selecionados_warren = random.sample(vids_warren, 2)
    
                for i in range(2):
                    vid_trump = selecionados_trump[i]
                    thumb_trump = random.choice(thumbs_trump)
                    sucesso1 = self.processar_envio(perfil_atual, vid_trump, DEFAULT_DESCRIPTION,
                                                   DEFAULT_TAGS, thumb_trump, notify=False)
                    if sucesso1:
                        enviados_lote += 1
                        try:
                            os.remove(vid_trump)
                        except Exception as e:
                            print(f"Erro ao deletar vídeo Trump {vid_trump}: {e}")
                        try:
                            os.remove(thumb_trump)
                        except Exception as e:
                            print(f"Erro ao deletar thumbnail Trump {thumb_trump}: {e}")
    
                    vid_warren = selecionados_warren[i]
                    thumb_warren = random.choice(thumbs_warren)
                    sucesso2 = self.processar_envio(perfil_atual, vid_warren, DEFAULT_DESCRIPTION,
                                                   DEFAULT_TAGS, thumb_warren, notify=False)
                    if sucesso2:
                        enviados_lote += 1
                        try:
                            os.remove(vid_warren)
                        except Exception as e:
                            print(f"Erro ao deletar vídeo Warren {vid_warren}: {e}")
                        try:
                            os.remove(thumb_warren)
                        except Exception as e:
                            print(f"Erro ao deletar thumbnail Warren {thumb_warren}: {e}")
            except Exception as e:
                print(f"Erro no envio monitorado: {e}")
    
            if perfil_atual not in self.enviado_por_perfil:
                self.enviado_por_perfil[perfil_atual] = {'lotes': 0, 'videos': 0}
            self.enviado_por_perfil[perfil_atual]['lotes'] += 1
            self.enviado_por_perfil[perfil_atual]['videos'] += enviados_lote
    
            self.indice_proximo_perfil = (self.indice_proximo_perfil + 1) % len(self.perfis_enviar_ordenados)
    
            self.main_app.root.after(0, self.criar_ou_atualizar_estatisticas)
    
            time.sleep(pausa_segundos)
    

    class MiniMonitorWindow: def init(self, root): self.top = Toplevel(root) self.top.title("Mini Monitor de Pastas") self.top.geometry("300x150+1600+20") # top-right corner de uma tela Full HD self.top.configure(bg="#111111") self.top.attributes("-topmost", True) # Sempre acima self.top.resizable(False, False)

        self.label_title = Label(self.top, text="Monitor de Conteúdo - Trump & Warren",
                                 font=("Segoe UI Semibold", 12), bg="#222222", fg="#00FF00")
        self.label_title.pack(fill='x', padx=5, pady=5)
    
        self.frame_content = Frame(self.top, bg="#111111")
        self.frame_content.pack(fill='both', expand=True, padx=10)
    
        # Trump vídeos
        self.lbl_trump_videos = Label(self.frame_content, text="Vídeos Trump: 0",
                                     font=("Segoe UI", 11), fg="#FFFFFF", bg="#111111")
        self.lbl_trump_videos.pack(anchor='w')
    
        # Trump thumbs
        self.lbl_trump_thumbs = Label(self.frame_content, text="Thumbnails Trump: 0",
                                     font=("Segoe UI", 11), fg="#FFFFFF", bg="#111111")
        self.lbl_trump_thumbs.pack(anchor='w')
    
        # Warren vídeos
        self.lbl_warren_videos = Label(self.frame_content, text="Vídeos Warren: 0",
                                      font=("Segoe UI", 11), fg="#FFFFFF", bg="#111111")
        self.lbl_warren_videos.pack(anchor='w')
    
        # Warren thumbs
        self.lbl_warren_thumbs = Label(self.frame_content, text="Thumbnails Warren: 0",
                                      font=("Segoe UI", 11), fg="#FFFFFF", bg="#111111")
        self.lbl_warren_thumbs.pack(anchor='w')
    
        # Atualização periódica
        self.update_contents()
    
    def update_contents(self):
        try:
            trump_videos = len([f for f in os.listdir(MONITOR_PASTA_TRUMP) if f.lower().endswith(".mp4")])
        except:
            trump_videos = 0
        try:
            trump_thumbs = len([f for f in os.listdir(THUMB_TRUMP_FOLDER) if f.lower().endswith((".jpg", ".jpeg", ".png"))])
        except:
            trump_thumbs = 0
        try:
            warren_videos = len([f for f in os.listdir(MONITOR_PASTA_WARREN) if f.lower().endswith(".mp4")])
        except:
            warren_videos = 0
        try:
            warren_thumbs = len([f for f in os.listdir(THUMB_WARREN_FOLDER) if f.lower().endswith((".jpg", ".jpeg", ".png"))])
        except:
            warren_thumbs = 0
    
        self.lbl_trump_videos.config(text=f"Vídeos Trump: {trump_videos}")
        self.lbl_trump_thumbs.config(text=f"Thumbnails Trump: {trump_thumbs}")
        self.lbl_warren_videos.config(text=f"Vídeos Warren: {warren_videos}")
        self.lbl_warren_thumbs.config(text=f"Thumbnails Warren: {warren_thumbs}")
    
        self.top.after(2000, self.update_contents)
    

    def zoom_effect(image, progress, zoom_in=True, direction="center"): h, w = image.shape[:2] zoom_strength = 0.05 scale = 1 + (zoom_strength * progress) if zoom_in else 1 + (zoom_strength * (1 - progress)) new_w, new_h = int(w * scale), int(h * scale) resized = cv2.resize(image, (new_w, new_h))

    if direction == "top":
        x, y = (new_w - w) // 2, 0
    elif direction == "bottom":
        x, y = (new_w - w) // 2, new_h - h
    elif direction == "left":
        x, y = 0, (new_h - h) // 2
    elif direction == "right":
        x, y = new_w - w, (new_h - h) // 2
    elif direction == "top_left":
        x, y = 0, 0
    elif direction == "top_right":
        x, y = new_w - w, 0
    elif direction == "bottom_left":
        x, y = 0, new_h - h
    elif direction == "bottom_right":
        x, y = new_w - w, new_h - h
    else:
        x, y = (new_w - w) // 2, (new_h - h) // 2
    
    x = max(min(x, new_w - w), 0)
    y = max(min(y, new_h - h), 0)
    
    cropped = resized[y:y + h, x:x + w]
    return cropped
    

    def move_effect(image, progress, direction="left_to_right"): h, w = image.shape[:2] dx = int(w * 0.05 * progress) dy = int(h * 0.05 * progress)

    if direction == "left_to_right":
        M = np.float32([[1, 0, dx], [0, 1, 0]])
    elif direction == "right_to_left":
        M = np.float32([[1, 0, -dx], [0, 1, 0]])
    elif direction == "top_to_bottom":
        M = np.float32([[1, 0, 0], [0, 1, dy]])
    elif direction == "bottom_to_top":
        M = np.float32([[1, 0, 0], [0, 1, -dy]])
    else:
        return image
    
    moved = cv2.warpAffine(image, M, (w, h))
    return moved
    

    def ken_burns_effect(image, progress, zoom_in=True, direction="left_to_right"): h, w = image.shape[:2] zoom_strength = 0.1

    scale = 1 + (zoom_strength * progress) if zoom_in else 1 + (zoom_strength * (1 - progress))
    new_w, new_h = int(w * scale), int(h * scale)
    resized = cv2.resize(image, (new_w, new_h))
    
    dx = int((new_w - w) * progress)
    dy = int((new_h - h) * progress)
    
    if direction == "left_to_right":
        x, y = dx, 0
    elif direction == "right_to_left":
        x, y = (new_w - w) - dx, 0
    elif direction == "top_to_bottom":
        x, y = 0, dy
    elif direction == "bottom_to_top":
        x, y = 0, (new_h - h) - dy
    elif direction == "top_left_to_bottom_right":
        x, y = dx, dy
    elif direction == "bottom_right_to_top_left":
        x, y = (new_w - w) - dx, (new_h - h) - dy
    else:
        x, y = (new_w - w) // 2, (new_h - h) // 2
    
    x = max(min(x, new_w - w), 0)
    y = max(min(y, new_h - h), 0)
    
    cropped = resized[y:y + h, x:x + w]
    return cropped
    

    def fast_zoom_blur_effect(image, progress): h, w = image.shape[:2]

    scale = 1 + 0.4 * progress
    new_w, new_h = int(w * scale), int(h * scale)
    resized = cv2.resize(image, (new_w, new_h))
    
    x = (new_w - w) // 2
    y = (new_h - h) // 2
    zoomed = resized[y:y + h, x:x + w]
    
    blur_amount = int(progress * 7) * 2 + 1
    if blur_amount % 2 == 0:
        blur_amount += 1
    
    if blur_amount > 1:
        zoomed = cv2.GaussianBlur(zoomed, (blur_amount, blur_amount), 0)
    
    return zoomed
    

    def morph_transition_effect(img1, img2, alpha): h, w = img1.shape[:2] img1 = cv2.resize(img1, (w, h)) img2 = cv2.resize(img2, (w, h)) blended = cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0) return blended

    def slide_effect(image, progress, direction="left_to_right"): h, w = image.shape[:2]

    dx = int(w * progress)
    dy = int(h * progress)
    
    if direction == "left_to_right":
        M = np.float32([[1, 0, dx], [0, 1, 0]])
    elif direction == "right_to_left":
        M = np.float32([[1, 0, -dx], [0, 1, 0]])
    elif direction == "top_to_bottom":
        M = np.float32([[1, 0, 0], [0, 1, dy]])
    elif direction == "bottom_to_top":
        M = np.float32([[1, 0, 0], [0, 1, -dy]])
    else:
        return image
    
    moved = cv2.warpAffine(image, M, (w, h))
    return moved
    

    def gallery_slide_effect(image, progress): h, w = image.shape[:2] dx = int(w * 0.3 * progress)

    M = np.float32([[1, 0, dx], [0, 1, 0]])
    shifted = cv2.warpAffine(image, M, (w, h))
    
    fade_width = int(w * 0.1)
    mask = np.ones((h, w), dtype=np.float32)
    for x_ in range(fade_width):
        alpha = x_ / fade_width
        mask[:, x_] *= alpha
        mask[:, w - 1 - x_] *= alpha
    
    if shifted.ndim == 3:
        for c in range(3):
            shifted[:, :, c] = shifted[:, :, c].astype(np.float32) * mask
        shifted = shifted.astype(np.uint8)
    else:
        shifted = (shifted.astype(np.float32) * mask).astype(np.uint8)
    
    return shifted
    

    def load_images_from_folder(folder): images = [] for filename in os.listdir(folder): if filename.lower().endswith((".png", ".jpg", ".jpeg")): path = os.path.join(folder, filename) img = cv2.imread(path) if img is not None and img.shape[0] > 0 and img.shape[1] > 0: images.append(img) random.shuffle(images) return images

    from pydub import AudioSegment

    def get_beat_times(audio_path, frame_ms=50, energy_threshold_factor=1.3): audio = AudioSegment.from_file(audio_path).set_channels(1) frame_length = frame_ms n_frames = len(audio) // frame_length energies = []

    for i in range(n_frames):
        frame = audio[i * frame_length: (i + 1) * frame_length]
        energies.append(frame.rms)
    
    energies = np.array(energies)
    avg_energy = np.mean(energies)
    beat_indices = []
    
    for i in range(1, len(energies) - 1):
        if energies[i] > energy_threshold_factor * avg_energy and energies[i] > energies[i - 1] and energies[i] > energies[i + 1]:
            beat_indices.append(i)
    
    beat_times = [i * frame_length / 1000.0 for i in beat_indices]
    
    filtered_beats = []
    min_separation = 1.0
    for t in beat_times:
        if len(filtered_beats) == 0 or (t - filtered_beats[-1]) > min_separation:
            filtered_beats.append(t)
    
    return filtered_beats
    

    def remover_silencio(audio_segment, silence_thresh=-50, min_silence_len=500, padding=300): nao_silencioso = detect_nonsilent(audio_segment, min_silence_len=min_silence_len, silence_thresh=silence_thresh) if not nao_silencioso: return audio_segment

    partes = []
    for start, end in nao_silencioso:
        start_pad = max(0, start - padding)
        end_pad = min(len(audio_segment), end + padding)
        partes.append(audio_segment[start_pad:end_pad])
    
    audio_sem_silencio = partes[0]
    for part in partes[1:]:
        audio_sem_silencio += AudioSegment.silent(duration=150) + part
    return audio_sem_silencio
    

    def create_video_only(video_path, duration, images, fps=30, progress_callback=None, change_times=None): if not images: raise ValueError("Lista de imagens vazia.")

    height, width, _ = images[0].shape
    total_frames = int(duration * fps)
    out = cv2.VideoWriter(video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height))
    
    img_index = 0
    efeitos = {
        "zoom": 0.15,
        "move": 0.15,
        "ken_burns": 0.15,
        "fast_zoom_blur": 0.10,
        "morph_transition": 0.10,
        "slide": 0.10,
        "gallery_slide": 0.10,
        "static": 0.15,
    }
    
    efeito_usado_count = {key: 0 for key in efeitos.keys()}
    
    def escolher_efeito(efeitos, efeito_usado_count):
        chances_ajustadas = {}
        for e, chance in efeitos.items():
            mult = 0.8 ** efeito_usado_count[e]
            chances_ajustadas[e] = chance * mult
        total = sum(chances_ajustadas.values())
        probs = [v / total for v in chances_ajustadas.values()]
        escolha = random.choices(list(chances_ajustadas.keys()), weights=probs, k=1)[0]
        efeito_usado_count[escolha] += 1
        return escolha
    
    morph_duration_frames = int(fps * 0.5)
    rapid_change_count = 0
    rapid_change_max = 7
    rapid_change_interval_frames = fps
    morph_active = False
    morph_frame = 0
    morph_from_img = None
    morph_to_img = None
    
    frames_per_image = int(3 * fps)
    if change_times is None or len(change_times) == 0:
        def random_interval_frames():
            return int(random.uniform(2.5, 4.0) * fps)
        frames_per_image = random_interval_frames()
        next_change_frame = frames_per_image
    else:
        change_frames = [int(t * fps) for t in change_times if t * fps < total_frames]
        if change_frames[-1] < total_frames - 1:
            change_frames.append(total_frames - 1)
        change_index = 0
        next_change_frame = change_frames[change_index]
    
    start_time = time.time()
    
    current_effect = None
    current_direction_zoom = None
    current_direction_move = None
    current_direction_ken = None
    current_direction_slide = None
    current_direction_static = None
    
    for i in range(total_frames):
    
        if rapid_change_count < rapid_change_max:
            if i % rapid_change_interval_frames == 0 and i != 0:
                img_index = (img_index + 1) % len(images)
                rapid_change_count += 1
                current_effect = None
                current_direction_zoom = None
                current_direction_move = None
                current_direction_ken = None
                current_direction_slide = None
                current_direction_static = None
        else:
            if change_times is None or len(change_times) == 0:
                if i >= next_change_frame:
                    img_index = (img_index + 1) % len(images)
                    frames_per_image = random_interval_frames()
                    next_change_frame = i + frames_per_image
                    current_effect = None
                    current_direction_zoom = None
                    current_direction_move = None
                    current_direction_ken = None
                    current_direction_slide = None
                    current_direction_static = None
            else:
                if i >= next_change_frame:
                    img_index = (img_index + 1) % len(images)
                    change_index += 1
                    if change_index < len(change_frames):
                        next_change_frame = change_frames[change_index]
                    else:
                        next_change_frame = total_frames + 1
                    current_effect = None
                    current_direction_zoom = None
                    current_direction_move = None
                    current_direction_ken = None
                    current_direction_slide = None
                    current_direction_static = None
    
        img = images[img_index]
    
        if change_times is not None and len(change_times) > 0 and i <= next_change_frame:
            prev_frame_change = change_frames[change_index - 1] if change_index > 0 else 0
            frame_in_image = i - prev_frame_change
            total_frames_for_image = next_change_frame - prev_frame_change
        else:
            total_frames_for_image = frames_per_image
            frame_in_image = i % frames_per_image
    
        progress = frame_in_image / total_frames_for_image if total_frames_for_image > 0 else 0
        progress = min(max(progress, 0), 1)
    
        if morph_active:
            if morph_frame < morph_duration_frames:
                frame = morph_transition_effect(morph_from_img, morph_to_img, morph_frame / morph_duration_frames)
                morph_frame += 1
                frame = move_effect(frame, progress, direction="left_to_right")
                frame = cv2.resize(frame, (width, height))
                out.write(frame)
                if progress_callback:
                    elapsed = time.time() - start_time
                    frames_done = i + 1
                    frames_left = total_frames - frames_done
                    eta = (elapsed / frames_done) * frames_left if frames_done > 0 else 0
                    progress_callback(frames_done, total_frames, eta)
                continue
            else:
                morph_active = False
                morph_frame = 0
                current_effect = None
    
        aplicar_morph = False
        if frame_in_image == 0 and random.random() < 0.2 and len(images) > 1:
            morph_active = True
            morph_frame = 0
            morph_from_img = img
            prox_img_index = (img_index + 1) % len(images)
            morph_to_img = images[prox_img_index]
            aplicar_morph = True
    
        if aplicar_morph:
            continue
    
        if current_effect is None:
            current_effect = escolher_efeito(efeitos, efeito_usado_count)
    
        if current_effect == "zoom":
            if current_direction_zoom is None:
                current_direction_zoom = random.choice(
                    ["center", "top", "bottom", "left", "right", "top_left", "top_right", "bottom_left", "bottom_right"])
            frame_effect = zoom_effect(img, progress, zoom_in=True, direction=current_direction_zoom)
            if current_direction_move is None:
                current_direction_move = random.choice(["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"])
            frame = move_effect(frame_effect, progress, direction=current_direction_move)
    
        elif current_effect == "move":
            if current_direction_move is None:
                current_direction_move = random.choice(["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"])
            frame = move_effect(img, progress, direction=current_direction_move)
    
        elif current_effect == "ken_burns":
            if current_direction_ken is None:
                current_direction_ken = random.choice(
                    ["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top", "top_left_to_bottom_right",
                     "bottom_right_to_top_left"])
            if current_direction_move is None:
                current_direction_move = random.choice(["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"])
            frame_effect = ken_burns_effect(img, progress, zoom_in=True, direction=current_direction_ken)
            frame = move_effect(frame_effect, progress, direction=current_direction_move)
    
        elif current_effect == "fast_zoom_blur":
            frame_effect = fast_zoom_blur_effect(img, progress)
            if current_direction_move is None:
                current_direction_move = random.choice(["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"])
            frame = move_effect(frame_effect, progress, direction=current_direction_move)
    
        elif current_effect == "slide":
            if current_direction_slide is None:
                current_direction_slide = random.choice(["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"])
            frame_effect = slide_effect(img, progress, direction=current_direction_slide)
            if current_direction_move is None:
                current_direction_move = random.choice(["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"])
            frame = move_effect(frame_effect, progress, direction=current_direction_move)
    
        elif current_effect == "gallery_slide":
            frame_effect = gallery_slide_effect(img, progress)
            if current_direction_move is None:
                current_direction_move = random.choice(["left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"])
            frame = move_effect(frame_effect, progress, direction=current_direction_move)
    
        elif current_effect == "static":
            if current_direction_move is None:
                current_direction_move = "left_to_right"
            frame = move_effect(img, progress, direction=current_direction_move)
    
        else:
            frame = img.copy()
    
        frame = cv2.resize(frame, (width, height))
        out.write(frame)
    
        if progress_callback:
            elapsed = time.time() - start_time
            frames_done = i + 1
            frames_left = total_frames - frames_done
            eta = (elapsed / frames_done) * frames_left if frames_done > 0 else 0
            progress_callback(frames_done, total_frames, eta)
    
    out.release()
    

    def merge_audio_with_video(video_path, audio_path, output_path): fundo_path = AUDIO_FUNDO audio1 = AudioSegment.from_file(audio_path).set_channels(2) audio2 = AudioSegment.from_file(fundo_path).set_channels(2)

    audio2 = audio2 - 1
    
    if len(audio2) < len(audio1):
        audio2 = audio2 * (len(audio1) // len(audio2) + 1)
    audio2 = audio2[:len(audio1)]
    
    combined = audio1.overlay(audio2)
    temp_audio_path = "combined_temp_audio.mp3"
    combined.export(temp_audio_path, format="mp3")
    
    command = [
        "ffmpeg",
        "-y",
        "-i",
        video_path,
        "-i",
        temp_audio_path,
        "-c:v",
        "copy",
        "-c:a",
        "aac",
        "-shortest",
        output_path,
    ]
    subprocess.run(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    os.remove(temp_audio_path)
    

    def create_video_with_audio(audio_path, images_folder, progress_callback=None): try: audio = AudioSegment.from_file(audio_path) except Exception as e: print(f"[ERRO] Falha ao carregar áudio: {e}") return

    silence_threshold = audio.dBFS - 14
    audio_sem_silencio = remover_silencio(audio, silence_thresh=silence_threshold, min_silence_len=400, padding=300)
    
    temp_audio_no_silencio = "temp_audio_no_silencio.mp3"
    audio_sem_silencio.export(temp_audio_no_silencio, format="mp3")
    
    duration_seconds = audio_sem_silencio.duration_seconds
    audio_name = os.path.splitext(os.path.basename(audio_path))[0]
    temp_video_path = f"{audio_name}_temp.mp4"
    final_video_path = f"{audio_name}.mp4"
    
    images = load_images_from_folder(images_folder)
    if not images:
        print("[ERRO] Nenhuma imagem válida encontrada.")
        return
    
    try:
        change_times = get_beat_times(temp_audio_no_silencio)
    
        def internal_progress(current_frame, total_frames, eta):
            if progress_callback:
                percent = int((current_frame / total_frames) * 100)
                eta_str = time.strftime("%M:%S", time.gmtime(max(0, eta)))
                progress_callback(percent, eta_str)
    
        create_video_only(temp_video_path, duration_seconds, images, fps=30, progress_callback=internal_progress, change_times=change_times)
    
        merge_audio_with_video(temp_video_path, temp_audio_no_silencio, final_video_path)
        os.remove(temp_video_path)
        os.remove(temp_audio_no_silencio)
        print(f"[SUCESSO] Vídeo final exportado: {final_video_path}")
    except Exception as e:
        print(f"[ERRO FATAL] Falha ao criar vídeo: {e}")
    

    def main(): root = Tk() app = MainApp(root) app.start()

    if name == "main": main() . a barra lateral só tá aparecendo no converso e conversão . adicione uma barra de rolagem do lado da tela para mim pode arrasta para baixo pós tem coisas saindo da tela e não consigo acessar . outra os numeros só tão aparecendo do lado quando eu adiciono um perfil no novo ou deleto um pq atualiza essa parte aí fica normal pq quando eu abro fica normal sem numero pode tirar a parte monitorar dessa parte pós não vou usar mas o dessa parte . "Por favor, me dê o código completo e integral da solução, linha por linha, sem resumir ou omitir nada, mesmo que seja um código muito longo. Divida em partes se necessário, mas garanta que todas as funções, classes e trechos estejam presentes na íntegra." não quero comentários do tipo “o restante do código é este ou aquele” — tudo deve ser escrito. quero um perfil embaixo do outro e tá sem a barra lateral para descer a hub . chat me de tudo mesmo que o codigo fique gigante e passe do limite faça o codigo completo mesmo que fique longo pfv você tá abreviando partes do codigo me de completo sem abreviar pfv escreva todas as partes linha por linha não tente me enganar . não pessa para minha incluir nem nada escreva você tudo. preciso dela na parte de agendador e upload quero que mude o designer todo e organize tudo de forma inteligente na hub adicione na lateral de todas abas a barra de rolagem e deixe em mode janela normal deixe os botões de perfils pequenos tamanho padrão que tem os nomes dos perfils no campo perfils para monitoramento tire essa parte de perfis para monitoralmento remova esse campo deixe apenas os perfis em quadrados pequeno organizados com o numero do lado para mim colocar de quantos lotes quero que ele envie caso tiver 0 ele não envia nada para aquele. faça essa modificação

  2. Assistant

    Entendido. Você quer que eu te forneça o código completo da aplicação, refeito para:

    • Adicionar barra de rolagem lateral em todas as abas principais (incluindo Criador de Enredo, Criar Vídeos, Monitor Conversão e Agendador & Upload), para que todo conteúdo fique acessível em janela normal (não maximinada).
    • Remover da aba "Agendador & Upload" o campo de 'Perfis para monitoramento' (ou seja, a seção com os botões para ativar monitoramento que antes estavam em frame_autorizacao), pois você não usará essa funcionalidade.
    • Em vez disso, na aba Agendador deixar somente os perfis organizados em botões pequenos (quadrados) um embaixo do outro, cada um com um campo ao lado onde você informa quantos lotes de vídeos quer enviar para aquele perfil. Se indicado "0" não deve enviar nada.
    • Organizar o design da aba Agendador de forma inteligente, compacta e clara.
    • A janela principal deve abrir em modo janela normal (não maximizada).
    • As barras de rolagem laterais devem aparecer no painel lateral de todas abas.
    • Os botões dos perfis devem estar menores no Agendador, alinhados verticalmente, com um campo numérico ao lado de cada perfil para dizermos quantos lotes enviar.
    • Botões e campos devem ter tamanho padrão/pequeno (bons para uma interface clara e organizada).

    Eu vou direto reescrever o código integral, considerando as alterações somente.

    Para facilitar, vou dividir a resposta em partes para não passar do limite. A cada parte enviarei trecho integral de código e logo continuo na próxima resposta.


    Parte 1 — Código Integral atualizado da aplicação

    import os
    import time
    import threading
    import random
    import subprocess
    import string
    import re
    import shutil
    import pickle
    import sqlite3
    from datetime import datetime, timedelta, timezone
    from tkinter import (
        Tk, Frame, Button, Text, Entry, Label, messagebox, END, Scrollbar, filedialog, simpledialog,
        Listbox, VERTICAL, SINGLE, RIGHT, Y, LEFT, BOTH, StringVar, OptionMenu, scrolledtext, Toplevel, Canvas
    )
    import tkinter as tk
    from tkinter import LabelFrame
    from tkinter.ttk import Notebook, Progressbar, Combobox, Style
    import pyperclip
    import cv2
    from pydub import AudioSegment
    from pydub.silence import detect_nonsilent
    import numpy as np
    from googleapiclient.discovery import build
    from googleapiclient.http import MediaFileUpload
    import pytz
    
    # CONSTANTES E PASTAS
    PASTA_CATEGORIAS = r"C:\Users\jonathan\Desktop\AUTLAND\CATEGORIAS DE IMAGENS VIDEO"
    AUDIO_FUNDO = r"C:\Users\jonathan\Desktop\AUTLAND\TRILHA SONORA\soundfund.mp3"
    PASTA_DESTINO_VIDEOS = r"C:\Users\jonathan\Desktop\FINANCE CHANEEL\VIDEO PARA POSTAR PRONTOS"
    PASTA_TRUMP_AUDIOS = r"C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS TRUMP"
    PASTA_WARREN_AUDIOS = r"C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS WARREN"
    PASTA_TRUMP_IMAGENS = r"C:\Users\jonathan\Desktop\AUTLAND\CATEGORIAS DE IMAGENS VIDEO\TRUMP"
    PASTA_WARREN_IMAGENS = r"C:\Users\jonathan\Desktop\AUTLAND\CATEGORIAS DE IMAGENS VIDEO\WARREN"
    PASTA_TRUMP_DESTINO = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO TRUMP"
    PASTA_WARREN_DESTINO = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO WARREN"
    
    DOWNLOADS_FOLDER = r'C:\Users\jonathan\Downloads'
    OUTPUT_WARREN = r'C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS WARREN'
    OUTPUT_TRUMP = r'C:\Users\jonathan\Desktop\AUTLAND\AUDIOS\AUDIOS TRUMP'
    
    DB_PATH = r"C:\Users\jonathan\Desktop\FINANCE CHANEEL\monitorador_juntador.db"
    HORARIOS_DIA = [5, 6, 7, 8]
    
    DEFAULT_DESCRIPTION = """
    In this video, we reveal the shocking truth behind Warren Buffett’s boldest move ever — and what it could mean for the future of the market. Is a crash on the horizon? Don’t miss these crucial insights!
    ⏱️ Chapters
    0:00 - Introduction
    0:45 - What Just Happened
    2:10 - Deep Dive into the Situation
    3:00 - Final Thoughts and Predictions
    8:45 - Outro
    
    📢 Subscribe now for more eye-opening financial insights!
    #finance #investing #stockmarket #breakingnews #wealth
    """
    
    DEFAULT_TAGS = [
        "Warren Buffett sells biggest stock",
        "Buffett stock sale 2025",
        "Wall Street reaction Buffett",
        "Warren Buffett stock market news",
        "Buffett biggest investment sold",
        "Buffett stock dump explained",
        "Warren Buffett investing",
        "stock market news 2025",
        "Buffett sell off impact",
        "Warren Buffett market strategy",
        "investment advice Buffett",
        "Buffett latest moves",
        "Wall Street freak out Buffett",
        "trump",
        "trump tarrifs"
    ]
    
    MONITOR_PASTA_TRUMP = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO TRUMP"
    MONITOR_PASTA_WARREN = r"C:\Users\jonathan\Desktop\AUTLAND\POSTAGEM\VIDEO WARREN"
    
    THUMB_TRUMP_FOLDER = r"C:\Users\jonathan\Desktop\AUTLAND\THUMBNAILS\TUMB TRUMP"
    THUMB_WARREN_FOLDER = r"C:\Users\jonathan\Desktop\AUTLAND\THUMBNAILS\TUMB WARREN"
    
    # Helper para limpar nomes de arquivos
    def limpar_nome(texto):
        return re.sub(r'[\/*?:"<>|]', "", texto.strip())
    
    
    class MainApp:
        COR_FUNDO = "#000000"
        COR_TEXTO = "#FFFFFF"
        COR_BOTAO = "#00FF00"
        COR_BOTAO_HOVER = "#00CC00"
        COR_TEXTO_BOTAO = "#FFFFFF"
        FONT_TITULO = ("Segoe UI Semibold", 14)
        FONT_DEFAULT = ("Segoe UI", 11)
        FONT_LOG = ("Consolas", 11)
    
        def __init__(self, root):
            self.root = root
            root.title("Sistema Integrado - Criador, Editor, Monitor e Agendador")
            root.geometry("1280x720")
            root.configure(bg=self.COR_FUNDO)
            # root.state('zoomed') # removido para abrir em janela normal
    
            style = Style()
            style.theme_use('default')
            style.configure('TNotebook', background=self.COR_FUNDO, borderwidth=0)
            style.configure('TNotebook.Tab', background="#003300", foreground=self.COR_TEXTO,
                            font=("Segoe UI Semibold", 11))
            style.map('TNotebook.Tab', background=[('selected', '#00FF00')], foreground=[('selected', '#000000')])
    
            self.main_frame = Frame(root, bg=self.COR_FUNDO)
            self.main_frame.pack(expand=True, fill=BOTH)
    
            self.top_controls_frame = Frame(self.main_frame, bg=self.COR_FUNDO)
            self.top_controls_frame.pack(side='top', fill='x', padx=10, pady=5)
    
            self.master_monitor_button = Button(
                self.top_controls_frame, text="Ativar TODOS Monitores",
                bg=self.COR_BOTAO, fg=self.COR_TEXTO_BOTAO,
                font=self.FONT_DEFAULT, relief='flat', padx=10, pady=6,
                command=self.toggle_all_monitors
            )
            self.master_monitor_button.pack(side='left', padx=5)
    
            self.refresh_stats_button = Button(
                self.top_controls_frame, text="Atualizar Estatísticas",
                bg=self.COR_BOTAO, fg=self.COR_TEXTO_BOTAO,
                font=self.FONT_DEFAULT, relief='flat', padx=10, pady=6,
                command=self.atualizar_estatisticas
            )
            self.refresh_stats_button.pack(side='left', padx=5)
    
            self.notebook = Notebook(self.main_frame)
            self.notebook.pack(expand=True, fill='both', padx=15, pady=10)
    
            self.frame_criador_enredo = CriadorEnredoFrame(self.notebook, self)
            self.frame_video_editor = VideoEditorFrame(self.notebook, self)
            self.frame_monitor_conversion = MonitorConversionFrame(self.notebook, self)
            self.frame_agendador_upload = AgendadorFrame(self.notebook, self)
    
            self.notebook.add(self.frame_criador_enredo, text="Criador de Enredo")
            self.notebook.add(self.frame_video_editor, text="Criar Vídeos")
            self.notebook.add(self.frame_monitor_conversion, text="Monitor Conversão")
            self.notebook.add(self.frame_agendador_upload, text="Agendador & Upload")
    
            # Mini monitor permanece igual
            self.mini_monitor_window = MiniMonitorWindow(self.root)
    
            self.monitors_ativos = {
                'audio_folder_monitor': False,
                'video_conversion_monitor': False,
                'youtube_upload_monitor': False,
            }
    
            self.monitor_threads = {}
            self.perfis_autorizados = {}
            self.botoes_perfis = {}
    
            self.enviado_por_perfil = {}
    
            self.init_db()
    
            self.atualizar_perfis()
            self.construir_lista_perfis_autorizados()
    
            self.root.after(30000, self.periodic_estatisticas_update)
    
        def init_db(self):
            conn = sqlite3.connect(DB_PATH)
            c = conn.cursor()
            c.execute('''
                CREATE TABLE IF NOT EXISTS videos (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    filename TEXT UNIQUE,
                    title TEXT,
                    channel TEXT,
                    schedule_time TEXT
                )
            ''')
            c.execute('''
                CREATE TABLE IF NOT EXISTS perfis (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    nome TEXT UNIQUE,
                    credentials BLOB,
                    canal TEXT
                )
            ''')
            conn.commit()
            conn.close()
    
        def get_perfis(self):
            conn = sqlite3.connect(DB_PATH)
            c = conn.cursor()
            c.execute("SELECT id, nome, canal FROM perfis")
            perfis = c.fetchall()
            conn.close()
            return perfis
    
        def add_perfil(self, nome, credentials_blob, canal):
            conn = sqlite3.connect(DB_PATH)
            c = conn.cursor()
            c.execute("INSERT OR REPLACE INTO perfis (nome, credentials, canal) VALUES (?, ?, ?)", (nome, credentials_blob, canal))
            conn.commit()
            conn.close()
    
        def delete_perfil(self, nome):
            conn = sqlite3.connect(DB_PATH)
            c = conn.cursor()
            c.execute("DELETE FROM perfis WHERE nome=?", (nome,))
            conn.commit()
            conn.close()
    
        def atualizar_perfis(self):
            perfis = self.get_perfis()
            self.frame_agendador_upload.atualizar_dropdown_perfis(perfis)
    
        def construir_lista_perfis_autorizados(self):
            perfis = self.get_perfis()
            for widget in self.frame_agendador_upload.frame_autorizacao.winfo_children():
                widget.destroy()
            self.botoes_perfis = {}
            self.perfis_autorizados = {}
            for p in perfis:
                nome = p[1]
                self.perfis_autorizados[nome] = False
                btn = Button(self.frame_agendador_upload.frame_autorizacao, text=nome, width=15,
                             bg="red", fg="white", relief="raised", font=self.FONT_DEFAULT)
                btn.pack(side="left", padx=3, pady=3)
                btn.config(command=lambda n=nome, b=btn: self.toggle_autorizacao(n, b))
                self.botoes_perfis[nome] = btn
    
        def toggle_autorizacao(self, nome_perfil, botao):
            atual = self.perfis_autorizados.get(nome_perfil, False)
            self.perfis_autorizados[nome_perfil] = not atual
            botao.config(bg="green" if not atual else "red")
            self.rebuild_perfis_enviar_ordenados()
    
        def rebuild_perfis_enviar_ordenados(self):
            self.perfis_enviar_ordenados = [p for p, aut in self.perfis_autorizados.items() if aut]
            self.indice_proximo_perfil = 0 if not hasattr(self, 'indice_proximo_perfil') else self.indice_proximo_perfil
            if self.indice_proximo_perfil >= len(self.perfis_enviar_ordenados):
                self.indice_proximo_perfil = 0
    
        def toggle_all_monitors(self):
            novo_estado = not all(self.monitors_ativos.values())
            if novo_estado:
                if not self.monitors_ativos['audio_folder_monitor']:
                    self.frame_video_editor.toggle_monitoring(force_state=True)
                if not self.monitors_ativos['video_conversion_monitor']:
                    self.frame_monitor_conversion.toggle_monitoring(force_state=True)
                if not self.monitors_ativos['youtube_upload_monitor']:
                    self.frame_agendador_upload.toggle_monitoramento(force_state=True)
                messagebox.showinfo("Monitores", "Todos os monitores ativados.")
            else:
                if self.monitors_ativos['audio_folder_monitor']:
                    self.frame_video_editor.toggle_monitoring(force_state=False)
                if self.monitors_ativos['video_conversion_monitor']:
                    self.frame_monitor_conversion.toggle_monitoring(force_state=False)
                if self.monitors_ativos['youtube_upload_monitor']:
                    self.frame_agendador_upload.toggle_monitoramento(force_state=False)
                messagebox.showinfo("Monitores", "Todos os monitores desativados.")
            self.monitors_ativos['audio_folder_monitor'] = self.frame_video_editor.monitoring_active
            self.monitors_ativos['video_conversion_monitor'] = self.frame_monitor_conversion.monitorando
            self.monitors_ativos['youtube_upload_monitor'] = self.frame_agendador_upload.monitorando_youtube
    
        def atualizar_estatisticas(self):
            self.frame_agendador_upload.criar_ou_atualizar_estatisticas()
    
        def periodic_estatisticas_update(self):
            self.atualizar_estatisticas()
            self.root.after(30000, self.periodic_estatisticas_update)
    
        def start(self):
            self.root.mainloop()
    
    # A função gerar_prompt permanece a mesma
    
    def gerar_prompt(titulo):
        return f"""Agora você é um roteirista profissional de YouTube e vai criar um script sobre:{titulo}.
    Por favor, faça isso sem marcações de transições ou cenas, quero apenas a frase do narrador não coloque o titulo no começoapenas texto. . Introdução (300-500 palavras): Apresente o tema de forma clara e envolvente. Use uma anedota ou pergunta intrigante para capturar a atenção. Explique brevemente o que será abordado no vídeo e por que é relevante para o espectador. Desenvolvimento (2.000-2.200 palavras): Divida em seções claras e bem organizadas, cada uma abordando um ponto específico. Mantenha a fluidez e transições suaves entre as seções. Ofereça informações relevantes, dados, exemplos, e insights que agreguem valor. Faça perguntas retóricas para estimular o pensamento e a reflexão. Interação com o Público (200-300 palavras): No meio do vídeo, introduza um momento para incentivar os espectadores a se inscreverem no canal. Relacione isso ao conteúdo que está sendo apresentado. Peça para os espectadores compartilharem suas opiniões nos comentários sobre o tema abordado. Conclusão (300-500 palavras): Resuma os pontos principais discutidos no vídeo. Reforce a importância do tema e convide os espectadores a aplicarem o que aprenderam. Finalize com um convite para que assistam a outros vídeos do canal e deixem o like se gostaram do conteúdo. Dicas Adicionais: Mantenha um tom de conversa natural e envolvente. Evite longas explicações e vá direto ao ponto. Use exemplos práticos e histórias pessoais para conectar com o público. E se você quer ir além, assista esse vídeo aqui do lado que aprofunda ainda mais no passo 2 que falei aqui."O vídeo deve terminar com um gancho para outro conteúdo (evitando um final seco). Incentive a interação de forma natural. Exemplo: “Se achou isso absurdo, espere até descobrir o que acontece no Catar…” Forneça um script contendo aproximadamente 3000 palavras para um vídeo do YouTube, vou contar as palavras, então, não tente me enganar!. 2 partes de 1500 totalizando 3000 palavras. Forneça o texto em inglês, adaptando para a cultura daquele país quando necessário, deixando ele fluído e natural, adicione o título escolhido e por favor não divida o texto, quero apenas o que deve ser dito pelo narrador. É importante que seja um texto longo sobre [assunto]. Não inclua títulos, subtítulos, perguntas ou qualquer tipo de formatação extra. Quero apenas o texto bruto, sem nada além da escrita. Nada disso "Sure. Here’s Part 1 of the full script, written exactly as requested — dense, conversational, and designed for YouTube high-retention storytelling, all in English. It contains exactly 3000 words." nada disso no final. "Let me know se você quer que eu continue com a Parte 2, com mais 3000 palavras, seguindo exatamente o mesmo estilo." não pergunte e nem escreva nada no final quero que você crie algo único que nunca tenha feito ATENÇÃO QUERO SOMENTE O TEXTO NADA DE TITULO NEM SUBTITULO, NADA DE PERGUNTAS APENAS O CAMPO COM TEXTO E HISTORIA PÓS IREI COPIAR E NÃO QUERO QUE COPIE NADA ALÉM DO TEXTO. . em ingles"""
    
    
    # ----- Frame CriadorEnredoFrame sem alterações (ícone de scroll lateral mostrado por padrão na Text, mas pode colocar scroll explicitamente) -----
    
    class CriadorEnredoFrame(Frame):
        def __init__(self, parent, main_app):
            super().__init__(parent, bg=main_app.COR_FUNDO)
            self.main_app = main_app
            self.titulos = []
            self.index = 0
            self.titulo_atual = ""
    
            Label(self, text="Criador de Enredo", font=main_app.FONT_TITULO,
                  bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO).pack(pady=7)
    
            Label(self, text="Cole os títulos (um por linha):",
                  bg=main_app.COR_FUNDO, fg=main_app.COR_TEXTO, font=main_app.FONT_DEFAULT).pack()
            
            # Frame com canvas para scrollbar lateral do texto
            frame_text = Frame(self, bg=main_app.COR_FUNDO)
            frame_text.pack(padx=10, pady=5, fill=BOTH, expand=True)
            self.text_scrollbar = Scrollbar(frame_text)
            self.text_scrollbar.pack(side=RIGHT, fill=Y)
            self.text_input = Text(frame_text, height=10, width=80,
                                   bg="#101010", fg=main_app.COR_TEXTO,
                                   insertbackground=main_app.COR_TEXTO, font=main_app.FONT_DEFAULT,
                                   yscrollcommand=self.text_scrollbar.set, wrap="word")
            self.text_input.pack(side=LEFT, fill=BOTH, expand=True)
            self.text_scrollbar.config(command=self.text_input.yview)
    
            btn_copiar_titulo_frame = Frame(self, bg=main_app.COR_FUNDO)
            btn_copiar_titulo_frame.pack(pady=(7, 12))
            self.btn_copiar_titulo_atual = Button(btn_copiar_titulo_frame, text="Copiar Título Atual",
                                                  command=self.copiar_titulo_atual,
                                                  state="disabled", bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                                                  relief="flat", activebackground=main_app.COR_BOTAO_HOVER,
                                                  activeforeground=main_app.COR_TEXTO_BOTAO,
                                                  font=main_app.FONT_DEFAULT, padx=10, pady=5)
            self.btn_copiar_titulo_atual.pack()
    
            self.avancar_button = Button(self, text="Avançar", command=self.iniciar_prompts,
                                        bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO,
                                        relief="flat", activebackground=main_app.COR_BOTAO_HOVER,
                                        activeforeground=main_app.COR_TEXTO_BOTAO,
                                        font=main_app.FONT_DEFAULT, padx=12, pady=6)
            self.avancar_button.pack(pady=12)
    
            # Frame para output com scroll lateral - para prompts mais longos
            frame_output = Frame(self, bg=main_app.COR_FUNDO)
            frame_output.pack(padx=10, pady=5, fill=BOTH, expand=True)
            self.output_scrollbar = Scrollbar(frame_output)
            self.output_scrollbar.pack(side=RIGHT, fill=Y)
            self.prompt_output = Text(frame_output, height=20, width=100, wrap="word",
                                     bg="#101010", fg=main_app.COR_TEXTO, insertbackground=main_app.COR_TEXTO,
                                     font=main_app.FONT_LOG,
                                     yscrollcommand=self.output_scrollbar.set)
            self.prompt_output.pack(side=LEFT, fill=BOTH, expand=True)
            self.output_scrollbar.config(command=self.prompt_output.yview)
            self.prompt_output.config(state="disabled")
    
            btn_frame = Frame(self, bg=main_app.COR_FUNDO)
            btn_frame.pack(pady=8)
            Button(btn_frame, text="Copiar Prompt", command=self.copiar_prompt,
                   bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO, relief="flat",
                   activebackground=main_app.COR_BOTAO_HOVER, activeforeground=main_app.COR_TEXTO_BOTAO,
                   font=main_app.FONT_DEFAULT, padx=10, pady=5).grid(row=0, column=0, padx=8)
            Button(btn_frame, text="Próximo", command=self.proxima_prompt,
                   bg=main_app.COR_BOTAO, fg=main_app.COR_TEXTO_BOTAO, relief="flat",
                   activebackground=main_app.COR_BOTAO_HOVER, activeforeground=main_app.COR_TEXTO_BOTAO,
                   font=main_app.FONT_DEFAULT, padx=10, pady=5).grid(row=0, column=1, padx=8)
    
        def iniciar_prompts(self):
            self.titulos = [linha.strip() for linha in self.text_input.get("1.0", END).splitlines() if linha.strip()]
            self.index = 0
            if not self.titulos:
                messagebox.showerror("Erro", "Por favor, insira pelo menos um título.")
                self.btn_copiar_titulo_atual.config(state="disabled")
                return
            self.mostrar_prompt()
    
        def mostrar_prompt(self):
            if self.index < len(self.titulos):
                self.titulo_atual = self.titulos[self.index]
                self.btn_copiar_titulo_atual.config(state="normal")
                prompt = gerar_prompt(self.titulo_atual)
                self.prompt_output.config(state="normal")
                self.prompt_output.delete("1.0", END)
                self.prompt_output.insert(END, prompt)
                self.prompt_output.config(state="disabled")
            else:
                self.titulo_atual = ""
                self.btn_copiar_titulo_atual.config(state="disabled")
                self.prompt_output.config(state="normal")
                self.prompt_output.delete("1.0", END)
                self.prompt_output.insert(END, "Todos os prompts foram gerados.")
                self.prompt_output.config(state="disabled")
    
        def copiar_prompt(self):
            texto = self.prompt_output.get("1.0", END).strip()
            pyperclip.copy(texto)
            messagebox.showinfo("Copiado", "Prompt copiado para a área de transferência!")
    
        def copiar_titulo_atual(self):
            if self.titulo_atual:
                pyperclip.copy(self.titulo_atual)
                messagebox.showinfo("Copiado", f"Título '{self.titulo_atual}' copiado para a área de transferência!")
            else:
                messagebox.showwarning("Aviso", "Nenhum título para copiar.")
    
        def proxima_prompt(self):
            self.index += 1
            self.mostrar_prompt()
    
    

    Próxima parte (Parte 2) contém o Frame VideoEditorFrame refeito para barra lateral, e também a aba MonitorConversionFrame com barra, depois modificações na aba Agendador conforme solicitado. Vou enviar a próxima parte já.