Update app.py

app.py

@@ -1,536 +1,131 @@
-# 🔥 LIMITES DE SEGURANÇA - PARA EVITAR TIMEOUT NO HUGGING FACE
+# app.py - BACKEND SIMPLIFICADO PARA TESTE
 import os
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 os.environ["GRADIO_QUEUE_ENABLED"] = "False"
 
-MAX_COMBINATIONS = 10000  # Limite absoluto de combinações testadas
-MAX_COTAS_POR_ADMIN = 100  # Limita cotas por administradora
-
-# IMPORTS
+import gradio as gr
 import pandas as pd
 import requests
 import io
-import itertools
 from collections import defaultdict
-import gradio as gr
-import time
-import math
-
-# 🔧 CONFIGURAÇÕES GLOBAIS
-FILE_ID = "1EoH8V3Fyls0mNa95VcBN6ZL1B552ty3X"
-URL = f"https://drive.google.com/uc?export=download&id={FILE_ID}"
-
-# Variáveis globais para armazenamento
-df = None
-df_auto = None
-grupos_auto = None
-planilha_carregada = False
-
-def carregar_planilha():
-    """Carrega e prepara a planilha para análise."""
-    global df, df_auto, grupos_auto, planilha_carregada
-    
-    # Se já carregou, não precisa carregar novamente
-    if planilha_carregada:
-        return True
-        
-    try:
-        print("⏳ Carregando planilha...")
-        response = requests.get(URL)
-        response.raise_for_status()
-        data = io.BytesIO(response.content)
-        df = pd.read_excel(data)
-
-        # Padroniza nomes das colunas
-        df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")
-
-        # Padroniza os nomes das administradoras
-        if 'administradora' in df.columns:
-            df['administradora'] = df['administradora'].astype(str).str.strip().str.lower()
-
-        # Converte colunas numéricas
-        colunas_numericas = ['valor_credito', 'valor_entrada', 'valor_parcela', 'saldo_devedor', 'qtd_parcelas']
-        for coluna in colunas_numericas:
-            if coluna in df.columns:
-                df[coluna] = pd.to_numeric(df[coluna], errors='coerce').fillna(0)
-
-        # Verifica colunas essenciais
-        if 'tipo_do_bem' not in df.columns or 'administradora' not in df.columns:
-            raise ValueError("Colunas essenciais não encontradas")
 
-        # Remove duplicatas
-        df.drop_duplicates(inplace=True)
-        
-        # Pré-filtra e pré-processa dados de auto
-        df_auto = df[df['tipo_do_bem'].str.lower() == 'auto'].copy()
-        grupos_auto = agrupar_por_administradora(df_auto)
-        
-        # 🔥 LIMITA COTAS POR ADMINISTRADORA PARA EVITAR TIMEOUT
-        for adm in list(grupos_auto.keys()):
-            grupos_auto[adm] = grupos_auto[adm][:MAX_COTAS_POR_ADMIN]
-
-        planilha_carregada = True
-        print("✅ Planilha carregada e pré-processada com sucesso")
-        print(f"✅ Total de cotas de auto: {len(df_auto)}")
-        print(f"✅ Administradoras disponíveis: {list(grupos_auto.keys())}")
-        return True
-
-    except Exception as e:
-        print(f"❌ Erro ao carregar planilha: {str(e)}")
-        return False
-
-def agrupar_por_administradora(dataframe):
-    """Agrupa cotas por administradora."""
+# DADOS DE TESTE PARA INÍCIO
+def criar_dados_teste():
+    """Cria dados de teste enquanto não carrega a planilha"""
+    dados = []
+    administradoras = ["bradesco", "santander", "itau", "caixa", "banco do brasil"]
+    
+    for i in range(50):
+        dados.append({
+            "administradora": administradoras[i % len(administradoras)],
+            "valor_credito": 20000 + (i * 5000),
+            "valor_entrada": 2000 + (i * 500),
+            "valor_parcela": 300 + (i * 50),
+            "qtd_parcelas": 60,
+            "saldo_devedor": 18000 + (i * 4500),
+            "codigo": f"TEST{i:03d}",
+            "tipo_do_bem": "auto"
+        })
+    
+    return pd.DataFrame(dados)
+
+# Variáveis globais
+df = criar_dados_teste()
+planilha_carregada = True
+
+def agrupar_por_administradora(df):
     grupos = defaultdict(list)
-    for _, row in dataframe.iterrows():
+    for _, row in df.iterrows():
         grupos[row['administradora']].append(row.to_dict())
     return grupos
 
