Update app.py

app.py

@@ -2,333 +2,311 @@ import os
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
 
-import gradio as gr
+import pandas as pd
 import requests
-import json
-from datetime import datetime
-import time
-
-# ==================== CONFIGURAÇÕES ====================
-API_BASE_URL = "https://api.maxconconsorcios.com.br"
-WHATSAPP_NUMBER = "5516997865738"
-
-# Cache simples
-cache = {}
-
-# ==================== MAPEAMENTO DE ADMINISTRADORAS ====================
-ADMIN_MAP = {
-    1: 'Itaú', 2: 'Bradesco', 3: 'Santander', 4: 'Honda', 5: 'Volkswagen',
-    6: 'Serello', 7: 'Ademicon', 8: 'Remaza', 9: 'Porto Seguro VP',
-    10: 'Banrisul', 11: 'Embracon', 12: 'Serrana', 13: 'Caixa XS5',
-    14: 'Caixa CNP', 15: 'Unifisa', 16: 'HS Consorcios', 17: 'Caixa Seguradora',
-    18: 'Porto Seguro', 19: 'Mycon', 20: 'Rodobens', 21: 'Ford',
-    22: 'Sicoob Unicoob', 23: 'Zema', 24: 'Maggi', 25: 'Ancora', 26: 'Yamaha',
-    27: 'Sponchiado', 28: 'Scania', 29: 'Disal', 30: 'Servopa', 31: 'Canopus',
-    32: 'Bradesco', 33: 'Banco do Brasil', 34: 'Santander', 35: 'Sicredi'
-}
-
-# ==================== FUNÇÕES AUXILIARES ====================
-def formatar_moeda(valor):
-    """Formata valor para moeda brasileira"""
-    if valor is None or valor == '':
-        return "R$ 0,00"
-    try:
-        num = float(valor)
-        return f"R$ {num:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
-    except:
-        return "R$ 0,00"
-
-def get_administradora_nome(admin_id):
-    """Retorna nome da administradora pelo ID"""
-    return ADMIN_MAP.get(admin_id, 'Não especificado')
-
-def calcular_entrada_total(cota):
-    """Calcula entrada total incluindo comissão de 8.5%"""
-    credito = float(cota.get('valor_credito', 0))
-    entrada = float(cota.get('entrada', 0))
-    comissao = credito * 0.085
-    return entrada + comissao
-
-# ==================== BUSCA DE COTAS ====================
-def buscar_cotas_da_api():
-    """Busca cotas diretamente da API do Supabase"""
+import io
+import itertools
+from collections import defaultdict
+import gradio as gr
+
+# 🔧 CONFIGURAÇÕES DO ARQUIVO
+FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
+URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
+
+# Variáveis globais
+df_auto = None
+grupos_auto = None
+planilha_carregada = False
+ADMIN_OPCOES = []
+
+
+def carregar_planilha():
+    global df_auto, grupos_auto, planilha_carregada, ADMIN_OPCOES
+
+    if planilha_carregada:
+        return True
+
     try:
-        print("🔄 Buscando cotas na API...")
-        response = requests.post(
-            f"{API_BASE_URL}/api/cotas",
-            json={},
-            headers={'Content-Type': 'application/json'},
-            timeout=30
-        )
-        
-        if response.status_code == 200:
-            cotas = response.json()
-            print(f"✅ {len(cotas)} cotas carregadas")
-            return cotas
-        else:
-            print(f"❌ Erro na API: {response.status_code}")
-            return []
-            
-    except requests.exceptions.Timeout:
-        print("❌ Timeout na conexão com a API")
-        return []
-    except requests.exceptions.ConnectionError:
-        print("❌ Erro de conexão com a API")
-        return []
+        print("⏳ Carregando planilha de automóveis...")
+        response = requests.get(URL)
+        response.raise_for_status()
+        data = io.BytesIO(response.content)
+        df = pd.read_excel(data)
+
+        df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
+
+        colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
+        for col in colunas_numericas:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
+
+        if 'tipo_do_bem' not in df.columns or 'administradora' not in df.columns:
+            raise ValueError("Colunas essenciais não encontradas")
+
+        df.drop_duplicates(inplace=True)
+
+        df_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
+        df_auto['administradora'] = df_auto['administradora'].astype(str).str.strip().str.lower()
+        df_auto = df_auto[df_auto['administradora'].notna() & (df_auto['administradora'] != '')]
+
+        grupos_auto = defaultdict(list)
+        for _, row in df_auto.iterrows():
+            grupos_auto[row['administradora']].append(row.to_dict())
+
+        ADMIN_OPCOES = sorted(df_auto['administradora'].unique())
+        planilha_carregada = True
+
+        print(f"✅ Total de cotas AUTO: {len(df_auto)}")
+        print(f"✅ Administradoras AUTO: {ADMIN_OPCOES}")
+        return True
+
     except Exception as e:
