Update app.py

app.py

@@ -3,23 +3,22 @@ import requests
 import io
 import itertools
 from collections import defaultdict
-import gradio as gr
-import time
-import numpy as np
-from concurrent.futures import ThreadPoolExecutor, as_completed
-import heapq
+import gradio as gr # Importação principal para Gradio
+import os # Para variáveis de ambiente, se necessário
 
 # 🔧 CONFIGURAÇÕES GLOBAIS
+# O ID da planilha para Consórcio de Automóveis
+# Certifique-se de que este FILE_ID esteja acessível publicamente ou para "Qualquer pessoa com o link"
 FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
 URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
 
 # Variável global para armazenar o DataFrame
 df = None
-df_filtrado_auto = None
+
 
 def carregar_planilha():
     """Carrega e prepara a planilha para análise de consórcios de automóveis."""
-    global df, df_filtrado_auto
+    global df
     try:
         print("⏳ Carregando planilha...")
         response = requests.get(URL)
@@ -34,6 +33,7 @@ def carregar_planilha():
         if 'administradora' in df.columns:
             df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
 
+
         # Converte colunas numéricas
         numeric_cols = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
         for col in numeric_cols:
@@ -46,127 +46,33 @@ def carregar_planilha():
 
         # Remove duplicatas
         df.drop_duplicates(inplace=True)
-        
-        # Pré-filtra dados de automóveis para otimização
-        df_filtrado_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
-        
-        # Pré-calcula valores importantes
-        df_filtrado_auto['entrada_com_comissao'] = df_filtrado_auto['valor_entrada'] + (df_filtrado_auto['valor_credito'] * 0.085)
-        
         print("✅ Planilha carregada com sucesso!")
         return True
 
     except Exception as e:
         print(f"❌ Erro ao carregar planilha: {str(e)}")
+        # Retorne uma mensagem de erro mais útil para o usuário
         return False
 
-def agrupar_por_administradora_otimizado(dataframe, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max):
-    """Agrupa cotas por administradora com pré-filtro otimizado."""
+def agrupar_por_administradora(dataframe):
+    """Agrupa cotas por administradora."""
     grupos = defaultdict(list)
-    
-    # Pré-filtra as cotas que estão dentro das faixas individuais
     for _, row in dataframe.iterrows():
-        credito = row['valor_credito']
-        entrada = row['entrada_com_comissao']
-        parcela = row['valor_parcela']
-        
-        # Verifica se a cota individual está dentro das faixas aceitáveis
-        if (credito_min * 0.1 <= credito <= credito_max * 2.0 and
-            entrada_min * 0.1 <= entrada <= entrada_max * 2.0 and
-            parcela_min * 0.1 <= parcela <= parcela_max * 3.0):
-            
-            grupos[row['administradora']].append(row.to_dict())
-    
+        grupos[row['administradora']].append(row.to_dict())
     return grupos
 