-def calcular_tempo_parcelas(combinacao):
-    """Calcula o tempo de parcelas baseado nas cotas da combinação - VERSÃO CORRIGIDA."""
-    if not combinacao:
-        return ""
-    
-    try:
-        # Ordena as cotas pelo prazo (menor prazo primeiro)
-        cotas_ordenadas = sorted(combinacao, key=lambda x: int(x.get('qtd_parcelas', 0)))
-        
-        # Encontra todos os prazos únicos e ordena
-        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 i, prazo_atual in enumerate(prazos):
-            # Calcula a soma das parcelas das cotas que estão ativas neste intervalo
-            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
-        
-        # Adiciona faixa final se houver cotas com prazos além do último ponto de quebra
-        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 ao calcular tempo de parcelas: {str(e)}")
-        return ""
-
-def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=10):
-    """Busca combinações de cotas dentro dos parâmetros especificados de forma otimizada."""
-    global df_auto, grupos_auto
-    
-    # 🔥 LIMITE DE SEGURANÇA - EVITA TIMEOUT
-    if credito_desejado > 1000000:  # 1 milhão
-        return "⚠️ Valor muito alto. Use valores até R$ 1.000.000 para evitar timeout."
-    
-    # Garante que o DataFrame está carregado
-    if not planilha_carregada:
-        if not carregar_planilha():
-            return "❌ Erro: Planilha não carregada. Por favor, tente novamente."
-
-    # Filtra administradoras se especificado
-    if administradoras and len(administradoras) > 0:
-        administradoras = [a.strip().lower() for a in administradoras]
-        grupos_filtrados = {adm: cotas for adm, cotas in grupos_auto.items() if adm in administradoras}
-        print(f"🔍 Filtrando por administradoras: {administradoras}")
-    else:
-        grupos_filtrados = grupos_auto
-        print("🔍 Buscando em todas as administradoras")
-
-    if not grupos_filtrados:
-        return "🚫 Nenhuma cota encontrada com os filtros aplicados. Tente ajustar os parâmetros."
-
-    print(f"🔍 Total de administradoras no filtro: {len(grupos_filtrados)}")
-    
-    # TOLERÂNCIAS - Ajustadas para valores de auto (geralmente menores que imóveis)
-    if credito_desejado > 5000000:  # Para valores acima de 5 Milhões
-        tolerancia_credito = 0.50  # 10%
-        tolerancia_entrada = 0.50  # 10%
-        tolerancia_parcela = 1.00  # 50%
-        max_cotas_combinacao = 10   # Até 10 cotas por combinação (REDUZIDO)
-    elif credito_desejado > 100000:  # Para valores acima de 100 Mil
-        tolerancia_credito = 0.25  # 10%
-        tolerancia_entrada = 0.25  # 10%
-        tolerancia_parcela = 0.50  # 30%
-        max_cotas_combinacao = 8   # Até 8 cotas por combinação (REDUZIDO)
-    else:  # Para valores até 100k
-        tolerancia_credito = 0.15  # 5%
-        tolerancia_entrada = 0.15  # 5%
-        tolerancia_parcela = 0.30  # 25%
-        max_cotas_combinacao = 6   # Até 6 cotas por combinação (REDUZIDO)
-
-    # Define faixas de tolerância
-    credito_min = credito_desejado * (1 - tolerancia_credito)
-    credito_max = credito_desejado * (1 + tolerancia_credito)
-    entrada_min = entrada_desejada * (1 - tolerancia_entrada)
-    entrada_max = entrada_desejada * (1 + tolerancia_entrada)
-    parcela_min = parcela_desejada * (1 - tolerancia_parcela)
-    parcela_max = parcela_desejada * (1 + tolerancia_parcela)
-
-    print(f"💰 Valores desejados: Crédito: R$ {credito_desejado:,.2f}, Entrada: R$ {entrada_desejada:,.2f}, Parcela: R$ {parcela_desejada:,.2f}")
-    print(f"🔧 Tolerâncias: Crédito: ±{tolerancia_credito*100:.1f}%, Entrada: ±{tolerancia_entrada*100:.1f}%, Parcela: ±{tolerancia_parcela*100:.1f}%")
-    print(f"🔧 Máximo de cotas por combinação: {max_cotas_combinacao}")
-
-    resultados = []
-    total_combinacoes_testadas = 0
-    
-    # Para cada administradora, busca combinações
-    for adm, cotas in grupos_filtrados.items():
-        print(f"🔍 Analisando administradora: {adm} ({len(cotas)} cotas)")
-        
-        # Para valores altos, NÃO filtramos cotas individuais primeiro
-        cotas_para_combinar = cotas
-        
-        # Gera combinações
-        for r in range(1, min(max_cotas_combinacao + 1, len(cotas_para_combinar) + 1)):
-            # Limita o número de combinações testadas por administradora
-            if credito_desejado > 500000:
-                max_combinacoes_por_adm = 1000  # REDUZIDO
-            else:
-                max_combinacoes_por_adm = 500   # REDUZIDO
-                
-            combinacoes_geradas = 0
-            
-            for combinacao in itertools.combinations(cotas_para_combinar, r):
-                if combinacoes_geradas >= max_combinacoes_por_adm:
-                    break
-                    
-                total_combinacoes_testadas += 1
-                combinacoes_geradas += 1
-                
-                # 🔥 LIMITE GLOBAL DE COMBINAÇÕES TESTADAS
-                if total_combinacoes_testadas > MAX_COMBINATIONS:
-                    print(f"⚠️ Limite máximo de combinações atingido: {MAX_COMBINATIONS}")
-                    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)
-
-                # Verifica se a combinação está dentro das tolerâncias
-                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))
-                    
-                    # Para se já encontrou combinações suficientes
-                    if len(resultados) >= max_combinacoes * 3:
-                        break
-            
-            if total_combinacoes_testadas > MAX_COMBINATIONS:
-                break
-                
-            if len(resultados) >= max_combinacoes * 3:
-                break
-        
-        if total_combinacoes_testadas > MAX_COMBINATIONS:
-            break
-            
-        if len(resultados) >= max_combinacoes * 3:
-            break
-
-    print(f"🔍 Total de combinações testadas: {total_combinacoes_testadas}")
-    print(f"🔍 Combinações válidas encontradas: {len(resultados)}")
-
-    if not resultados:
-        # Tenta uma busca mais ampla se não encontrou resultados
-        print("🔍 Nenhuma combinação encontrada. Tentando busca ampla...")
-        return buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejada, administradoras, max_combinacoes)
-
-    # Ordena pela diferença e pega as melhores
-    resultados.sort(key=lambda x: x[2])
-    return formatar_resultados(resultados[:max_combinacoes])
-
-def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None, max_combinacoes=5):
-    """Busca combinações com tolerâncias mais amplas para valores altos."""
-    global grupos_auto
-    
-    # 🔥 LIMITE DE SEGURANÇA - EVITA TIMEOUT
-    if credito_desejado > 1000000:
-        return "⚠️ Busca ampla desativada para valores acima de R$ 1.000.000"
-    
-    # Filtra administradoras se especificado
-    if administradoras and len(administradoras) > 0:
-        administradoras = [a.strip().lower() for a in administradoras]
-        grupos_filtrados = {adm: cotas for adm, cotas in grupos_auto.items() if adm in administradoras}
-    else:
-        grupos_filtrados = grupos_auto
-
-    # Tolerâncias mais amplas para valores altos
-    if credito_desejado > 5000000:
-        tolerancia_credito = 0.50  # 15%
-        tolerancia_entrada = 0.50  # 15%
-        tolerancia_parcela = 1.00  # 75%
-        max_cotas_combinacao = 8   # REDUZIDO
-    elif credito_desejado > 100000:
-        tolerancia_credito = 0.25  # 10%
-        tolerancia_entrada = 0.25  # 10%
-        tolerancia_parcela = 0.50  # 50%
-        max_cotas_combinacao = 6   # REDUZIDO
-    else:
-        tolerancia_credito = 0.15  # 5%
-        tolerancia_entrada = 0.15  # 5%
-        tolerancia_parcela = 0.30  # 35%
-        max_cotas_combinacao = 4   # REDUZIDO
-
-    credito_min = credito_desejado * (1 - tolerancia_credito)
-    credito_max = credito_desejado * (1 + tolerancia_credito)
-    entrada_min = entrada_desejada * (1 - tolerancia_entrada)
-    entrada_max = entrada_desejada * (1 + tolerancia_entrada)
-    parcela_min = parcela_desejada * (1 - tolerancia_parcela)
-    parcela_max = parcela_desejada * (1 + tolerancia_parcela)
-
-    print(f"🔍 BUSCA AMPLA: Tolerâncias: Crédito: ±{tolerancia_credito*100:.1f}%, Entrada: ±{tolerancia_entrada*100:.1f}%, Parcela: ±{tolerancia_parcela*100:.1f}%")
-    print(f"🔍 BUSCA AMPLA: Máximo de cotas por combinação: {max_cotas_combinacao}")
+grupos_auto = agrupar_por_administradora(df[df['tipo_do_bem'] == 'auto'])
 
