Update app.py

Atualização com as novas implementações da Aula 12

app.py

@@ -1,20 +1,28 @@
 # CHATBOT E GERADOR DE POSTS PARA REDES SOCIAIS
-# Aula 9: Versão Web com Hugging Face Spaces + Gradio
-# Versão com persistência de dados via Firebase Admin
-# ATUALIZADO: Adicionada funcionalidade de Chatbot e Geração Avançada de Imagens
+# VERSÃO COMPLETA (MERGE)
+# Funcionalidades:
+# - Geração Avançada de Imagem (Estilo, Qualidade, Filtro)
+# - Download de Post Composto (Imagem + Texto)
+# - Chatbot Assistente
+# - Sistema de Cache local
+# - Persistência de Histórico e Analytics no Firebase
+# - Aba de Histórico com Busca, Filtros e Favoritos
+# - Carregamento de posts antigos do histórico
 
 import gradio as gr
 import requests
 import os
-import json # Importar para carregar o JSON da Service Account
-import time # Adicionado para a nova função de progresso
+import json
+import time
 from datetime import datetime
 from zoneinfo import ZoneInfo
 from PIL import Image, ImageDraw, ImageFont
 from io import BytesIO
 from huggingface_hub import InferenceClient
-import tempfile # Para criar arquivos de download
-import textwrap # Para quebrar o texto no post final
+from pathlib import Path
+import hashlib
+import tempfile
+import textwrap
 
 # Importar firebase-admin
 import firebase_admin
@@ -27,12 +35,11 @@ HUGGINGFACE_API_KEY = os.environ.get("Capoeira")
 if not HUGGINGFACE_API_KEY:
     print("⚠️ API Key do Hugging Face não configurada! Certifique-se de que a variável de ambiente 'Capoeira' está definida.")
 
-# URLs e modelos (SEM símbolos < >)
+# URLs e modelos
 BASE_URL = "https://router.huggingface.co/v1"
 MODELO_TEXTO = "meta-llama/Llama-3.1-8B-Instruct"
 MODELO_TRADUCA = "Helsinki-NLP/opus-mt-pt-en"
 