-        print(f"❌ Erro ao buscar cotas: {str(e)}")
-        return []
-
-def buscar_combinacoes(credito, entrada, parcela, admin_selecionadas):
-    """
-    Função principal de busca de combinações
-    """
-    # Validação dos inputs
-    try:
-        credito_val = float(credito) if credito else 0
-    except:
-        credito_val = 0
-    
-    try:
-        entrada_val = float(entrada) if entrada else 0
-    except:
-        entrada_val = 0
-    
+        print(f"❌ Erro ao carregar planilha AUTO: {e}")
+        return False
+
+
+def formatar_moeda(valor):
+    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+
+
+def definir_margens_absolutas(credito, entrada, parcela):
+    margem_credito = 20_000   # ex.: 30.000 → 10.000–50.000
+    margem_entrada  = 2_000
+    margem_parcela  = 100
+
+    cred_min = max(0, credito - margem_credito)
+    cred_max = credito + margem_credito
+    ent_min  = max(0, entrada - margem_entrada)
+    ent_max  = entrada + margem_entrada
+    parc_min = max(0, parcela - margem_parcela)
+    parc_max = parcela + margem_parcela
+
+    return cred_min, cred_max, ent_min, ent_max, parc_min, parc_max
+
+
+def filtrar_cotas_por_faixa(cotas, cred_min, cred_max):
+    return [c for c in cotas if c['valor_credito'] < cred_max * 2]
+
+
+def calcular_tempo_parcelas(combinacao):
+    if not combinacao:
+        return ""
+
     try:
-        parcela_val = float(parcela) if parcela else 0
-    except:
-        parcela_val = 0
-    
-    if credito_val == 0 and entrada_val == 0 and parcela_val == 0:
-        return "❌ Informe pelo menos um valor (Crédito, Entrada ou Parcela)"
-    
-    # Busca cotas
-    cotas = buscar_cotas_da_api()
-    
-    if not cotas:
-        return """❌ **Erro ao carregar dados**
-
-Não foi possível conectar ao servidor. Por favor, tente novamente em alguns instantes.
-
-Se o erro persistir, entre em contato pelo WhatsApp."""
-    
-    # Filtra cotas disponíveis
-    cotas_disponiveis = [c for c in cotas if c.get('reserva') != 'reservado']
-    print(f"📊 Cotas disponíveis: {len(cotas_disponiveis)}")
-    
-    # Filtra por administradora
-    if admin_selecionadas and len(admin_selecionadas) > 0:
-        adm_ids_filtro = []
-        for admin_nome in admin_selecionadas:
-            for admin_id, nome in ADMIN_MAP.items():
-                if nome.lower() == admin_nome.lower():
-                    adm_ids_filtro.append(admin_id)
+        cotas_ordenadas = sorted(combinacao, key=lambda x: int(x.get('qtd_parcelas', 0)))
+        prazos = sorted(set(int(c.get('qtd_parcelas', 0)) for c in combinacao))
+
+        if not prazos or prazos[0] <= 0:
+            return ""
+
+        resultado = []
+        prazo_anterior = 0
+
+        for prazo_atual in prazos:
+            cotas_ativas = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) >= prazo_anterior + 1]
+            valor_parcela_total = sum(c.get('valor_parcela', 0) for c in cotas_ativas)
+
+            inicio = prazo_anterior + 1
+            fim = prazo_atual
+
+            if inicio <= fim and valor_parcela_total > 0:
+                resultado.append(f"{inicio}x à {fim}x: {formatar_moeda(valor_parcela_total)}/mês")
+
+            prazo_anterior = prazo_atual
+
+        if prazos and prazo_anterior < max(prazos):
+            cotas_ativas_finais = [c for c in cotas_ordenadas if int(c.get('qtd_parcelas', 0)) > prazo_anterior]
+            if cotas_ativas_finais:
+                valor_parcela_final = sum(c.get('valor_parcela', 0) for c in cotas_ativas_finais)
+                inicio_final = prazo_anterior + 1
+                fim_final = max(prazos)
+                if valor_parcela_final > 0:
+                    resultado.append(f"{inicio_final}x à {fim_final}x: {formatar_moeda(valor_parcela_final)}/mês")
+
+        return "\\n".join(resultado) if resultado else ""
+
+    except Exception as e:
+        print(f"❌ Erro calcular tempo de parcelas AUTO: {e}")
+        return ""
+
+
+def buscar_combinacoes(credito, entrada, parcela, adm_selecionadas):
+    if not planilha_carregada:
+        if not carregar_planilha():
+            return "❌ Erro: planilha de automóveis não carregada."
+
+    # Filtra administradoras
+    if adm_selecionadas:
+        grupos = {adm: cotas for adm, cotas in grupos_auto.items() if adm in adm_selecionadas}
+    else:
+        grupos = grupos_auto
+
+    if not grupos:
+        return "🚫 Nenhuma cota de automóvel encontrada com os filtros."
+
+    # Margens absolutas
+    cred_min, cred_max, ent_min, ent_max, parc_min, parc_max = definir_margens_absolutas(
+        float(credito or 0),
+        float(entrada or 0),
+        float(parcela or 0)
+    )
+
+    print(f"💰 AUTO - Crédito: R$ {credito:,.2f} → [{cred_min:,.2f}, {cred_max:,.2f}]")
+
+    # Limites de busca
+    max_cotas_combinacao = 15
+    max_combinacoes_por_adm = 4000
+
+    resultados = []
+    total_combinacoes_testadas = 0
+
+    for adm, cotas in grupos.items():
+        print(f"🔍 AUTO - Administradora: {adm} ({len(cotas)} cotas)")
+        cotas_filtradas = filtrar_cotas_por_faixa(cotas, cred_min, cred_max)
+
+        for r in range(1, min(max_cotas_combinacao + 1, len(cotas_filtradas) + 1)):
+            combinacoes_geradas = 0
+            for combinacao in itertools.combinations(cotas_filtradas, r):
+                if combinacoes_geradas >= max_combinacoes_por_adm:
                     break