+def buscar_combinacoes_simples(credito_desejado, entrada_desejada, parcela_desejada, administradoras, max_combinacoes=5):
+    """Busca simplificada para teste"""
     resultados = []
-    total_combinacoes_testadas = 0
     
-    for adm, cotas in grupos_filtrados.items():
-        print(f"🔍 BUSCA AMPLA - Analisando administradora: {adm}")
-        
-        # Gera combinações
-        for r in range(1, min(max_cotas_combinacao + 1, len(cotas) + 1)):
-            combinacoes_geradas = 0
-            max_combinacoes_por_adm = 300  # REDUZIDO
-            
-            for combinacao in itertools.combinations(cotas, r):
-                if combinacoes_geradas >= max_combinacoes_por_adm:
-                    break
-                    
-                total_combinacoes_testadas += 1
-                combinacoes_geradas += 1
-                
-                # 🔥 LIMITE GLOBAL DE COMBINAÇÕES TESTADAS
-                if total_combinacoes_testadas > MAX_COMBINATIONS:
-                    print(f"⚠️ Limite máximo de combinações atingido: {MAX_COMBINATIONS}")
-                    break
+    for adm in administradoras:
+        if adm in grupos_auto:
+            for cota in grupos_auto[adm][:10]:  # Limita a 10 cotas por admin
+                credito = cota['valor_credito']
+                entrada = cota['valor_entrada']
+                parcela = cota['valor_parcela']
                 
