Update app.py

app.py

@@ -4,309 +4,364 @@ os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
 
 import pandas as pd
 import requests
-import io
-import itertools
+import json
 from collections import defaultdict
 import gradio as gr
+from datetime import datetime
+import hashlib
 
-# 🔧 CONFIGURAÇÕES DO ARQUIVO
-FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
-URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
+# ==================== CONFIGURAÇÕES ====================
+API_BASE_URL = "https://api.maxconconsorcios.com.br"
+WHATSAPP_NUMBER = "5516997865738"
 
-# 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
+# Cache para evitar muitas requisições
+cache = {}
+CACHE_TTL = 300  # 5 minutos
 
+# ==================== FUNÇÕES AUXILIARES ====================
+def formatar_moeda(valor):
+    """Formata valor para moeda brasileira"""
+    if valor is None:
+        return "R$ 0,00"
     try:
-        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 carregar planilha AUTO: {e}")
+        return f"R$ {float(valor):,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+    except:
+        return "R$ 0,00"
+
+def get_cache_key(prefix, *args, **kwargs):
+    """Gera chave de cache"""
+    key_data = {'prefix': prefix, 'args': args, 'kwargs': kwargs}
+    key_string = json.dumps(key_data, sort_keys=True)
+    return f"{prefix}_{hashlib.md5(key_string.encode()).hexdigest()}"
+
+def is_cache_valid(key):
+    """Verifica se cache é válido"""
+    if key not in cache:
         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 ""
-
+    timestamp, _ = cache[key]
+    return (datetime.now() - timestamp).total_seconds() < CACHE_TTL
+
+def set_cache(key, value):
+    """Armazena no cache"""
+    cache[key] = (datetime.now(), value)
+
+def get_cache(key):
+    """Recupera do cache"""
+    if is_cache_valid(key):
+        return cache[key][1]
+    return None
+
+# ==================== BUSCA DE COTAS VIA SUPABASE ====================
+def buscar_cotas_supabase(filtros=None):
+    """
+    Busca cotas diretamente do Supabase através da API
+    (mesma fonte do backend da Foto 1)
+    """
+    cache_key = get_cache_key('cotas', filtros)
+    cached = get_cache(cache_key)
+    if cached:
+        print("📦 Cache HIT para cotas")
+        return cached
+    
     try:
-        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 ""
-
+        print(f"🔍 Buscando cotas na API: {API_BASE_URL}/api/cotas")
+        
+        # Prepara payload para a API
+        payload = {}
+        if filtros:
+            if filtros.get('categoria'):
+                payload['categoria'] = filtros['categoria']
+            if filtros.get('valor_credito_min'):
+                payload['valor_credito'] = filtros['valor_credito_min']
+            if filtros.get('valor_parcela_max'):
+                payload['valor_parcela'] = filtros['valor_parcela_max']
+            if filtros.get('administradora_id'):
+                payload['administradora_id'] = filtros['administradora_id']
+        
+        response = requests.post(
+            f"{API_BASE_URL}/api/cotas",
+            json=payload,
+            headers={'Content-Type': 'application/json'},
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            cotas = response.json()
+            print(f"✅ {len(cotas)} cotas encontradas")
+            set_cache(cache_key, cotas)
+            return cotas
+        else:
+            print(f"❌ Erro na API: {response.status_code}")
+            return []
+            
     except Exception as e:
-        print(f"❌ Erro calcular tempo de parcelas AUTO: {e}")
+        print(f"❌ Erro ao buscar cotas: {str(e)}")
+        return []
+
+def get_administradoras_list():
+    """Obtém lista de administradoras disponíveis"""
+    cache_key = get_cache_key('administradoras')
+    cached = get_cache(cache_key)
+    if cached:
+        return cached
+    
+    cotas = buscar_cotas_supabase()
+    administradoras = set()
+    
+    for cota in cotas:
+        admin_id = cota.get('administradora_id')
+        if admin_id:
+            administradoras.add(get_administradora_nome(admin_id))
+    
+    resultado = sorted(list(administradoras))
+    set_cache(cache_key, resultado)
+    return resultado
+
+def get_administradora_nome(admin_id):
+    """Mapeia ID da administradora para nome"""
+    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'
+    }
+    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
+
+def formatar_tempo_parcelas(cota):
+    """Formata o tempo de parcelas com escalonamento (1-21x e 22-27x)"""
+    parcelas = int(cota.get('parcelas', 0))
+    valor_parcela = float(cota.get('valor_parcela', 0))
+    
+    if parcelas == 0:
         return ""
-
-
+    
+    resultado = []
+    
+    # Primeiro período: 1x à 21x
+    primeiro_periodo = min(21, parcelas)
+    resultado.append(f"{1}x à {primeiro_periodo}x: {formatar_moeda(valor_parcela)}/mês")
+    
+    # Segundo período: se houver mais de 21 parcelas
+    if parcelas > 21:
+        # Valor reduzido (aproximadamente 44% do valor original)
+        valor_reduzido = valor_parcela * 0.44
+        resultado.append(f"{22}x à {parcelas}x: {formatar_moeda(valor_reduzido)}/mês")
+    
+    return "\\n".join(resultado)
+
+# ==================== FUNÇÃO PRINCIPAL DE BUSCA ====================
 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