-def encontrar_combinacoes_otimizado(cotas, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max, max_combinacoes=1000):
-    """Encontra combinações de forma otimizada usando poda de busca."""
-    resultados = []
-    n = len(cotas)
-    
-    # Ordena as cotas por valor de crédito para poda mais eficiente
-    cotas_ordenadas = sorted(cotas, key=lambda x: x['valor_credito'])
-    
-    # Função recursiva com poda
-    def backtrack(start, combinacao_atual, credito_total, entrada_total, parcela_total):
-        # Poda: se já ultrapassou os limites máximos, não continua
-        if credito_total > credito_max * 1.1 or entrada_total > entrada_max * 1.1 or parcela_total > parcela_max * 1.5:
-            return
-            
-        # Se está dentro dos limites, adiciona ao resultado
-        if (credito_min <= credito_total <= credito_max and
-            entrada_min <= entrada_total <= entrada_max and
-            parcela_min <= parcela_total <= parcela_max):
-            
-            # Calcula a diferença para ordenação
-            saldo_total = sum(c['saldo_devedor'] for c in combinacao_atual)
-            valor_final = entrada_total + saldo_total
-            diferenca = abs(valor_final - credito_total)
-            
-            # Usa heap para manter apenas as melhores combinações
-            if len(resultados) < max_combinacoes:
-                heapq.heappush(resultados, (-diferenca, combinacao_atual[:]))
-            else:
-                # Substitui a pior combinação se esta for melhor
-                heapq.heappushpop(resultados, (-diferenca, combinacao_atual[:]))
-        
-        # Limita o tamanho das combinações e continua a busca
-        if len(combinacao_atual) < 10 and start < n:
-            for i in range(start, n):
-                cota = cotas_ordenadas[i]
-                novo_credito = credito_total + cota['valor_credito']
-                nova_entrada = entrada_total + cota['entrada_com_comissao']
-                nova_parcela = parcela_total + cota['valor_parcela']
-                
-                # Poda: se já ultrapassou muito os limites, não continua
-                if novo_credito > credito_max * 1.5 or nova_entrada > entrada_max * 1.5:
-                    continue
-                    
-                combinacao_atual.append(cota)
-                backtrack(i + 1, combinacao_atual, novo_credito, nova_entrada, nova_parcela)
-                combinacao_atual.pop()
-    
-    # Inicia a busca
-    backtrack(0, [], 0, 0, 0)
-    
-    # Converte o heap para lista ordenada
-    resultados_ordenados = []
-    while resultados:
-        diferenca, combinacao = heapq.heappop(resultados)
-        resultados_ordenados.append((combinacao, -diferenca))
-    
-    return resultados_ordenados
-
-def processar_administradora_10_cotas(args):
-    """Processa uma administradora para combinações de até 10 cotas."""
-    adm, cotas, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max = args
-    resultados_adm = []
-    
-    # Limita para as 20 melhores cotas por administradora
-    cotas_limitadas = cotas[:20]
-    
-    # Encontra combinações de forma otimizada
-    combinacoes = encontrar_combinacoes_otimizado(
-        cotas_limitadas, credito_min, credito_max, entrada_min, entrada_max, 
-        parcela_min, parcela_max, max_combinacoes=100
-    )
-    
-    for combinacao, diferenca in combinacoes:
-        resultados_adm.append((adm, combinacao, diferenca))
-    
-    return resultados_adm
-
-def buscar_combinacoes_10_cotas(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de até 10 cotas de forma otimizada."""
-    global df_filtrado_auto
-    
-    if df_filtrado_auto is None:
+def buscar_combinacoes(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
+    """Busca combinações de cotas para automóveis dentro dos parâmetros especificados."""
+    global df
+    if df is None:
         if not carregar_planilha():
             return "❌ Erro: Planilha não carregada. Verifique se o ID do arquivo está correto e público."
 
-    # Filtra por administradoras selecionadas
-    df_filtrado = df_filtrado_auto.copy()
+    # Filtra por tipo de bem (Auto) e administradoras selecionadas
+    df_filtrado = df[df['tipo_do_bem'].str.lower() == 'auto']
     if administradoras:
+        if isinstance(administradoras, tuple):
+            administradoras = list(administradoras)
         administradoras = [a.strip().lower() for a in administradoras]
         df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
 
@@ -178,48 +84,34 @@ def buscar_combinacoes_10_cotas(credito_desejado, entrada_desejada, parcela_dese
     entrada_min, entrada_max = entrada_desejada * 0.93, entrada_desejada * 1.07
     parcela_min, parcela_max = parcela_desejada * 0.5, parcela_desejada * 1.5
 
-    # Agrupa com pré-filtro otimizado
-    grupos = agrupar_por_administradora_otimizado(
-        df_filtrado, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max
-    )
-    
-    # Prepara argumentos para processamento paralelo
-    args_list = []
-    for adm, cotas in grupos.items():
-        if cotas:  # Só processa administradoras com cotas
-            args_list.append((adm, cotas, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max))
-    
+    grupos = agrupar_por_administradora(df_filtrado)
     resultados = []
-    
-    # Processa em paralelo
-    if args_list:
-        with ThreadPoolExecutor(max_workers=min(4, len(args_list))) as executor:
-            futures = [executor.submit(processar_administradora_10_cotas, args) for args in args_list]
-            for future in as_completed(futures):
-                resultados.extend(future.result())
+    MAX_COMBINACOES_POR_ADM = 1000  # Limite para evitar processamento excessivo
 
-    if not resultados:
-        # Tenta com faixas mais amplas se não encontrou resultados
-        credito_min, credito_max = credito_desejado * 0.90, credito_desejado * 1.10
-        entrada_min, entrada_max = entrada_desejada * 0.90, entrada_desejada * 1.10
-        
-        grupos = agrupar_por_administradora_otimizado(
-            df_filtrado, credito_min, credito_max, entrada_min, entrada_max, parcela_min, parcela_max
-        )
+    for adm, cotas in grupos.items():
+        cotas = cotas[:20]  # Limita a 20 cotas por administradora para evitar combinações explosivas
+        combinacoes_validas = 0
         
-        for adm, cotas in grupos.items():
-            if not cotas:
-                continue
-                
-            cotas = cotas[:20]  # Limita a 20 cotas por administradora
-            
-            combinacoes = encontrar_combinacoes_otimizado(
-                cotas, credito_min, credito_max, entrada_min, entrada_max, 
-                parcela_min, parcela_max, max_combinacoes=50
-            )
-            
-            for combinacao, diferenca in combinacoes:
-                resultados.append((adm, combinacao, diferenca))
+        for r in range(1, min(5, len(cotas)) + 1):  # Agora até 5 cotas
+            for combinacao in itertools.combinations(cotas, r):
+                if combinacoes_validas >= MAX_COMBINACOES_POR_ADM:
+                    break
+                    
+                total_credito = sum(c['valor_credito'] for c in combinacao)
+                total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
+                total_entrada = total_entrada_base + (total_credito * 0.085)
+                total_parcelas = sum(c['valor_parcela'] for c in combinacao)
+
+                if (credito_min <= total_credito <= credito_max and
+                    entrada_min <= total_entrada <= entrada_max and
+                    parcela_min <= total_parcelas <= parcela_max):
+
+                    total_saldo = sum(c['saldo_devedor'] for c in combinacao)
+                    valor_final = round(total_entrada + total_saldo, 2)
+                    diferenca = abs(valor_final - total_credito)
+
+                    resultados.append((adm, combinacao, diferenca))
+                    combinacoes_validas += 1
 
     if not resultados:
         return "Nenhuma combinação adequada encontrada para automóveis com os parâmetros fornecidos."
@@ -227,44 +119,73 @@ def buscar_combinacoes_10_cotas(credito_desejado, entrada_desejada, parcela_dese
     # Ordena por diferença (melhores combinações primeiro)
     resultados.sort(key=lambda x: x[2])
     
-    # Limita o número total de resultados
-    resultados = resultados[:200]
+    # Limita o número total de resultados para evitar sobrecarga
+    resultados = resultados[:500]
     
-    return formatar_resultados_10_cotas(resultados)
+    return formatar_resultados(resultados)
 
 def formatar_moeda(valor):
     return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
 
-def formatar_resultados_10_cotas(resultados):
+def formatar_resultados(resultados):
     """Formata os resultados para exibição."""
-    if not resultados:
-        return "Nenhuma combinação encontrada."
-        
-    resposta = f"📊 **Total de {len(resultados)} combinações encontradas (1-10 cotas)**\n\n"
+    resposta = ""
     
-    # Agrupa por administradora mantendo a ordenação por qualidade
+     # 1. Agrupar os resultados por administradora, mantendo a diferença para ordenação interna
+    # grouped_by_adm = {'Administradora X': [(combinacao_A, 100), (combinacao_C, 180), ...],
+    #                   'Administradora Y': [(combinacao_B, 150), ...]}
     grouped_by_adm = defaultdict(list)
     for adm, combinacao, diferenca in resultados:
         grouped_by_adm[adm].append((combinacao, diferenca))
 
-    # Ordena cada grupo por diferença
+    # 2. Ordenar as combinações dentro de cada administradora pela diferença (do menor para o maior)
     for adm in grouped_by_adm:
-        grouped_by_adm[adm].sort(key=lambda x: x[1])
-
-    # Seleciona as melhores combinações de cada administradora
-    final_resultados = []
-    for adm, combinacoes in grouped_by_adm.items():
-        # Pega as 5 melhores de cada administradora
-        for combinacao, diferenca in combinacoes[:5]:
-            final_resultados.append((adm, combinacao, diferenca))
+        grouped_by_adm[adm].sort(key=lambda x: x[1]) # x[1] é a diferença
+
+    final_resultados_diversificados = []
     
-    # Ordena todas as combinações por qualidade
-    final_resultados.sort(key=lambda x: x[2])
+    # Dicionário para acompanhar o índice da próxima combinação a ser pega de cada administradora
+    # Ex: {'Itau': 0, 'Bradesco': 0, 'Caixa': 0}
+    adm_indices = {adm: 0 for adm in grouped_by_adm.keys()}
+
+    # Lista de administradoras ativas (que ainda têm combinações disponíveis)
+    active_adms = list(grouped_by_adm.keys())
     
-    # Limita a 20 resultados finais para exibição
-    final_resultados = final_resultados[:20]
+    current_adm_idx = 0 # Índice para ciclar entre as administradoras ativas
     
-    for idx, (adm, combinacao, diferenca) in enumerate(final_resultados, 1):
+    # Loop para selecionar até 15 combinações, garantindo diversidade
+    while len(final_resultados_diversificados) < 15 and active_adms:
+        # Pega a administradora da vez para selecionar uma combinação
+        adm_da_vez = active_adms[current_adm_idx]
+        
+        # Pega o índice da próxima combinação para essa administradora
+        idx_na_adm = adm_indices[adm_da_vez]
+        
+        # Verifica se essa administradora ainda tem combinações disponíveis
+        if idx_na_adm < len(grouped_by_adm[adm_da_vez]):
+            # Pega a combinação (ignorando a diferença, que já foi usada para ordenar internamente)
+            combinacao_data, _ = grouped_by_adm[adm_da_vez][idx_na_adm]
+            
+            # Adiciona à lista de resultados final (com a administradora e a combinação)
+            final_resultados_diversificados.append((adm_da_vez, combinacao_data))
+            
+            # Incrementa o índice para a próxima vez que pegarmos dessa administradora
+            adm_indices[adm_da_vez] += 1
+        else:
+            # Se essa administradora não tem mais combinações, remove ela da lista de ativas
+            active_adms.pop(current_adm_idx)
+            # Ajusta o current_adm_idx se a lista diminuiu e estamos no limite
+            if current_adm_idx >= len(active_adms) and active_adms:
+                 current_adm_idx = 0 # Volta para o início da lista se removemos o último
+
+        # Move para a próxima administradora no ciclo (garantindo que não estouramos o índice da lista active_adms)
+        if active_adms: # Só avança se ainda houver administradoras ativas
+            current_adm_idx = (current_adm_idx + 1) % len(active_adms)
+        else:
+            break # Não há mais administradoras ativas, sai do loop
+            
+    # Agora, itera sobre os resultados diversificados para formatar a resposta
+    for idx, (adm, combinacao) in enumerate(final_resultados_diversificados, 1):
         codigos = [str(c.get('codigo', 'N/A')) for c in combinacao]
         total_credito = sum(c['valor_credito'] for c in combinacao)
         total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -279,39 +200,46 @@ def formatar_resultados_10_cotas(resultados):
         taxa_percentual = (taxa_total / credito_real) * 100 if credito_real > 0 else 0
         taxa_mensal = taxa_percentual / maior_prazo if maior_prazo > 0 else 0
 
+        #comissao = total_entrada * (8.5 / 108.5)
+
         resposta += f"""
 --- COMBINAÇÃO {idx} ---
-🏢 **Administradora:** {adm.upper()}
-🔢 **Códigos ({len(combinacao)} cotas):** {', '.join(codigos)}
-💰 **Crédito Total:** {formatar_moeda(total_credito)}
-💵 **Entrada (+comissão):** {formatar_moeda(total_entrada)}
-📉 **Saldo Devedor:** {formatar_moeda(total_saldo)}
-💲 **Parcela:** {formatar_moeda(total_parcelas)}
-⏳ **Prazo:** {maior_prazo} meses
-🔚 **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}%
-⭐ **Score de Qualidade:** {diferenca:.2f}
+�� Administradora: {adm}
+🔢 Códigos: {', '.join(codigos)}
+💰 Crédito Total: {formatar_moeda(total_credito)}
+�� Entrada (+comissão): {formatar_moeda(total_entrada)}
+📉 Saldo Devedor: {formatar_moeda(total_saldo)}
+💲 Parcela: {formatar_moeda(total_parcelas)}
+⏳ Prazo: {maior_prazo} meses
+🔚 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_mensal * 12:.2f}%
+📊 Nº de Cotas: {len(combinacao)}
 """
     return resposta
 
 # --- INICIALIZAÇÃO PARA GRADIO ---
+# Carrega a planilha UMA VEZ no início do aplicativo
+# Se der erro, a função de busca tentará carregar novamente.
 if not carregar_planilha():
     print("⚠️ Aviso: Planilha não carregada na inicialização. Tentará carregar na primeira busca.")
 
-def ajustar_e_buscar_10_cotas(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
+# Calcula a entrada adicionando 8,5% ao valor final da entrada.
+def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
     entrada_calculada = credito_desejado * 0.085 + entrada_desejada
-    return buscar_combinacoes_10_cotas(credito_desejado, entrada_calculada, parcela_desejada, administradoras)
+    return buscar_combinacoes(credito_desejado, entrada_calculada, parcela_desejada, administradoras)
 
+# Prepara as opções para o seletor de administradoras do Gradio
 def get_administradoras_options():
-    if df is not None and df_filtrado_auto is not None:
-        adm_list = df_filtrado_auto['administradora'].unique()
-        return sorted(adm_list.tolist())
+    if df is not None:
+        adm_list = df[df['tipo_do_bem'].str.lower() == 'auto']['administradora'].unique()
+        return sorted(adm_list.tolist()) # Converter para lista, pois .unique() pode retornar um numpy array
     return []
 
-# --- Interface Gradio para 10 cotas ---
-with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis (1-10 Cotas)") as demo:
+# --- Interface Gradio ---
+with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis") as demo:
     gr.HTML("""
     <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
     <style>