-                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))
+                # Tolerâncias simples
+                if (0.8 * credito_desejado <= credito <= 1.2 * credito_desejado and
+                    0.8 * entrada_desejada <= entrada <= 1.2 * entrada_desejada and
+                    0.8 * parcela_desejada <= parcela <= 1.2 * parcela_desejada):
                     
-                    if len(resultados) >= max_combinacoes * 2:
-                        break
-            
-            if total_combinacoes_testadas > MAX_COMBINATIONS:
-                break
-                
-            if len(resultados) >= max_combinacoes * 2:
-                break
-        
-        if total_combinacoes_testadas > MAX_COMBINATIONS:
-            break
-            
-        if len(resultados) >= max_combinacoes * 2:
-            break
-
-    print(f"🔍 BUSCA AMPLA: Total de combinações testadas: {total_combinacoes_testadas}")
-    print(f"🔍 BUSCA AMPLA: Combinações válidas encontradas: {len(resultados)}")
-
-    if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
-
-    resultados.sort(key=lambda x: x[2])
-    return formatar_resultados(resultados[:max_combinacoes])
-
-def formatar_moeda(valor):
-    return f"R$ {valor:,.2f}".replace(",", "v").replace(".", ",").replace("v", ".")
+                    resultados.append({
+                        "administradora": adm,
+                        "credito": credito,
+                        "entrada": entrada,
+                        "parcela": parcela,
+                        "prazo": cota['qtd_parcelas'],
+                        "saldo_devedor": cota['saldo_devedor'],
+                        "codigo": cota['codigo']
+                    })
+    
+    # Limita resultados
+    return resultados[:max_combinacoes]
 
 def formatar_resultados(resultados):
-    """Formata os resultados para exibição INCLUINDO TEMPO DE PARCELAS CORRETO."""
     if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+        return "Nenhuma combinação encontrada com os critérios informados."
     
     resposta = ""
-    for idx, (adm, combinacao, _) in enumerate(resultados, 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)
-        total_entrada = total_entrada_base + (total_credito * 0.085)
-        total_saldo = sum(c['saldo_devedor'] for c in combinacao)
-        total_parcelas = sum(c['valor_parcela'] for c in combinacao)
-        maior_prazo = max(int(c.get('qtd_parcelas', 0)) for c in combinacao)
-
-        valor_final = round(total_entrada + total_saldo, 2)
-        credito_real = round(total_credito - total_entrada, 2)
-        taxa_total = total_saldo - credito_real
-        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
-        
-        # CHAMADA CORRIGIDA para calcular tempo de parcelas
-        tempo_parcelas = calcular_tempo_parcelas(combinacao)
-
+    for i, r in enumerate(resultados, 1):
         resposta += f"""
---- COMBINAÇÃO {idx} ---
-🏢 Administradora: {adm}
-🔢 Códigos: {', '.join(codigos)} ({len(combinacao)} cotas)
-💰 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}%
-
-⏰ TEMPO DE PARCELAS:
-{tempo_parcelas if tempo_parcelas else "Não foi possível calcular o tempo de parcelas"}
+--- COMBINAÇÃO {i} ---
+🏢 Administradora: {r['administradora']}
+🔢 Código: {r['codigo']}
+💰 Crédito Total: R$ {r['credito']:,.2f}
+💵 Entrada: R$ {r['entrada']:,.2f}
+💲 Parcela: R$ {r['parcela']:,.2f}
+⏳ Prazo: {r['prazo']} meses
+📉 Saldo Devedor: R$ {r['saldo_devedor']:,.2f}
 
 """
     return resposta
 