-
-                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:
+    """
+    Busca combinações de cotas usando a API real do Supabase
+    """
+    if not credito and not entrada and not parcela:
+        return "❌ Informe pelo menos um valor (Crédito, Entrada ou Parcela)"
+    
+    try:
+        # Converte valores para float
+        credito_val = float(credito) if credito else 0
+        entrada_val = float(entrada) if entrada else 0
+        parcela_val = float(parcela) if parcela else 0
+        
+        print(f"🔍 Buscando - Crédito: R$ {credito_val:,.2f}, Entrada: R$ {entrada_val:,.2f}, Parcela: R$ {parcela_val:,.2f}")
+        
+        # Busca cotas na API
+        cotas = buscar_cotas_supabase()
+        
+        if not cotas:
+            return "❌ Erro ao carregar cotas. Tente novamente mais tarde."
+        
+        # Filtra cotas disponíveis
+        cotas = [c for c in cotas if c.get('reserva') != 'reservado']
+        
+        # Filtra por administradora
+        if adm_selecionadas:
+            adm_ids = []
+            for adm_nome in adm_selecionadas:
+                for admin_id, nome in get_admin_map().items():
+                    if nome.lower() == adm_nome.lower():
+                        adm_ids.append(admin_id)
                         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."
-
+            
+            if adm_ids:
+                cotas = [c for c in cotas if c.get('administradora_id') in adm_ids]
+        
+        # Filtra por crédito mínimo
+        if credito_val > 0:
+            cotas = [c for c in cotas if float(c.get('valor_credito', 0)) >= credito_val]
+        
+        # Filtra por parcela máxima
+        if parcela_val > 0:
+            cotas = [c for c in cotas if float(c.get('valor_parcela', 0)) <= parcela_val]
+        
+        # Filtra por entrada máxima
+        if entrada_val > 0:
+            cotas = [c for c in cotas if calcular_entrada_total(c) <= entrada_val]
+        
+        # Ordena por crédito (maior para menor)
+        cotas.sort(key=lambda x: float(x.get('valor_credito', 0)), reverse=True)
+        
+        if not cotas:
+            return "🚫 Nenhuma cota encontrada com os filtros selecionados."
+        
+        # Limita para exibição
+        cotas = cotas[:15]
+        
+        # Formata resultados
+        return formatar_resultados(cotas)
+        
+    except Exception as e:
+        print(f"❌ Erro na busca: {str(e)}")
+        return f"❌ Erro ao buscar combinações: {str(e)}"
+
+def formatar_resultados(cotas):
+    """Formata os resultados para exibição"""
+    if not cotas:
+        return "🚫 Nenhuma combinação 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)
-
+    
+    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 mensal e anual
+        if prazo > 0:
+            taxa_mensal = taxa_percentual / prazo
+            taxa_anual = taxa_mensal * 12
+        else:
+            taxa_mensal = 0
+            taxa_anual = 0
+        
+        tempo_parcelas = formatar_tempo_parcelas(cota)
+        
         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
+--- COMBINAÇÃO {idx} ---
+🏢 Administradora: {adm_nome}
+🔢 Código: {codigo}
+💰 Crédito Total: {formatar_moeda(credito)}
+💵 Entrada Total: {formatar_moeda(entrada_total)}
+📉 Saldo Devedor: {formatar_moeda(saldo)}
+💲 Parcela: {formatar_moeda(parcela)}
+⏳ Prazo: {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)})
+💠 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_mensal * 12:.2f}%
+🗓️ Taxa Anual: {taxa_anual:.2f}%
 ⏰ TEMPO DE PARCELAS:
-{tempo if tempo else "Não foi possível calcular"}
+{tempo_parcelas if tempo_parcelas else "Não disponível"}
 """
+    
     return resposta
 
+def get_admin_map():
+    """Retorna mapeamento de administradoras"""
+    return {
+        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'
+    }
+
+# ==================== INTERFACE GRADIO ====================
+def obter_administradoras():
+    """Obtém lista de administradoras para o dropdown"""
+    try:
+        return get_administradoras_list()
+    except:
+        return ["Porto Seguro", "Itaú", "Bradesco", "Santander", "Banco do Brasil"]
 
-# 🔁 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:
+with gr.Blocks(title="🚗 MAXCON - Busca de Consórcio Auto", theme=gr.themes.Soft()) 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>
+    <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>
     """)
-
-    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(
+        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
+            )
+            
+            adm_input = gr.Dropdown(
+                choices=obter_administradoras(),
+                label="🏢 Administradoras",
+                multiselect=True,
+                interactive=True
+            )
+            
+            buscar_btn = gr.Button("🔍 Buscar Combinações", variant="primary", size="lg")
+        
+        with gr.Column(scale=2):
+            output_text = gr.Textbox(
+                label="📋 Resultados",
+                lines=25,
+                max_lines=40,
+                interactive=False,
+                placeholder="Os resultados aparecerão aqui após a busca..."
+            )
+    
+    buscar_btn.click(
         fn=buscar_combinacoes,
         inputs=[credito_input, entrada_input, parcela_input, adm_input],
         outputs=output_text
     )
+    
+    gr.Markdown("""
+    ---
+    ### 📌 Sobre a Busca
+    
+    - Os resultados são buscados **em tempo real** do nosso banco de dados
+    - Valores atualizados diariamente
+    - Entre em contato pelo WhatsApp para negociar
+    """)
 
-    gr.Markdown("---")
-    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio automotivo.")
-
-
-# Executar o app
+# ==================== INICIALIZAÇÃO ====================
 if __name__ == "__main__":
-    demo_auto.launch()
-#
+    print("🚀 Iniciando servidor MAXCON no Hugging Face...")
+    print(f"📡 API Base: {API_BASE_URL}")
+    demo_auto.launch()