-# ATUALIZADO: Lista de modelos de imagem
 MODELOS_IMAGEM = [
     {
         "nome": "FLUX.1-schnell",
@@ -54,7 +61,6 @@ MODELOS_IMAGEM = [
     }
 ]
 
-
 # Headers para requisições
 headers = {
     "Authorization": f"Bearer {HUGGINGFACE_API_KEY}",
@@ -84,7 +90,6 @@ ESTILOS_DISPONIVEIS = [
     "Tutorial/Passo a Passo",
 ]
 
-# NOVO: Dicionário de estilos de imagem (baseado na Solicitação 2)
 ESTILOS_DE_IMAGEM = {
     "Nenhum (Automático)": "standard photography, high quality, 4k",
     "Fotografia Vintage": "vintage photography, retro style, film grain, analog",
@@ -103,8 +108,6 @@ ESTILOS_DE_IMAGEM = {
     "Minimalista": "minimalist, clean background, simple, elegant",
 }
 
-
-# NOVO: Dicionário de filtros de imagem
 FILTROS_IMAGEM = {
     "Nenhum": "",
     "Preto e Branco": "black and white, monochrome, high contrast",
@@ -114,23 +117,23 @@ FILTROS_IMAGEM = {
     "Frio (Moderno)": "cool tones, modern aesthetic, clean, desaturated blues",
 }
 
-
-# CORRIGIDO: O dicionário do LinkedIn estava quebrado
-# ATUALIZADO: Funcionalidade de formato reativada (Solicitação 1)
 FORMATO_CONFIGS = {
     "Instagram (Post)": {"tamanho": "100-150 palavras", "estrutura": "gancho inicial + desenvolvimento + call-to-action", "tom_adicional": "próximo, empático e motivador", "max_tokens": 350, "limite_palavras_ia": "150 palavras", "hashtags": "Incluir 4-5 hashtags relevantes no final. Incluir no máximo 3 emojis relevantes no texto."},
     "Twitter/X (Curto)": {"tamanho": "Até 280 caracteres", "estrutura": "frase de impacto + link/hashtag", "tom_adicional": "direto e conciso, ideal para tweets", "max_tokens": 150, "limite_palavras_ia": "280 caracteres", "hashtags": "Incluir no máximo 2 hashtags."},
+    # CORREÇÃO: A vírgula entre "autoritário" e "focado" foi removida, unindo as duas strings.
     "LinkedIn (Artigo)": {"tamanho": "250-400 palavras", "estrutura": "título chamativo + desenvolvimento profissional + reflexão", "tom_adicional": "profissional e autoritário, focado em insights", "max_tokens": 700, "limite_palavras_ia": "400 palavras", "hashtags": "Incluir 3-4 hashtags profissionais no final."},
 }
 
-# Variável global para armazenar o histórico de sessão (agora é um cache)
-post_history = []
-# Variável para a instância do Firestore
+# Variáveis globais
 db = None
+post_history = []
+analytics = {}
+CACHE_DIR = Path("post_cache")
+CACHE_DIR.mkdir(exist_ok=True)
 
 
 # ============================================
-# FUNÇÕES DE PERSISTÊNCIA (FIREBASE ATIVADO)
+# FUNÇÕES DE PERSISTÊNCIA (FIREBASE)
 # ============================================
 
 def _inicializar_firestore():
@@ -138,9 +141,8 @@ def _inicializar_firestore():
     Inicializa o Firebase Admin SDK usando as credenciais
     armazenadas nos Secrets do Hugging Face Spaces.
     """
-    global db
+    global db, analytics
     
-    # Nome do Secret que você criou no HF Spaces
     secret_name = "FIREBASE_SERVICE_ACCOUNT_JSON"
     secret_json_string = os.environ.get(secret_name)
 
@@ -148,30 +150,26 @@ def _inicializar_firestore():
         print(f"❌ Erro de Configuração do Firebase: Secret '{secret_name}' não encontrado.")
         print("Usando apenas histórico de sessão (temporário).")
         db = None
+        analytics = {"status": "Não conectado"}
         return
 
     if not firebase_admin._apps:
         try:
-            # Converter a string JSON (do Secret) em um dicionário
             service_account_info = json.loads(secret_json_string)
-            
-            # Usar o dicionário para criar as credenciais
             cred = credentials.Certificate(service_account_info)
-            
             firebase_admin.initialize_app(cred)
             db = firestore.client()
             print("✅ Firestore inicializado com sucesso.")
+            # Inicializar/Carregar Analytics do Firestore
+            _carregar_analytics_firestore()
         except Exception as e:
             print(f"❌ Erro ao inicializar Firestore. Usando histórico de sessão. Detalhe: {e}")
             db = None
+            analytics = {"status": f"Erro de conexão: {e}"}
 
 def _adicionar_post_firestore(entry):
-    """
-    Adiciona um novo documento à coleção 'posts' no Firestore.
-    """
     if db:
         try:
-            # Adiciona o dicionário 'entry' como um novo documento
             db.collection('posts').add(entry)
             return True
         except Exception as e:
@@ -180,16 +178,10 @@ def _adicionar_post_firestore(entry):
     return False
 
 def _obter_historico_firestore():
-    """
-    Obtém os últimos 50 documentos da coleção 'posts', ordenados por data.
-    Retorna uma lista de dicionários.
-    """
     if db:
         try:
-            # Query para buscar posts, ordenar pelo campo 'Data/Hora' em ordem descendente, limitando a 50
-            posts_query = db.collection('posts').order_by('Data/Hora', direction=firestore.Query.DESCENDING).limit(50)
+            posts_query = db.collection('posts').order_by('Data/Hora', direction=firestore.Query.DESCENDING).limit(100) # Aumentado limite para busca
             posts_stream = posts_query.stream()
-            
             history = [post.to_dict() for post in posts_stream]
             return history
         except Exception as e:
@@ -198,66 +190,229 @@ def _obter_historico_firestore():
     return []
 
 def atualizar_historico(entry):
-    """
-    Função unificada para salvar no Firestore E atualizar o cache de sessão.
-    """
+    """Salva no Firestore e atualiza o cache de sessão local."""
     global post_history
-    
-    # Tenta salvar no Firestore
     _adicionar_post_firestore(entry)
-    
-    # Atualiza o cache de sessão local (para a UI)
+    # Adiciona no início da lista local
     post_history.insert(0, entry)
-    
+    # Garante que a lista local não cresça indefinidamente
+    if len(post_history) > 100:
+        post_history = post_history[:100]
     return post_history
 
 def carregar_historico_inicial():
-    """
-    Função para carregar o histórico ao iniciar o aplicativo.
-    Prioriza o DB e preenche o cache de sessão.
-    """
+    """Carrega o histórico do Firestore ao iniciar o app."""
     global post_history
-    
-    # Tenta carregar do Firestore
     historico_db = _obter_historico_firestore()
-    
     if historico_db:
         post_history = historico_db
-    
-    # Retorna o histórico (do DB ou vazio)
     return post_history
 
-# Inicializar Firestore ao carregar o app
-_inicializar_firestore()
+# ============================================
+# FUNÇÕES DE ANALYTICS
+# ============================================
+
+def _carregar_analytics_firestore():
+    """Carrega o documento único de analytics do Firestore."""
+    global analytics
+    if db:
+        try:
+            doc_ref = db.collection('analytics').document('summary')
+            doc = doc_ref.get()
+            if doc.exists:
+                analytics = doc.to_dict()
+                print("✅ Analytics carregados do Firestore.")
+            else:
+                # Se não existir, inicializa
+                analytics = {
+                    "total_posts": 0,
+                    "posts_por_nicho": {},
+                    "posts_por_estilo": {},
+                    "total_palavras": 0,
+                    "total_imagens": 0,
+                    "cache_hits": 0,
+                    "cache_misses": 0,
+                    "total_favoritos": 0 # Adicionado
+                }
+                doc_ref.set(analytics)
+                print("Analytics inicializados no Firestore.")
+        except Exception as e:
+            print(f"❌ Erro ao carregar Analytics: {e}")
+            analytics = {"status": f"Erro: {e}"}
+
+def _salvar_analytics_firestore():
+    """Salva o estado atual de analytics no Firestore."""
+    if db:
+        try:
+            db.collection('analytics').document('summary').set(analytics)
+            print("Analytics salvos no Firestore.")
+        except Exception as e:
+            print(f"❌ Erro ao salvar Analytics: {e}")
+
+def atualizar_analytics(nicho, estilo, palavras, imagem_gerada, cache_hit, favorito):
+    """Atualiza as métricas de analytics (agora salva no Firestore)."""
+    global analytics
+    
+    analytics['total_posts'] = analytics.get('total_posts', 0) + 1
+    analytics['total_palavras'] = analytics.get('total_palavras', 0) + palavras
+    
+    if imagem_gerada:
+        analytics['total_imagens'] = analytics.get('total_imagens', 0) + 1
+        
+    if cache_hit:
+        analytics['cache_hits'] = analytics.get('cache_hits', 0) + 1
+    else:
+        analytics['cache_misses'] = analytics.get('cache_misses', 0) + 1
+        
+    if favorito:
+        analytics['total_favoritos'] = analytics.get('total_favoritos', 0) + 1
+
+    # Atualizar contadores de nicho e estilo
+    nicho_counts = analytics.get('posts_por_nicho', {})
+    nicho_counts[nicho] = nicho_counts.get(nicho, 0) + 1
+    analytics['posts_por_nicho'] = nicho_counts
+    
+    estilo_counts = analytics.get('posts_por_estilo', {})
+    estilo_counts[estilo] = estilo_counts.get(estilo, 0) + 1
+    analytics['posts_por_estilo'] = estilo_counts
+    
+    # Salvar no Firestore
+    _salvar_analytics_firestore()
+
+def gerar_relatorio_analytics():
+    """Formata os dados de analytics para exibição no Gradio como Markdown."""
+    global analytics
+    if not analytics or 'status' in analytics or analytics.get("total_posts", 0) == 0:
+        return "📊 Nenhum post gerado ainda."
+        
+    # Ordenar os dicionários por valor (mais usados primeiro)
+    posts_por_nicho_sorted = dict(sorted(analytics.get('posts_por_nicho', {}).items(), key=lambda item: item[1], reverse=True))
+    posts_por_estilo_sorted = dict(sorted(analytics.get('posts_por_estilo', {}).items(), key=lambda item: item[1], reverse=True))
+
+    total_reqs = analytics.get('cache_hits', 0) + analytics.get('cache_misses', 0)
+    taxa_cache_hit = (analytics.get('cache_hits', 0) / total_reqs * 100) if total_reqs > 0 else 0
+    
+    nicho_top = max(analytics["posts_por_nicho"].items(), key=lambda x: x[1]) if analytics.get("posts_por_nicho") else ("N/A", 0)
+    estilo_top = max(analytics["posts_por_estilo"].items(), key=lambda x: x[1]) if analytics.get("posts_por_estilo") else ("N/A", 0)
+
+    relatorio = f"""📊 **RELATÓRIO DE ANALYTICS**
+**Geral:**
+• Total de posts: {analytics['total_posts']}
+• Total de palavras: {analytics['total_palavras']:,}
+• Total de imagens: {analytics['total_imagens']}
+• Total de favoritos: {analytics.get('total_favoritos', 0)}
+• Média de palavras/post: {analytics['total_palavras'] // analytics['total_posts'] if analytics['total_posts'] > 0 else 0}
+
+**Performance:**
+• Cache hits: {analytics['cache_hits']}
+• Cache misses: {analytics['cache_misses']}
+• Taxa de cache: {taxa_cache_hit:.1f}%
+
+**Preferências:**
+• Nicho mais usado: {nicho_top[0]} ({nicho_top[1]} posts)
+• Estilo mais usado: {estilo_top[0]} ({estilo_top[1]} posts)
+"""
+    return relatorio
+
+def resetar_analytics():
+    """Reseta os dados de analytics no Firestore e localmente."""
+    global analytics
+    analytics = {
+        "total_posts": 0,
+        "posts_por_nicho": {},
+        "posts_por_estilo": {},
+        "total_palavras": 0,
+        "total_imagens": 0,
+        "cache_hits": 0,
+        "cache_misses": 0,
+        "total_favoritos": 0
+    }
+    _salvar_analytics_firestore()
+    # Limpar cache local
+    for f in CACHE_DIR.glob('*'):
+        f.unlink()
+    print("Analytics e Cache resetados.")
+    return gerar_relatorio_analytics()
+
+
+# ============================================
+# FUNÇÕES DE CACHE
+# ============================================
+
+def criar_cache_key(tema, nicho, estilo, formato):
+    """Cria uma chave de hash SHA-256 para os inputs."""
+    input_string = f"{tema}-{nicho}-{estilo}-{formato}".encode('utf-8')
+    return hashlib.sha256(input_string).hexdigest()
+
+def salvar_no_cache(key, data):
+    """Salva os dados (texto e imagem) em cache."""
+    cache_file = CACHE_DIR / f"{key}.json"
+    with open(cache_file, 'w', encoding='utf-8') as f:
+        json.dump({"texto": data["texto"], "imagem_path": data.get("imagem_path")}, f)
+
+def buscar_no_cache(key):
+    """Busca dados do cache. Retorna (texto, imagem_path) ou (None, None)."""
+    cache_file = CACHE_DIR / f"{key}.json"
+    if cache_file.exists():
+        try:
+            with open(cache_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            texto = data.get("texto")
+            imagem_path = data.get("imagem_path")
+            imagem = None
+            
+            if imagem_path:
+                img_cache_file = CACHE_DIR / imagem_path
+                if img_cache_file.exists():
+                    imagem = Image.open(img_cache_file)
+                else:
+                    return None, None
+            
+            return texto, imagem
+        except Exception as e:
+            print(f"Erro ao ler cache {key}: {e}")
+            return None, None
+    return None, None
+
+def salvar_imagem_cache(key, imagem_pil):
+    """Salva a imagem PIL no diretório de cache e retorna o nome do arquivo."""
+    if not imagem_pil:
+        return None
+    
+    try:
+        imagem_path = f"{key}_img.png"
+        imagem_pil.save(CACHE_DIR / imagem_path)
+        return imagem_path
+    except Exception as e:
+        print(f"Erro ao salvar imagem no cache: {e}")
+        return None
 
 # ============================================
-# HELPER FUNCTION PARA GRADIO
+# HELPER FUNCTIONS
 # ============================================
+
 def _formatar_historico_para_df(history_list):
-    """
-    Converte a lista de dicionários (do Firestore) para uma
-    lista de listas (para o gr.Dataframe).
-    """
+    """Formata a lista de histórico (dicionários) para o Dataframe (lista de listas)."""
     formatted_list = []
     if not history_list:
         return []
         
-    # A ordem DEVE bater com os headers do gr.Dataframe
+    # Colunas: ["⭐", "Data/Hora", "Tema", "Nicho", "Estilo", "Formato", "Texto (Preview)", "Status"]
     for entry in history_list:
+        texto_preview = entry.get("Texto", "")[:100].replace('\n', ' ') + "..."
         formatted_list.append([
+            "⭐" if entry.get("Favorito") else "",
             entry.get("Data/Hora", ""),
             entry.get("Tema", ""),
             entry.get("Nicho", ""),
             entry.get("Estilo", ""),
             entry.get("Formato", ""),
-            entry.get("Texto (Preview)", ""),
+            texto_preview,
             entry.get("Status", "")
         ])
     return formatted_list
 
-# ============================================
-# FUNÇÃO DE ALERTA (ATUALIZADA para HTML)
-# ============================================
 def criar_alerta(tipo, mensagem):
     """Cria alerta HTML colorido"""
     cores = {
@@ -277,41 +432,47 @@ def criar_alerta(tipo, mensagem):
     </div>
     """
 
-# ============================================
-# FUNÇÕES AUXILIARES (Adicionadas)
-# ============================================
-
 def copiar_feedback(texto):
     if texto:
         return criar_alerta('success', '✅ Texto copiado!')
     return criar_alerta('warning', '⚠️ Nada para copiar')
 
 def limpar_tudo():
-    # Retorna 11 valores para limpar todos os campos
+    """Limpa todos os inputs da UI, incluindo filtros de histórico."""
+    analytics_data = gerar_relatorio_analytics() # Gerar relatório limpo
     return (
+        # Aba Gerador
         "", # texto_output
         None, # imagem_output
         criar_alerta('info', '🧹 Interface limpa!'), # status_output
         0, # palavras_output
         0, # caracteres_output
         0, # hashtags_output
-        list(FORMATO_CONFIGS.keys())[0], # formato_input (Solicitação 1)
+        list(FORMATO_CONFIGS.keys())[0], # formato_input
         "Nenhum (Automático)", # estilo_img_input
         "Balanceada", # qualidade_img_input
         "Nenhum", # filtro_img_input
-        None # download_output
+        None, # download_output
+        True, # usar_cache_checkbox
+        analytics_data, # analytics_display
+        False, # favorito_checkbox
+        # Aba Histórico
+        "", # busca_query_input
+        "Todos", # filtro_nicho_hist
+        "Todos", # filtro_estilo_hist
+        "Todos", # filtro_formato_hist
+        False # filtro_favoritos_hist
     )
 
-# NOVA FUNÇÃO AUXILIAR PARA ATUALIZAR A UI DO HISTÓRICO
-def recarregar_e_formatar_historico():
-    """Recarrega o histórico do cache global (que foi atualizado) e formata para o Dataframe."""
-    # O cache 'post_history' já foi atualizado por 'gerar_post_interface'
-    # através da chamada a 'atualizar_historico'
-    return _formatar_historico_para_df(post_history)
+def recarregar_e_formatar_historico(query, nicho, estilo, formato, favoritos_apenas):
+    """
+    Chamado após a geração de um post, para atualizar a tabela de histórico
+    mantendo os filtros atuais.
+    """
+    # A lista global `post_history` já foi atualizada por `atualizar_historico`.
+    # Apenas precisamos refiltrar e formatar.
+    return filtrar_historico_local(query, nicho, estilo, formato, favoritos_apenas)
 
-# ============================================
-# NOVA FUNÇÃO: INTERPRETAR ERROS (Solicitação 3)
-# ============================================
 def interpretar_erro_api(erro_str):
     """Interpreta erros comuns da API para o usuário em Português."""
     erro_str_lower = erro_str.lower()
@@ -336,21 +497,95 @@ def interpretar_erro_api(erro_str):
     if "authorization" in erro_str_lower or "401" in erro_str_lower:
             return ("Erro 401: Autenticação falhou. A Chave da API (Secret 'Capoeira') pode estar inválida ou ausente.")
 
-    # Fallback para erros genéricos
-    return f"Erro inesperado: {erro_str[:200]}..." # Trunca o erro
+    return f"Erro inesperado: {erro_str[:200]}..."
 
 # ============================================
-# FUNÇÕES DE GERAÇÃO (POSTS)
+# NOVAS FUNÇÕES DE FILTRO E CARGA DE HISTÓRICO
 # ============================================
 
-def gerar_texto(tema, nicho, estilo, formato): # ATUALIZADO: 'formato' re-adicionado
+def filtrar_historico_local(query, nicho, estilo, formato, favoritos_apenas):
+    """Filtra a lista global `post_history` com base nos inputs da UI."""
+    global post_history
+    
+    # Começa com a lista completa
+    resultados = post_history
+    
+    # Filtro de busca por texto
+    if query:
+        query_lower = query.lower()
+        resultados = [
+            post for post in resultados 
+            if query_lower in post.get("Tema", "").lower() or query_lower in post.get("Texto", "").lower()
+        ]
+        
+    # Filtro de Nicho
+    if nicho != "Todos":
+        resultados = [post for post in resultados if post.get("Nicho") == nicho]
+        
+    # Filtro de Estilo
+    if estilo != "Todos":
+        resultados = [post for post in resultados if post.get("Estilo") == estilo]
+        
+    # Filtro de Formato
+    if formato != "Todos":
+        resultados = [post for post in resultados if post.get("Formato") == formato]
+        
+    # Filtro de Favoritos
+    if favoritos_apenas:
+        resultados = [post for post in resultados if post.get("Favorito") == True]
+        
+    # Formata para o Dataframe
+    return _formatar_historico_para_df(resultados)
+
+def carregar_post_do_historico(evt: gr.SelectData):
+    """
+    Chamado quando o usuário clica em uma linha do Dataframe de histórico.
+    Carrega os dados do post selecionado na aba "Gerar Post".
+    """
+    global post_history
+    try:
+        # Pega o post correspondente da lista global
+        post_selecionado = post_history[evt.index]
+        
+        # Extrai os dados
+        tema = post_selecionado.get("Tema", "")
+        nicho = post_selecionado.get("Nicho", NICHOS_DISPONIVEIS[0])
+        estilo = post_selecionado.get("Estilo", ESTILOS_DISPONIVEIS[0])
+        formato = post_selecionado.get("Formato", list(FORMATO_CONFIGS.keys())[0])
+        favorito = post_selecionado.get("Favorito", False)
+        texto = post_selecionado.get("Texto", "")
+        
+        # Feedback para o usuário
+        status_alerta = criar_alerta('info', '✅ Post carregado do histórico! A imagem deve ser gerada novamente se desejado.')
+        
+        # Retorna os valores para a UI, incluindo a mudança de aba
+        return (
+            gr.Tabs(selected=0), # Muda para a primeira aba (Gerar Post)
+            tema,
+            nicho,
+            estilo,
+            formato,
+            favorito,
+            texto,
+            status_alerta
+        )
+    except Exception as e:
+        print(f"Erro ao carregar do histórico: {e}")
+        return (
+            gr.Tabs(selected=0), # Muda para a primeira aba
+            "", "", "", "", False, "", # Limpa os campos
+            criar_alerta('error', f'Erro ao carregar post: {e}')
+        )
+
+# ============================================
+# FUNÇÕES DE GERAÇÃO
+# ============================================
+
+def gerar_texto(tema, nicho, estilo, formato):
     """
     Gera texto usando API do Hugging Face com base no formato escolhido.
     """
     
-    # ATUALIZADO: Linha hardcoded removida
-    # formato = "Instagram (Post)" 
-
     if not HUGGINGFACE_API_KEY:
         return "❌ Erro de Configuração: API Key não está definida."
 
@@ -395,25 +630,19 @@ Escreva apenas o conteúdo, sem introduções ou explicações."""
             else:
                 return f"❌ Erro na resposta da API: Resposta vazia ou inesperada.\n{resultado}"
         else:
-            # ATUALIZADO: Interpretar erro
             return f"❌ {interpretar_erro_api(f'Erro {response.status_code}: {response.text}')}"
 
     except Exception as e:
-        # ATUALIZADO: Interpretar erro
         return f"❌ {interpretar_erro_api(str(e))}"
 
 def traduzir_texto(texto_pt):
     """Traduz texto de Português (PT) para Inglês (EN) usando API do Hugging Face.
     """
-
     if not HUGGINGFACE_API_KEY:
         return texto_pt
 
     url = f"https://api-inference.huggingface.co/models/{MODELO_TRADUCA}"
-
-    payload = {
-        "inputs": texto_pt,
-    }
+    payload = {"inputs": texto_pt}
 
     try:
         response = requests.post(url, headers=headers, json=payload, timeout=30)
@@ -427,30 +656,18 @@ def traduzir_texto(texto_pt):
                 return texto_pt # Fallback
         else:
             return texto_pt # Fallback
-
     except Exception as e:
         print(f"Falha na tradução (fallback para PT): {e}")
         return texto_pt # Fallback
 
-# ============================================
-# NOVAS FUNÇÕES DE GERAÇÃO DE IMAGEM
-# ============================================
-
 def otimizar_prompt_imagem(descricao_pt, estilo_escolhido, filtro_escolhido):
     """Combina as escolhas do usuário em um prompt otimizado (em Português)."""
     
-    # 1. Obter estilo
-    # ATUALIZADO: Usar o novo dicionário ESTILOS_DE_IMAGEM (Solicitação 2)
     estilo = ESTILOS_DE_IMAGEM.get(estilo_escolhido, ESTILOS_DE_IMAGEM["Nenhum (Automático)"])
-    
-    # 2. Obter filtro
     filtro = FILTROS_IMAGEM.get(filtro_escolhido, FILTROS_IMAGEM["Nenhum"])
     
-    # 3. Montar o prompt
-    # Adiciona tags de qualidade padrão
     prompt_final = f"{descricao_pt}, {estilo}, {filtro}, best quality, 4k"
     
-    # Limpar tags duplicadas ou vazias (ex: "Nenhum" vira "")
     prompt_final = prompt_final.replace(", ,", ",").replace(", ,", ",")
     return prompt_final
 
@@ -498,15 +715,13 @@ def gerar_imagem_robusta(descricao_pt, estilo_escolhido, qualidade, filtro_escol
 
             client = InferenceClient(api_key=HUGGINGFACE_API_KEY)
             
-            # Gerar imagem
             imagem = client.text_to_image(
                 prompt=prompt_final_en,
                 model=modelo_config['id'],
                 negative_prompt=negative_prompt,
-                num_inference_steps=config['steps'] # Parâmetro de qualidade
+                num_inference_steps=config['steps']
             )
             
-            # Sucesso!
             print(f"✅ Imagem gerada com {modelo_config['nome']}")
             mensagem = f"✅ Imagem gerada com {modelo_config['nome']}"
             
@@ -515,51 +730,37 @@ def gerar_imagem_robusta(descricao_pt, estilo_escolhido, qualidade, filtro_escol
         except Exception as e:
             print(f"❌ Falha com {modelo_config['nome']}: {str(e)}")
             
-            # Se não for o último modelo, continua tentando
             if i < len(config['modelos']) - 1:
                 print(f"⏭️ Tentando próximo modelo...")
                 continue
             else:
-                # Último modelo falhou, retornar erro
-                # ATUALIZADO: Interpretar erro
                 mensagem = f"❌ {interpretar_erro_api(str(e))}"
                 return (None, mensagem)
 
-    # Se chegou aqui, algo deu errado
     return (None, "❌ Erro inesperado ao gerar imagem")
 
 
 # ============================================
-# NOVA FUNÇÃO DO CHATBOT (CORRIGIDA)
+# FUNÇÃO DO CHATBOT
 # ============================================
 def responder_chat(message, chat_history):
-    """
-    Processa uma mensagem do usuário e retorna uma resposta do LLM para o chatbot.
-    """
     if not HUGGINGFACE_API_KEY:
         return "❌ Erro de Configuração: API Key não está definida."
 
     url = f"{BASE_URL}/chat/completions"
     
-    # 1. Definir o System Prompt para o assistente
     system_prompt = "Você é um assistente virtual prestativo e amigável, especializado em marketing de mídias sociais e criação de conteúdo, mas pode responder sobre qualquer tópico. Seja direto e útil."
     
-    # 2. Construir o histórico no formato da API
     messages = [{"role": "system", "content": system_prompt}]
-    
-    # CORREÇÃO: chat_history (quando type="messages") já é uma List[Dict[str, str]]
-    # Podemos simplesmente estendê-lo
     messages.extend(chat_history)
-        
-    # 3. Adicionar a nova mensagem do usuário
     messages.append({"role": "user", "content": message})
 
     payload = {
-        "model": MODELO_TEXTO, # Reutiliza o mesmo modelo
+        "model": MODELO_TEXTO,
         "messages": messages,
-        "max_tokens": 1500, # Mais espaço para uma conversa fluida
+        "max_tokens": 1500,
         "temperature": 0.7,
-        "stream": False # ChatInterface do Gradio lida melhor com respostas completas
+        "stream": False
     }
 
     try:
@@ -573,15 +774,13 @@ def responder_chat(message, chat_history):
             else:
                 return f"❌ Erro na resposta da API: Resposta vazia ou inesperada.\n{resultado}"
         else:
-            # ATUALIZADO: Interpretar erro
             return f"❌ {interpretar_erro_api(f'Erro {response.status_code}: {response.text}')}"
 
     except Exception as e:
-        # ATUALIZADO: Interpretar erro
         return f"❌ {interpretar_erro_api(str(e))}"
 
 # ============================================
-# NOVAS FUNÇÕES DE DOWNLOAD
+# FUNÇÕES DE DOWNLOAD
 # ============================================
 
 def criar_post_completo(texto, imagem_pil, tema):
@@ -594,16 +793,13 @@ def criar_post_completo(texto, imagem_pil, tema):
         return None
     
     try:
-        # Configurações
         LARGURA_POST = 1080
         ALTURA_IMAGEM = 1080
         PADDING = 60
         COR_FUNDO = (255, 255, 255)
         COR_TEXTO = (0, 0, 0)
         
-        # Tentar carregar uma fonte (fallback para a fonte padrão do PIL)
         try:
-            # Fontes comuns em ambientes Linux (como o Hugging Face Spaces)
             fonte_texto = ImageFont.truetype("DejaVuSans.ttf", size=42)
             fonte_titulo = ImageFont.truetype("DejaVuSans-Bold.ttf", size=55)
         except IOError:
@@ -611,49 +807,35 @@ def criar_post_completo(texto, imagem_pil, tema):
             fonte_texto = ImageFont.load_default()
             fonte_titulo = ImageFont.load_default()
 
-        # 1. Redimensionar imagem original para 1080x1080 (formato Instagram)
         imagem_quadrada = imagem_pil.resize((LARGURA_POST, ALTURA_IMAGEM), Image.Resampling.LANCZOS)
         
-        # 2. Preparar texto
-        # Usar o 'tema' como título e 'texto' como corpo
         linhas_titulo = textwrap.wrap(tema.upper(), width=40)
-        linhas_texto = textwrap.wrap(texto, width=50) # Quebra de linha mais larga para o corpo
+        linhas_texto = textwrap.wrap(texto, width=50)
         
-        # 3. Calcular altura necessária para o texto
-        # (altura da linha * num linhas)
-        altura_titulo = len(linhas_titulo) * 60 
+        altura_titulo = len(linhas_titulo) * 60  
         altura_texto = len(linhas_texto) * 45
-        # Altura total = Título + Espaço + Texto + Padding
-        altura_total_texto = altura_titulo + 20 + altura_texto + (PADDING * 2) 
+        altura_total_texto = altura_titulo + 20 + altura_texto + (PADDING * 2)  
         
-        # 4. Criar nova imagem (canvas)
         altura_total = ALTURA_IMAGEM + altura_total_texto
         post_completo = Image.new('RGB', (LARGURA_POST, int(altura_total)), COR_FUNDO)
         
-        # 5. Colar imagem gerada
         post_completo.paste(imagem_quadrada, (0, 0))
         
-        # 6. Desenhar texto
         draw = ImageDraw.Draw(post_completo)
         pos_y = ALTURA_IMAGEM + PADDING
         
-        # Desenhar Título
         for linha in linhas_titulo:
-            # Centralizar título (opcional, mas fica melhor)
             largura_linha = draw.textlength(linha, font=fonte_titulo)
             pos_x_titulo = (LARGURA_POST - largura_linha) / 2
             draw.text((pos_x_titulo, pos_y), linha, font=fonte_titulo, fill=COR_TEXTO)
-            pos_y += 60 # Avança Y para a próxima linha
+            pos_y += 60
         
-        pos_y += 20 # Espaço extra entre título e corpo
+        pos_y += 20
         
-        # Desenhar Texto (Corpo)
         for linha in linhas_texto:
             draw.text((PADDING, pos_y), linha, font=fonte_texto, fill=COR_TEXTO)
-            pos_y += 45 # Avança Y
+            pos_y += 45
 
-        # 7. Salvar em arquivo temporário
-        # Usar tempfile para criar um arquivo nomeado que o Gradio possa acessar
         with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as f:
             post_completo.save(f, 'PNG')
             print(f"Arquivo temporário salvo em: {f.name}")
@@ -665,81 +847,102 @@ def criar_post_completo(texto, imagem_pil, tema):
 
 def preparar_download(texto, imagem_pil, tema):
     """
-    Prepara o arquivo ZIP para download.
+    Prepara o arquivo PNG para download.
     Retorna o caminho do arquivo para o gr.File ou None.
     """
     if not texto or not imagem_pil:
-        return None # Retorna None se não houver nada para baixar
+        return None
 
     caminho_arquivo = criar_post_completo(texto, imagem_pil, tema)
 
     if caminho_arquivo:
-        # Retorna o caminho do arquivo para o componente gr.File
         return caminho_arquivo
     
-    # Se falhar, retorna None (o botão de download não fará nada)
     return None
 
-
 # ============================================
-# FUNÇÃO PRINCIPAL COM PROGRESSO (ATUALIZADA)
+# FUNÇÃO PRINCIPAL
 # ============================================
 
-def gerar_post_interface(tema, nicho, estilo, formato, # ATUALIZADO: 'formato' adicionado
-                         descricao_imagem, gerar_img, 
-                         estilo_img_input, qualidade_img_input, filtro_img_input, 
+def gerar_post_interface(tema, nicho, estilo, formato, usar_cache, favorito_checkbox,
+                         descricao_imagem, gerar_img,
+                         estilo_img_input, qualidade_img_input, filtro_img_input,
                          progress=gr.Progress()):
-    """Gera post completo com feedback e lógica de imagem avançada"""
+    """
+    Função principal unificada, com Cache, Analytics, Favoritos e Geração Avançada.
+    Retorna 7 valores para a UI.
+    """
+    
+    analytics_display = gerar_relatorio_analytics() # Carregar estado atual
     
-    # Início
     progress(0, desc="🚀 Iniciando...")
     time.sleep(0.3)
     
-    # Validação
     progress(0.1, desc="✅ Validando...")
     if not tema or len(tema.strip()) < 3:
         status_final = criar_alerta('error', '⚠️ Digite um tema válido!')
-        # Retorna 6 valores
-        return ("", None, status_final, 0, 0, 0)
+        return ("", None, status_final, 0, 0, 0, analytics_display)
     time.sleep(0.3)
+
+    # 1. Lógica de Cache
+    cache_key = criar_cache_key(tema, nicho, estilo, formato)
+    if usar_cache:
+        progress(0.2, desc="🔍 Buscando no cache...")
+        texto, imagem = buscar_no_cache(cache_key)
+        
+        if texto:
+            print("✅ Cache hit!")
+            progress(1.0, desc="🎉 Encontrado no cache!")
+            status_final = criar_alerta('success', '🎉 Post carregado do cache!')
+            
+            atualizar_analytics(nicho, estilo, len(texto.split()), (imagem is not None), cache_hit=True, favorito=favorito_checkbox)
+            analytics_display = gerar_relatorio_analytics() # Recarregar
+            
+            palavras = len(texto.split())
+            caracteres = len(texto)
+            hashtags = texto.count('#')
+            
+            history_entry = {
+                "Data/Hora": datetime.now(ZoneInfo("America/Bahia")).strftime("%Y-%m-%d %H:%M:%S"),
+                "Tema": tema, "Nicho": nicho, "Estilo": estilo, "Formato": formato,
+                "Texto": texto,
+                "Status": "Carregado do Cache",
+                "Favorito": favorito_checkbox
+            }
+            atualizar_historico(history_entry)
+            
+            return (texto, imagem, status_final, palavras, caracteres, hashtags, analytics_display)
     
-    # Preparando
-    progress(0.2, desc="📝 Preparando prompt de texto...")
-    time.sleep(0.5)
-    
-    # Gerando texto
+    print("Cache miss ou cache desativado.")
     progress(0.3, desc="🤖 Gerando texto (Llama 3.1)...")
-    # ATUALIZADO: 'formato' passado para gerar_texto
-    texto = gerar_texto(tema, nicho, estilo, formato) 
     
-    if texto.startswith("❌"): # Erro já vem formatado
+    # 2. Gerar Texto
+    texto = gerar_texto(tema, nicho, estilo, formato)  
+    
+    if texto.startswith("❌"):
         status_final = criar_alerta('error', f'{texto}')
-        return (texto, None, status_final, 0, 0, 0)
+        return (texto, None, status_final, 0, 0, 0, analytics_display)
     
     progress(0.5, desc="✅ Texto pronto!")
     time.sleep(0.5)
     
-    # Gerando imagem
+    # 3. Gerar Imagem
     imagem = None
     status_imagem = ""
     if gerar_img:
-        # Descrição base em Português
         descricao_pt = descricao_imagem or f"{tema} imagem"
         
-        # Chamar a nova função robusta
         (imagem, status_imagem) = gerar_imagem_robusta(
-            descricao_pt, 
-            estilo_img_input, 
-            qualidade_img_input, 
-            filtro_img_input, 
-            progress # Passa o objeto de progresso
+            descricao_pt,  
+            estilo_img_input,  
+            qualidade_img_input,  
+            filtro_img_input,  
+            progress
         )
         
         if imagem:
             status_final = criar_alerta('success', f'🎉 Post completo gerado! ({status_imagem})')
         else:
-            # status_imagem conterá a mensagem de erro (ex: "Todos os modelos falharam")
-            # ATUALIZADO: status_imagem já vem formatado com o erro
             status_final = criar_alerta('warning', f'✅ Texto OK, mas imagem falhou: {status_imagem}')
     else:
         progress(0.7, desc="⏭️ Pulando geração de imagem...")
@@ -747,72 +950,65 @@ def gerar_post_interface(tema, nicho, estilo, formato, # ATUALIZADO: 'formato' a
     
     time.sleep(0.5)
     
-    # Estatísticas
+    # 4. Estatísticas
     progress(0.9, desc="📊 Calculando estatísticas...")
     palavras = len(texto.split())
     caracteres = len(texto)
     hashtags = texto.count('#')
     time.sleep(0.3)
     
-    # Concluído
-    progress(1.0, desc="🎉 Pronto!")
-    
-    # ==================================================
-    # INÍCIO DA CORREÇÃO: Re-adicionando salvamento no histórico
-    # ==================================================
-    
-    # ATUALIZADO: Usar o 'formato' vindo do input
-    formato_usado = formato
-    
-    # Usar a variável 'status' que já foi definida
-    status_final_historico = status_final # Usar o status HTML (o Firestore lida bem com strings)
-    
-    # Se a geração falhou, usamos a mensagem de status como preview
-    texto_preview = texto[:100].replace('\n', ' ') + "..." if not texto.startswith("❌") else status_final
-
+    # 5. Salvar no Cache
+    if usar_cache:
+        progress(0.95, desc="💾 Salvando no cache...")
+        imagem_path_cache = salvar_imagem_cache(cache_key, imagem)
+        cache_data = {
+            "texto": texto,
+            "imagem_path": imagem_path_cache
+        }
+        salvar_no_cache(cache_key, cache_data)
+        
+    # 6. Atualizar Histórico (Firestore)
     history_entry = {
         "Data/Hora": datetime.now(ZoneInfo("America/Bahia")).strftime("%Y-%m-%d %H:%M:%S"),
-        "Tema": tema,
-        "Nicho": nicho,
-        "Estilo": estilo,
-        "Formato": formato_usado, # Atualizado
-        "Texto (Preview)": texto_preview,
-        "Status": status_imagem or "Texto Gerado", # Salva o status da imagem (ex: "Gerada com FLUX")
+        "Tema": tema, "Nicho": nicho, "Estilo": estilo, "Formato": formato,
+        "Texto": texto, # Salva o texto completo
+        "Status": status_imagem or "Texto Gerado",
+        "Favorito": favorito_checkbox
     }
-    
-    # Salvar no Histórico (DB e cache)
     atualizar_historico(history_entry)
     
-    # ==================================================
-    # FIM DA CORREÇÃO
-    # ==================================================
+    # 7. Atualizar Analytics (Firestore)
+    atualizar_analytics(nicho, estilo, palavras, (imagem is not None), cache_hit=False, favorito=favorito_checkbox)
+    analytics_display = gerar_relatorio_analytics() # Recarregar
     
-    # A função agora retorna 6 valores
-    return (texto, imagem, status_final, palavras, caracteres, hashtags)
+    progress(1.0, desc="🎉 Pronto!")
+    
+    return (texto, imagem, status_final, palavras, caracteres, hashtags, analytics_display)
 
 
 # ============================================
-# INTERFACE GRADIO (Com Chatbot)
+# INTERFACE GRADIO
 # ============================================
 
-# ATUALIZADO: gr.themes.Glass é obsoleto no Gradio 4.x. Usando gr.themes.Soft.
 custom_theme = gr.themes.Soft(
-    primary_hue="blue",       # Azul como base
-    secondary_hue="gray",     # Contraste frio e sofisticado
-    neutral_hue="stone",      # Tom neutro suave
-    font=["Helvetica", "Georgia", "sans-serif"]  # Fontes clássicas e legíveis
+    primary_hue="blue",
+    secondary_hue="gray",
+    neutral_hue="stone",
+    font=["Helvetica", "Georgia", "sans-serif"]
 )
 
+# Inicializar Firestore e carregar Analytics ANTES de construir a UI
+_inicializar_firestore()
 
-with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
+with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot (Completo)") as demo:
 
     gr.Markdown("""
-    # 🚀 Gerador de Posts e Assistente de Mídias Sociais
-    ### Powered by Hugging Face, Gradio e Llama 3.1
+    # 🚀 Gerador de Posts e Assistente de Mídias Sociais (Versão Completa)
+    ### Powered by Hugging Face, Gradio, Llama 3.1 e Firebase
     """)
     
-    with gr.Tabs():
-        with gr.TabItem("✨ Gerar Post"):
+    with gr.Tabs() as main_tabs: # Adicionado 'as main_tabs' para controle
+        with gr.TabItem("✨ Gerar Post", id=0):
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### ⚙️ 1. Configurações do Texto")
@@ -836,13 +1032,16 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
                         placeholder="Ex: Transforme seu corpo, transforme sua vida"
                     )
 
-                    # ATUALIZADO: Reativado (Solicitação 1)
                     formato_input = gr.Radio(
                         choices=list(FORMATO_CONFIGS.keys()),
                         label="Escolha o Formato de Saída",
                         value=list(FORMATO_CONFIGS.keys())[0],
-                        interactive=True,
-                        visible=True
+                        interactive=True
+                    )
+                    
+                    usar_cache_checkbox = gr.Checkbox(
+                        label="Usar Cache? (Acelera posts repetidos)",
+                        value=True
                     )
         
                     gr.Markdown("### 🎨 2. Configurações da Imagem (Opcional)")
@@ -852,14 +1051,12 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
                         value=False
                     )
         
-                    # Inputs de Imagem (inicialmente ocultos)
                     descricao_img_input = gr.Textbox(
                         label="Descrição da imagem (em Português)",
                         placeholder="Ex: Pessoa correndo ao nascer do sol",
                         visible=False
                     )
                     
-                    # ATUALIZADO: Usando ESTILOS_DE_IMAGEM (Solicitação 2)
                     estilo_img_input = gr.Dropdown(
                         label="Estilo da Imagem",
                         choices=list(ESTILOS_DE_IMAGEM.keys()),
@@ -884,9 +1081,7 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
                         interactive=True
                     )
         
-                    # Função para mostrar/ocultar todos os controles de imagem
                     def toggle_descricao_img(gerar):
-                        # ATUALIZADO: Retorna 4 componentes
                         return (
                             gr.Textbox(visible=gerar),
                             gr.Dropdown(visible=gerar),
@@ -899,13 +1094,14 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
                         inputs=[gerar_img_checkbox],
                         outputs=[descricao_img_input, estilo_img_input, qualidade_img_input, filtro_img_input]
                     )
+                    
+                    favorito_checkbox = gr.Checkbox(label="⭐ Favoritar este post?", value=False)
         
                     gerar_btn = gr.Button("✨ Gerar Post", variant="primary")
                 
                 with gr.Column(scale=1):
                     gr.Markdown("### 📋 3. Resultado")
         
-                    # ATUALIZADO: Status agora é HTML para alertas coloridos
                     status_output = gr.HTML(
                         label="Status",
                         value=criar_alerta('info', 'Pronto para gerar!')
@@ -914,21 +1110,19 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
                     texto_output = gr.Textbox(
                         label="Texto Gerado",
                         lines=10,
-                        interactive=False,
-                        show_copy_button=True # Garantir que o botão nativo (ícone) apareça
+                        interactive=True, # Alterado para True para carregar do histórico
+                        show_copy_button=True
                     )
                     
-                    # Botões de ação adicionados
                     with gr.Row():
                         copiar_btn = gr.Button("📋 Copiar Texto", variant="secondary")
                         limpar_btn = gr.Button("🧹 Limpar Tudo", variant="stop")
-                
+        
                     imagem_output = gr.Image(
                         label="Imagem Gerada",
                         type="pil"
                     )
                     
-                    # NOVO: Seção de Download
                     gr.Markdown("### 📥 4. Download")
                     download_btn = gr.Button(
                         "Baixar Post Completo (Imagem + Texto)",
@@ -936,21 +1130,17 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
                     )
                     download_output = gr.File(
                         label="Clique para baixar",
-                        visible=True # Visível para que o link apareça
+                        visible=True
                     )
-
                     
-                    # Estatísticas adicionadas
                     gr.Markdown("### 📊 Estatísticas do Texto")
                     with gr.Row():
                         palavras_output = gr.Number(label="Palavras", value=0, interactive=False)
                         caracteres_output = gr.Number(label="Caracteres", value=0, interactive=False)
                         hashtags_output = gr.Number(label="Hashtags", value=0, interactive=False)
 
-        
             gr.Markdown("### 💡 Experimente estes exemplos:")
-        
-            # ATUALIZADO: Exemplos agora incluem o formato
+            
             gr.Examples(
                 examples=[
                     [NICHOS_DISPONIVEIS[2], ESTILOS_DISPONIVEIS[0], "Frases marcantes de pessoas importantes", "Instagram (Post)"],
@@ -958,119 +1148,90 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
                     [NICHOS_DISPONIVEIS[5], ESTILOS_DISPONIVEIS[3], "O futuro da IA em 2025", "LinkedIn (Artigo)"],
                     [NICHOS_DISPONIVEIS[4], ESTILOS_DISPONIVEIS[1], "Melhores destinos para lua de mel na Europa", "Twitter/X (Curto)"],
                 ],
-                inputs=[nicho_input, estilo_input, tema_input, formato_input], # 'formato_input' adicionado
+                inputs=[nicho_input, estilo_input, tema_input, formato_input],
                 outputs=[texto_output, imagem_output, status_output]
             )
-
-            # ============================================
-            # CONECTAR EVENTOS (Bloco Novo)
-            # ============================================
             
-            # Botão principal
-            # CORREÇÃO: Capturar o evento de clique para usá-lo na outra aba
-            click_event = gerar_btn.click(
-                fn=gerar_post_interface,
-                inputs=[
-                    tema_input, nicho_input, estilo_input, 
-                    formato_input, # ATUALIZADO: 'formato_input' adicionado
-                    descricao_img_input, gerar_img_checkbox,
-                    estilo_img_input, qualidade_img_input, filtro_img_input # Novos inputs
-                ],
-                outputs=[
-                    texto_output, imagem_output, status_output, 
-                    palavras_output, caracteres_output, hashtags_output
-                ],
-                show_progress="full"
-            )
-            
-            # Botão copiar
-            copiar_btn.click(
-                fn=copiar_feedback,
-                inputs=[texto_output],
-                outputs=[status_output]
-            )
-            
-            # Botão limpar
-            limpar_btn.click(
-                fn=limpar_tudo,
-                inputs=[],
-                outputs=[
-                    texto_output, imagem_output, status_output, 
-                    palavras_output, caracteres_output, hashtags_output,
-                    formato_input, # ATUALIZADO: 'formato_input' adicionado
-                    estilo_img_input, qualidade_img_input, filtro_img_input, # Limpa novos inputs
-                    download_output # Limpa o arquivo de download
-                ]
-            )
-            
-            # NOVO: Botão de Download
-            download_btn.click(
-                fn=preparar_download,
-                inputs=[texto_output, imagem_output, tema_input],
-                outputs=[download_output]
-            )
-        
-        # ============================================
-        # NOVA ABA: CHATBOT
-        # ============================================
-        with gr.TabItem("💬 Chatbot Assistente"):
+        with gr.TabItem("💬 Chatbot Assistente", id=1):
             gr.Markdown("### 🤖 Assistente Virtual")
             gr.Markdown("Faça perguntas sobre mídias sociais, IA, peça ideias rápidas ou qualquer outro tópico.")
             
-            # 1. Instanciar o Chatbot com os parâmetros solicitados
             chatbot_para_interface = gr.Chatbot(
-                height=500, 
-                type="messages" # Alterado conforme solicitação para evitar obsolescência
+                height=500,  
+                type="messages"
             )
 
-            # 2. Passar o componente chatbot para a ChatInterface
             gr.ChatInterface(
                 fn=responder_chat,
                 title="Assistente Virtual",
                 description="Converse com o Llama 3.1 para obter ajuda e insights.",
                 examples=[
-                    "O que é um 'gancho' para Instagram?", 
-                    "Me dê 3 ideias de post para um nicho de 'Fitness'", 
-                    "Como o Llama 3.1 funciona?",
+                    "O que é um 'gancho' para Instagram?",  
+                    "Me dê 3 ideias de post para um nicho de 'Fitness'",  
                     "Qual a diferença entre um post para Instagram e um para LinkedIn?"
                 ],
-                chatbot=chatbot_para_interface, # Passando o componente chatbot customizado
+                chatbot=chatbot_para_interface,
                 textbox=gr.Textbox(placeholder="Digite sua mensagem aqui...", scale=7),
-                submit_btn="Enviar"                
+                submit_btn="Enviar"
             )
             
-        # ABA 2: Histórico (Exibe o Dataframe)
-        with gr.TabItem("📚 Histórico de Posts"):
-            gr.Markdown("### Posts Gerados Recentemente")
+        with gr.TabItem("📚 Histórico de Posts", id=2):
+            gr.Markdown("### 🔍 Buscar e Filtrar Histórico")
+            gr.Markdown("Carregue posts antigos clicando em uma linha da tabela.")
+
+            with gr.Row():
+                busca_query_input = gr.Textbox(
+                    label="Buscar por Tema/Texto", 
+                    placeholder="Digite para buscar...", 
+                    scale=3,
+                    interactive=True
+                )
+                filtro_nicho_hist = gr.Dropdown(
+                    label="Nicho", 
+                    choices=["Todos"] + NICHOS_DISPONIVEIS, 
+                    value="Todos",
+                    interactive=True
+                )
+            with gr.Row():
+                filtro_estilo_hist = gr.Dropdown(
+                    label="Estilo", 
+                    choices=["Todos"] + ESTILOS_DISPONIVEIS, 
+                    value="Todos",
+                    interactive=True
+                )
+                filtro_formato_hist = gr.Dropdown(
+                    label="Formato", 
+                    choices=["Todos"] + list(FORMATO_CONFIGS.keys()), 
+                    value="Todos",
+                    interactive=True
+                )
+                filtro_favoritos_hist = gr.Checkbox(
+                    label="⭐ Apenas Favoritos", 
+                    value=False,
+                    interactive=True
+                )
+            
+            buscar_hist_btn = gr.Button("Buscar", variant="primary")
             
-            # Dataframe de exibição que é atualizado pelo output do botão
             historico_display = gr.Dataframe(
-                headers=["Data/Hora", "Tema", "Nicho", "Estilo", "Formato", "Texto (Preview)", "Status"],
-                interactive=False,
-                value=_formatar_historico_para_df(carregar_historico_inicial()), # Carrega histórico (DB ou vazio) E FORMATA
+                headers=["⭐", "Data/Hora", "Tema", "Nicho", "Estilo", "Formato", "Texto (Preview)", "Status"],
+                interactive=True, # Habilitado para seleção
+                value=_formatar_historico_para_df(carregar_historico_inicial()),
             )
+
+        with gr.TabItem("📊 Analytics", id=3):
+            gr.Markdown("### Análise de Uso da Ferramenta")
+            gr.Markdown("Estes dados são salvos no Firestore e agregam o uso de todos os usuários.")
             
-            # ============================================
-            # CORREÇÃO DA ATUALIZAÇÃO DO HISTÓRICO
-            # ============================================
-            # Conectar o evento de clique do 'gerar_btn' (da outra aba)
-            # para também atualizar 'historico_display' *depois* que a geração terminar.
-            click_event.then(
-                fn=recarregar_e_formatar_historico,
-                inputs=None,
-                outputs=[historico_display]
+            analytics_display = gr.Markdown(
+                value=gerar_relatorio_analytics()
             )
-
-            gr.Markdown("""
-            ---
-            *Nota sobre Persistência:*
             
-            Esta aba agora exibe o histórico persistente (dos **posts gerados**) salvo no Google Firestore.
-            O histórico é compartilhado entre todas as sessões e usuários.
-            """) 
+            with gr.Row():
+                gerar_relatorio_btn = gr.Button("Atualizar Relatório", variant="secondary")
+                resetar_analytics_btn = gr.Button("Resetar Analytics (CUIDADO)", variant="stop")
 
-        # ABA 3: Configurações
-        with gr.TabItem("⚙️ Configurações"):
+        with gr.TabItem("⚙️ Configurações", id=4):
             gr.Markdown("### Configurações do Gerador")
             gr.Markdown("**Modelo de Texto (LLM):** Llama 3.1 8B (Usado para Posts e Chatbot)")
             gr.Markdown("**Modelos de Imagem:** FLUX.1-schnell, FLUX.1-dev, SDXL 1.0")
@@ -1078,17 +1239,19 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
             gr.Markdown("**API Provider:** Hugging Face Inference")
             gr.Markdown("**Database:** Google Firestore (via Firebase Admin)")
             gr.Markdown("---")
-            gr.Markdown("#### Funcionalidades:")
+            gr.Markdown("#### Funcionalidades (Versão Completa):")
             gr.Markdown("- **Gerador de Posts:** Cria posts completos com texto e imagem.")
             gr.Markdown("- **Seleção de Formato:** Permite escolher o formato do texto (Instagram, Twitter, LinkedIn).")
             gr.Markdown("- **Controles Avançados:** Permite seleção de Estilo, Qualidade e Filtros para a imagem.")
             gr.Markdown("- **Download de Post:** Combina texto e imagem em um único arquivo PNG para download.")
             gr.Markdown("- **Chatbot Assistente:** Converse com a IA para ideias e perguntas rápidas.")
             gr.Markdown("- **Histórico Persistente:** Salva os *posts gerados* no Firestore.")
+            gr.Markdown("- **Busca no Histórico:** Permite buscar e filtrar posts antigos.")
+            gr.Markdown("- **Favoritos:** Permite marcar posts como favoritos.")
+            gr.Markdown("- **Sistema de Cache:** Salva posts localmente para acelerar requisições futuras.")
+            gr.Markdown("- **Sistema de Analytics:** Rastreia o uso (total, por nicho, etc.) no Firestore.")
 
-
-        # ABA 4: Sobre
-        with gr.TabItem("ℹ️ Sobre"):
+        with gr.TabItem("ℹ️ Sobre", id=5):
             gr.Markdown("""
             ### Sobre Este Projeto
 
@@ -1100,8 +1263,9 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
             - **Llama 3.1 8B (geração de texto e chatbot)**
             - **FLUX.1 & SDXL (geração de imagens)**
             - Opus-MT (tradução)
-            - **Firebase Firestore (Banco de Dados)**
+            - **Firebase Firestore (Banco de Dados & Analytics)**
             - **PIL (Python Imaging Library) (para composição de posts)**
+            - **Cache local (para performance)**
 
             **Como funciona:**
             1. **Gerar Post:** Você define o tema, nicho, estilo e **formato** do *texto*.
@@ -1109,7 +1273,7 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
             3. O sistema otimiza o prompt, traduz para inglês e usa o sistema de *fallback* de modelos (baseado na *Qualidade*) para gerar a imagem.
             4. **Download:** Após a geração, você pode clicar em "Baixar Post Completo" para salvar um PNG com a imagem e o texto formatado.
             5. **Chatbot:** Você pode conversar diretamente com a IA na aba 'Chatbot Assistente' para tirar dúvidas.
-            6. **Histórico:** Os posts gerados são salvos no Firestore.
+            6. **Histórico & Analytics:** Os posts gerados são salvos no Firestore e as métricas de uso são atualizadas.
 
             **Desenvolvido por:** Wilder Paz
             """)
@@ -1117,9 +1281,132 @@ with gr.Blocks(theme=custom_theme, title="Gerador de Posts e Chatbot") as demo:
     # Footer
     gr.Markdown("""
     ---
-    **Curso de Python com IA** | 🤖 Powered by Llama 3.1 & FLUX | ⚡ Hugging Face Spaces + Gradio + Firestore
+    **Curso de Python com IA** | 🤖 Powered by Llama 3.1 & FLUX | ⚡ Hugging Face Spaces + Gradio + Firestore + Cache + Analytics
     """)
 
+    # ============================================
+    # CONECTAR EVENTOS
+    # ============================================
+    
+    # Lista de inputs para o botão Gerar
+    gerar_inputs = [
+        tema_input, nicho_input, estilo_input, 
+        formato_input, usar_cache_checkbox, favorito_checkbox,
+        descricao_img_input, gerar_img_checkbox,
+        estilo_img_input, qualidade_img_input, filtro_img_input
+    ]
+    
+    # Lista de outputs do botão Gerar
+    gerar_outputs = [
+        texto_output, imagem_output, status_output,  
+        palavras_output, caracteres_output, hashtags_output,
+        analytics_display
+    ]
+    
+    # Botão principal
+    click_event = gerar_btn.click(
+        fn=gerar_post_interface,
+        inputs=gerar_inputs,
+        outputs=gerar_outputs,
+        show_progress="full"
+    )
+    
+    # Botão copiar
+    copiar_btn.click(
+        fn=copiar_feedback,
+        inputs=[texto_output],
+        outputs=[status_output]
+    )
+    
+    # Lista de outputs para o botão Limpar
+    limpar_outputs = [
+        # Aba Gerador
+        texto_output, imagem_output, status_output,  
+        palavras_output, caracteres_output, hashtags_output,
+        formato_input, 
+        estilo_img_input, qualidade_img_input, filtro_img_input,
+        download_output,
+        usar_cache_checkbox,
+        analytics_display,
+        favorito_checkbox,
+        # Aba Histórico
+        busca_query_input,
+        filtro_nicho_hist,
+        filtro_estilo_hist,
+        filtro_formato_hist,
+        filtro_favoritos_hist
+    ]
+    
+    # Botão limpar
+    limpar_btn.click(
+        fn=limpar_tudo,
+        inputs=[],
+        outputs=limpar_outputs
+    )
+    
+    # Botão de Download
+    download_btn.click(
+        fn=preparar_download,
+        inputs=[texto_output, imagem_output, tema_input],
+        outputs=[download_output]
+    )
+    
+    # --- Eventos da Aba Histórico ---
+    
+    # Lista de inputs para os filtros de histórico
+    hist_filter_inputs = [
+        busca_query_input, 
+        filtro_nicho_hist, 
+        filtro_estilo_hist, 
+        filtro_formato_hist, 
+        filtro_favoritos_hist
+    ]
+    
+    # Botão de buscar no histórico
+    buscar_hist_btn.click(
+        fn=filtrar_historico_local,
+        inputs=hist_filter_inputs,
+        outputs=[historico_display]
+    )
+    
+    # Atualizar o histórico (mantendo filtros) após gerar um novo post
+    click_event.then(
+        fn=recarregar_e_formatar_historico,
+        inputs=hist_filter_inputs,
+        outputs=[historico_display]
+    )
+    
+    # Clicar em uma linha do histórico para carregar
+    historico_display.select(
+        fn=carregar_post_do_historico,
+        inputs=[], # Usa o dado do evento
+        outputs=[
+            main_tabs, # Para mudar de aba
+            tema_input,
+            nicho_input,
+            estilo_input,
+            formato_input,
+            favorito_checkbox,
+            texto_output,
+            status_output
+        ],
+        show_progress="minimal"
+    )
+    
+    # --- Eventos da Aba Analytics ---
+    
+    gerar_relatorio_btn.click(
+        fn=gerar_relatorio_analytics,
+        inputs=None,
+        outputs=[analytics_display]
+    )
+    
+    resetar_analytics_btn.click(
+        fn=resetar_analytics,
+        inputs=None,
+        outputs=[analytics_display]
+    )
+
 # Lançar aplicação
 if __name__ == "__main__":
     demo.launch()