-        
-        if adm_ids_filtro:
-            cotas_disponiveis = [c for c in cotas_disponiveis if c.get('administradora_id') in adm_ids_filtro]
-            print(f"📊 Após filtro de administradora: {len(cotas_disponiveis)}")
-    
-    # Filtra por crédito mínimo
-    if credito_val > 0:
-        cotas_disponiveis = [c for c in cotas_disponiveis if float(c.get('valor_credito', 0)) >= credito_val]
-        print(f"📊 Após filtro de crédito (≥ R$ {credito_val:,.2f}): {len(cotas_disponiveis)}")
-    
-    # Filtra por parcela máxima
-    if parcela_val > 0:
-        cotas_disponiveis = [c for c in cotas_disponiveis if float(c.get('valor_parcela', 0)) <= parcela_val]
-        print(f"📊 Após filtro de parcela (≤ R$ {parcela_val:,.2f}): {len(cotas_disponiveis)}")
-    
-    # Filtra por entrada máxima
-    if entrada_val > 0:
-        cotas_disponiveis = [c for c in cotas_disponiveis if calcular_entrada_total(c) <= entrada_val]
-        print(f"📊 Após filtro de entrada (≤ R$ {entrada_val:,.2f}): {len(cotas_disponiveis)}")
-    
-    if not cotas_disponiveis:
-        return """🚫 **Nenhuma cota encontrada**
-
-Tente ajustar os filtros:
-- Aumente o valor do crédito
-- Diminua o valor da entrada
-- Diminua o valor da parcela
-- Selecione mais administradoras"""
-    
-    # Ordena por crédito (do maior para o menor)
-    cotas_disponiveis.sort(key=lambda x: float(x.get('valor_credito', 0)), reverse=True)
-    
-    # Limita para exibição (máximo 15 resultados)
-    resultados = cotas_disponiveis[:15]
-    
-    return formatar_resultados(resultados)
-
-def formatar_resultados(cotas):
-    """Formata os resultados para exibição"""
-    if not cotas:
-        return "🚫 Nenhum resultado encontrado."
-    
-    resultado = f"## 🎯 Resultados encontrados: {len(cotas)} cota(s)\n\n"
-    
-    for idx, cota in enumerate(cotas, 1):
-        adm_nome = get_administradora_nome(cota.get('administradora_id'))
-        codigo = cota.get('codigo', 'N/A')
-        credito = float(cota.get('valor_credito', 0))
-        entrada_total = calcular_entrada_total(cota)
-        saldo = float(cota.get('saldo', 0))
-        parcela = float(cota.get('valor_parcela', 0))
-        prazo = int(cota.get('parcelas', 0))
-        
-        # Cálculos financeiros
-        credito_real = credito - entrada_total
-        valor_final = entrada_total + saldo
-        taxa_total = saldo - credito_real
-        taxa_percentual = (taxa_total / credito_real * 100) if credito_real > 0 else 0
-        
-        # Taxas
-        if prazo > 0:
-            taxa_mensal = taxa_percentual / prazo
-            taxa_anual = taxa_mensal * 12
-        else:
-            taxa_mensal = 0
-            taxa_anual = 0
-        
-        resultado += f"""
-### 📌 Combinação {idx}
-
-| Campo | Valor |
-|-------|-------|
-| 🏢 **Administradora** | {adm_nome} |
-| 🔢 **Código** | {codigo} |
-| 💰 **Crédito** | {formatar_moeda(credito)} |
-| 💵 **Entrada** | {formatar_moeda(entrada_total)} |
-| 💲 **Parcela** | {formatar_moeda(parcela)} |
-| ⏳ **Prazo** | {prazo} meses |
-| 📉 **Saldo Devedor** | {formatar_moeda(saldo)} |
-| 🔚 **Valor Final** | {formatar_moeda(valor_final)} |
-| 💠 **Crédito Líquido** | {formatar_moeda(credito_real)} |
-| 📊 **Taxa Total** | {taxa_percentual:.2f}% ({formatar_moeda(taxa_total)}) |
-| 🗓️ **Taxa Mensal** | {taxa_mensal:.2f}% |
-| 🗓️ **Taxa Anual** | {taxa_anual:.2f}% |
-
-**⏰ Tempo de Parcelas:**
-- 1x à {min(21, prazo)}x: {formatar_moeda(parcela)}/mês
-"""
-        if prazo > 21:
-            valor_reduzido = parcela * 0.44
-            resultado += f"- {22}x à {prazo}x: {formatar_moeda(valor_reduzido)}/mês\n"
-        
-        resultado += f"""
----
-"""
-    
-    resultado += f"""
-### 📞 **Interessado?**
-Entre em contato pelo WhatsApp para negociar esta cota:
 
-[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge&logo=whatsapp&logoColor=white)](https://wa.me/{WHATSAPP_NUMBER}?text=Olá! Tenho interesse nas cotas de consórcio)
+                total_combinacoes_testadas += 1
+                combinacoes_geradas += 1
+
+                total_cred = sum(c['valor_credito'] for c in combinacao)
+                total_ent_base = sum(c['valor_entrada'] for c in combinacao)
+                total_ent = total_ent_base + total_cred * 0.085
+                total_parc = sum(c['valor_parcela'] for c in combinacao)
+
+                if (cred_min <= total_cred <= cred_max and
+                    ent_min <= total_ent <= ent_max and
+                    parc_min <= total_parc <= parc_max):
+
+                    total_saldo = sum(c['saldo_devedor'] for c in combinacao)
+                    valor_final = round(total_ent + total_saldo, 2)
+                    diff = abs(valor_final - total_cred)
+                    resultados.append((adm, combinacao, diff))
+
+                    if len(resultados) >= 45:
+                        break
+            if len(resultados) >= 45:
+                break
+        if len(resultados) >= 45:
+            break
+
+    print(f"🔍 AUTO - Total de combinações testadas: {total_combinacoes_testadas}")
+
+    if not resultados:
+        return "🚫 Nenhuma combinação de auto encontrada com os parâmetros fornecidos."
+
+    resultados.sort(key=lambda x: x[2])
+    return formatar_resultados(resultados[:15])
+
+
+def formatar_resultados(resultados):
+    if not resultados:
+        return "🚫 Nenhuma combinação de auto adequada encontrada."
+
+    resposta = ""
+    for idx, (adm, comb, _) in enumerate(resultados, 1):
+        codigos = [str(c.get('codigo', 'N/A')) for c in comb]
+        total_cred = sum(c['valor_credito'] for c in comb)
+        total_ent_base = sum(c['valor_entrada'] for c in comb)
+        total_ent = total_ent_base + total_cred * 0.085
+        total_saldo = sum(c['saldo_devedor'] for c in comb)
+        total_parc = sum(c['valor_parcela'] for c in comb)
+        maior_prazo = max(int(c.get('qtd_parcelas', 0)) for c in comb)
+        valor_final = round(total_ent + total_saldo, 2)
+        cred_real = total_cred - total_ent
+        taxa_total = total_saldo - cred_real
+        taxa_perc = (taxa_total / cred_real) * 100 if cred_real > 0 else 0
+        taxa_mensal = taxa_perc / maior_prazo if maior_prazo > 0 else 0
+        tempo = calcular_tempo_parcelas(comb)
+
+        resposta += f"""
+--- COMBINAÇÃO {idx} AUTO ---
+🏢 Administradora: {adm}
+🔢 Códigos: {', '.join(codigos)} ({len(comb)} cotas)
+💰 Crédito Total: {formatar_moeda(total_cred)}
+💵 Entrada (+comissão): {formatar_moeda(total_ent)}
+📉 Saldo Devedor: {formatar_moeda(total_saldo)}
+💲 Parcela: {formatar_moeda(total_parc)}
+⏳ Prazo: {maior_prazo} meses
+🔚 Valor Final: {formatar_moeda(valor_final)}
+💠 Crédito Líquido: {formatar_moeda(cred_real)}
+📊 Taxa Total: {taxa_perc:.2f}% ({formatar_moeda(taxa_total)})
+🗓️ Taxa Mensal: {taxa_mensal:.2f}%
+🗓️ Taxa Anual: {taxa_mensal * 12:.2f}%
+⏰ TEMPO DE PARCELAS:
+{tempo if tempo else "Não foi possível calcular"}
 """
-    
-    return resultado
+    return resposta
 
-# ==================== FUNÇÃO PARA OBTER ADMINISTRADORAS ====================
-def obter_administradoras():
-    """Obtém lista de administradoras disponíveis"""
-    try:
-        cotas = buscar_cotas_da_api()
-        adm_set = set()
-        for cota in cotas:
-            admin_id = cota.get('administradora_id')
-            if admin_id:
-                adm_set.add(get_administradora_nome(admin_id))
-        return sorted(list(adm_set))
-    except:
-        # Lista fallback caso não consiga carregar
-        return ["Porto Seguro", "Itaú", "Bradesco", "Santander", "Banco do Brasil", "Honda", "Yamaha"]
-
-# ==================== INTERFACE GRADIO ====================
-def create_interface():
-    with gr.Blocks(title="MAXCON - Consórcio Auto", theme=gr.themes.Soft()) as demo:
-        gr.HTML("""
-        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #1a3a6c 0%, #2a5a9c 100%); border-radius: 12px; margin-bottom: 20px;">
-            <h1 style="color: white; margin: 0;">🚗 MAXCON Consórcios</h1>
-            <p style="color: #ffd166; margin: 10px 0 0 0;">Encontre as melhores cotas para seu veículo</p>
-        </div>
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                credito_input = gr.Number(
-                    label="💰 Crédito Desejado (mínimo)",
-                    value=100000,
-                    step=1000,
-                    precision=2
-                )
-                entrada_input = gr.Number(
-                    label="💵 Entrada (máximo)",
-                    value=50000,
-                    step=1000,
-                    precision=2
-                )
-                parcela_input = gr.Number(
-                    label="💲 Parcela (máximo)",
-                    value=2000,
-                    step=100,
-                    precision=2
-                )
-                
-                # Carrega administradoras dinamicamente
-                admin_choices = obter_administradoras()
-                adm_input = gr.Dropdown(
-                    choices=admin_choices,
-                    label="🏢 Administradoras",
-                    multiselect=True,
-                    value=admin_choices[:5] if len(admin_choices) > 5 else admin_choices,
-                    interactive=True
-                )
-                
-                buscar_btn = gr.Button("🔍 Buscar Combinações", variant="primary", size="lg")
-                
-                # Botão de limpar
-                limpar_btn = gr.Button("🗑️ Limpar Filtros", variant="secondary", size="lg")
-            
-            with gr.Column(scale=2):
-                output_text = gr.Markdown(
-                    value="### 🔍 Aguardando busca...\n\nPreencha os filtros ao lado e clique em 'Buscar Combinações'",
-                    label="Resultados"
-                )
-        
-        # Eventos
-        buscar_btn.click(
-            fn=buscar_combinacoes,
-            inputs=[credito_input, entrada_input, parcela_input, adm_input],
-            outputs=output_text
-        )
-        
-        def limpar_filtros():
-            return [0, 0, 0, []]
-        
-        limpar_btn.click(
-            fn=limpar_filtros,
-            outputs=[credito_input, entrada_input, parcela_input, adm_input]
-        )
-        
-        gr.Markdown("""
-        ---
-        ### 📌 Sobre a Busca
-        
-        - Os resultados são buscados **em tempo real** do nosso banco de dados
-        - Valores atualizados diariamente
-        - **Comissão de 8.5%** já incluída no valor da entrada
-        - Entre em contato pelo WhatsApp para negociar
-        
-        ---
-        **MAXCON Assessoria** - Realizando sonhos há mais de 5 anos
-        """)
-    
-    return demo
-
-# ==================== INICIALIZAÇÃO ====================
+
+# 🔁 Carregar a planilha uma vez, no início do programa
+carregar_planilha()
+
+
+# Interface Gradio (exatamente igual ao imóvel, com Blocks)
+with gr.Blocks(title="🚗 Sistema de Busca de Consórcio Auto") as demo_auto:
+    gr.HTML("""
+    <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
+    <style>
+        * { font-family: 'Poppins', sans-serif !important; }
+        body { background-color: #ff8f00 !important; color: black !important; }
+        input[type="number"], textarea {
+            background-color: white !important;
+            border: 2px solid black !important;
+            border-radius: 12px !important;
+            color: black !important;
+            padding: 10px !important;
+        }
+        .gr-button {
+            font-weight: bold;
+            border-radius: 10px !important;
+            background-color: white !important;
+            color: black !important;
+            border: 2px solid black !important;
+        }
+    </style>
+    """)
+
+    gr.Markdown("# 🚗 Busca de Combinações de Consórcio Auto")
+    gr.Markdown("Insira os valores desejados para crédito, entrada e parcela, e filtre por administradora.")
+
+    with gr.Row():
+        credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000)
+        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100)
+        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10)
+
+    adm_input = gr.Dropdown(
+        choices=ADMIN_OPCOES,
+        label="Filtrar por Administradoras",
+        multiselect=True,
+        value=ADMIN_OPCOES,
+        interactive=True
+    )
+
+    submit_btn = gr.Button("🔍 Buscar Combinações AUTO", variant="primary")
+    output_text = gr.Textbox(
+        label="Resultados AUTO",
+        lines=20,
+        max_lines=40,
+        interactive=False,
+        placeholder="Os resultados aparecerão aqui..."
+    )
+
+    submit_btn.click(
+        fn=buscar_combinacoes,
+        inputs=[credito_input, entrada_input, parcela_input, adm_input],
+        outputs=output_text
+    )
+
+    gr.Markdown("---")
+    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio automotivo.")
+
+
+# Executar o app
 if __name__ == "__main__":
-    print("🚀 Iniciando servidor MAXCON no Hugging Face...")
-    print(f"📡 API Base: {API_BASE_URL}")
-    demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo_auto.launch()
+#