@@ -320,38 +248,32 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis (1-10 Cotas)
         }
         
         body {
-            background: linear-gradient(135deg, #ff8f00 0%, #ffa000 100%) !important;
+            background-color: #ff8f00 !important;
             color: black !important;
         }
         
-        .gr-box {
-            border-radius: 12px !important;
-            border: 2px solid #000 !important;
-        }
-        
+        /* Inputs Numéricos: Crédito, Entrada, Parcela */
         input[type="number"] {
             background-color: white !important;
             border: 2px solid #000 !important;
             border-radius: 12px !important;
             color: black !important;
-            padding: 12px !important;
+            padding: 10px !important;
             font-weight: 500;
         }
         
-        textarea {
+        /* Inputs de texto e áreas de texto (como a saída e código) */
+        input[type="text"], textarea {
             background-color: white !important;
             border: 2px solid black !important;
             border-radius: 12px !important;
             color: black !important;
-            padding: 12px !important;
-            font-size: 14px;
+            padding: 10px !important;
         }
         
-        .gr-checkbox-group {
-            background-color: white !important;
-            border: 2px solid black !important;
-            border-radius: 12px !important;
-            padding: 10px;
+        input::placeholder, textarea::placeholder {
+            color: #333 !important;
+            opacity: 0.7;
         }
         
         .gr-checkbox label {
@@ -359,93 +281,63 @@ with gr.Blocks(title="Sistema de Busca de Consórcio de Automóveis (1-10 Cotas)
             align-items: center;
             gap: 8px;
             font-weight: 600;
-            margin: 5px 0;
         }
         
         input[type="checkbox"] {
-            accent-color: #ff8f00 !important;
+            accent-color: black !important;
             width: 18px;
             height: 18px;
         }
         
         .gr-button {
             font-weight: bold;
-            border-radius: 12px !important;
-            background: linear-gradient(135deg, #000000 0%, #333333 100%) !important;
-            color: white !important;
-            border: none !important;
-            padding: 12px 24px !important;
-            font-size: 16px;
+            border-radius: 10px !important;
+            background-color: white !important;
+            color: black !important;
+            border: 2px solid black !important;
         }
         
         .gr-button:hover {
-            background: linear-gradient(135deg, #333333 0%, #555555 100%) !important;
-            transform: translateY(-2px);
-            box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+            background-color: #fff3e0 !important;
+            color: black !important;
         }
         
         label {
-            font-weight: 700 !important;
-            color: #000 !important;
-            margin-bottom: 8px !important;
-        }
-        
-        .gr-markdown h1 {
-            color: #000 !important;
-            text-align: center;
-            margin-bottom: 20px;
+            font-weight: 600 !important;
         }
     </style>
     """)
     
     gr.Markdown("# 🚗 Sistema de Busca de Combinações de Consórcio (Automóveis)")
-    gr.Markdown("### 🔥 **Versão 1-10 Cotas - Busca Inteligente**")
-    gr.Markdown("Preencha os campos abaixo para encontrar as melhores combinações de 1 a 10 cotas de consórcio de veículo.")
+    gr.Markdown("Preencha os campos abaixo para encontrar as melhores combinações de cotas de consórcio de veículo.")
 
     with gr.Row():
-        with gr.Column(scale=1):
-            credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000, interactive=True)
-            entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100, interactive=True)
-            parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10, interactive=True)
-            
-            gr.Markdown("### ⚙️ Configurações de Busca")
-            gr.Markdown("O sistema busca automaticamente as melhores combinações de 1 a 10 cotas")
-            
-            submit_btn = gr.Button("🔍 Buscar Combinações (1-10 Cotas)", variant="primary", size="lg")
-
-        with gr.Column(scale=1):
-            administradoras_options = get_administradoras_options()
-            administradoras_multiselect = gr.CheckboxGroup(
-                label="Filtrar por Administradoras",
-                choices=administradoras_options,
-                value=administradoras_options[:5] if len(administradoras_options) > 5 else administradoras_options,
-                interactive=True
-            )
-            
-            gr.Markdown("### 💡 Dicas para busca eficiente:")
-            gr.Markdown("- Selecione até 5 administradoras para busca mais rápida")
-            gr.Markdown("- Use valores aproximados para encontrar mais opções")
-            gr.Markdown("- O sistema mostra até 20 das melhores combinações")
-
-    output_text = gr.Textbox(
-        label="📋 Resultados da Busca (1-10 Cotas)", 
-        lines=25, 
-        max_lines=50, 
-        interactive=False, 
-        placeholder="Os resultados aparecerão aqui...",
-        show_copy_button=True
+        credito_input = gr.Number(label="Crédito Desejado (R$)", value=30000, step=1000, interactive=True)
+        entrada_input = gr.Number(label="Entrada Desejada (R$)", value=3000, step=100, interactive=True)
+        parcela_input = gr.Number(label="Parcela Desejada (R$)", value=500, step=10, interactive=True)
+
+    administradoras_options = get_administradoras_options()
+    administradoras_multiselect = gr.CheckboxGroup(
+        label="Filtrar por Administradoras",
+        choices=administradoras_options,
+        value=administradoras_options, # Seleciona todas por padrão
+        interactive=True
     )
 
-    # Conecta o botão à função de busca para 10 cotas
+    submit_btn = gr.Button("🔍 Buscar Combinações", variant="primary")
+
+    output_text = gr.Textbox(label="Resultados da Busca", lines=20, max_lines=40, interactive=False, placeholder="Os resultados aparecerão aqui...")
+
+    # Conecta o botão à função de busca
     submit_btn.click(
-        fn=ajustar_e_buscar_10_cotas,
+        fn=ajustar_e_buscar,
         inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect],
         outputs=output_text
     )
 
+
     gr.Markdown("---")
-    gr.Markdown("**🔥 Ferramenta avançada** para buscas de combinações de 1 a 10 cotas")
-    gr.Markdown("*Desenvolvido com algoritmos de busca inteligente e poda*")
+    gr.Markdown("Ferramenta desenvolvida para otimizar a busca por consórcios de automóveis.")
 
 if __name__ == "__main__":
-    demo.launch(share=False)
+    demo.launch() # Você não precisa disso no Colab, mas sim no arquivo que você fará o deploy