-# Carrega a planilha uma vez quando o aplicativo inicia
-carregar_planilha()
-
 def ajustar_e_buscar(credito_desejado, entrada_desejada, parcela_desejada, administradoras):
-    return buscar_combinacoes_otimizado(
-        credito_desejado, entrada_desejada, parcela_desejada, administradoras, max_combinacoes=10
-    )
-
-# Prepara a lista de administradoras para o Gradio
-def get_administradoras_options():
-    if df is not None and planilha_carregada:
-        adm_list = df[df['tipo_do_bem'].str.lower() == 'auto']['administradora'].unique()
-        return sorted(adm_list)
-    return []
-
-# Criando a interface Gradio
-with gr.Blocks(title="Sistema de Busca de Consórcio Auto") as demo:
-    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;
-        }
-    
-        /* 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: 10px !important;
-            font-weight: 500;
-        }
-    
-        /* 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: 10px !important;
-        }
+    print(f"Recebido: Crédito={credito_desejado}, Entrada={entrada_desejada}, Parcela={parcela_desejada}, Admin={administradoras}")
     
-        input::placeholder, textarea::placeholder {
-            color: #333 !important;
-            opacity: 0.7;
-        }
-    
-        .gr-checkbox label {
-            display: flex;
-            align-items: center;
-            gap: 8px;
-            font-weight: 600;
-        }
-    
-        input[type="checkbox"] {
-            accent-color: black !important;
-            width: 18px;
-            height: 18px;
-        }
-    
-        .gr-button {
-            font-weight: bold;
-            border-radius: 10px !important;
-            background-color: white !important;
-            color: black !important;
-            border: 2px solid black !important;
-        }
+    if not planilha_carregada:
+        return "Erro: Dados não carregados"
     
-        .gr-button:hover {
-            background-color: #fff3e0 !important;
-            color: black !important;
-        }
+    resultados = buscar_combinacoes_simples(
+        credito_desejado, entrada_desejada, parcela_desejada, 
+        [a.lower() for a in administradoras], max_combinacoes=5
+    )
     
-        label {
-            font-weight: 600 !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.")
+    return formatar_resultados(resultados)
 
+# Interface
+with gr.Blocks(title="Consórcio Auto - TESTE") as demo:
+    gr.Markdown("# 🚗 Busca de Combinações (MODO TESTE)")
+    
     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)
-
-    administradoras_multiselect = gr.CheckboxGroup(
-        label="Filtrar por Administradoras",
-        choices=get_administradoras_options(),
-        value=get_administradoras_options() # Seleciona todas por padrão
+        credito = gr.Number(label="Crédito Desejado (R$)", value=30000)
+        entrada = gr.Number(label="Entrada Desejada (R$)", value=3000)
+        parcela = gr.Number(label="Parcela Desejada (R$)", value=500)
+    
+    administradoras = gr.CheckboxGroup(
+        label="Administradoras",
+        choices=["bradesco", "santander", "itau", "caixa", "banco do brasil"],
+        value=["bradesco"]
     )
-
-    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...")
-
-    submit_btn.click(
-        fn=ajustar_e_buscar,
-        inputs=[credito_input, entrada_input, parcela_input, administradoras_multiselect],
-        outputs=output_text
+    
+    buscar_btn = gr.Button("Buscar")
+    resultado = gr.Textbox(label="Resultados", lines=20)
+    
+    buscar_btn.click(
+        ajustar_e_buscar,
+        inputs=[credito, entrada, parcela, administradoras],
+        outputs=resultado,
+        api_name="ajustar_e_buscar"
     )
 
-    gr.Markdown("---")
-    gr.Markdown("Desenvolvido para auxiliar na busca por cotas de consórcio ideais.")
-
-# Inicia o aplicativo Gradio
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-#
+    demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)