Update app.py

app.py

@@ -63,67 +63,95 @@ def formatar_moeda(valor):
     except:
         return f"R$ {valor}"
 
-def buscar_combinacoes_rapido(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
-    """Busca combinações de forma rápida e eficiente."""
+def buscar_combinacoes_eficiente(credito_desejado, entrada_desejada, parcela_desejada, administradoras=None):
+    """Busca combinações de forma eficiente e garantida."""
     try:
+        print("🔍 Iniciando busca de combinações...")
+        
         if df is None:
+            print("⚠️ DataFrame não carregado, tentando carregar...")
             if not carregar_planilha():
                 return "❌ Erro: Planilha não carregada."
 
+        # Debug: verifica se o DataFrame foi carregado
+        print(f"✅ DataFrame carregado com {len(df)} linhas")
+        print(f"📋 Colunas disponíveis: {list(df.columns)}")
+        
         # Filtra por tipo de bem
+        if 'tipo_do_bem' not in df.columns:
+            return "❌ Coluna 'tipo_do_bem' não encontrada na planilha."
+            
         df_filtrado = df[df['tipo_do_bem'].str.lower() == 'imovel']
+        print(f"📊 Imóveis filtrados: {len(df_filtrado)} linhas")
         
         if administradoras:
             if isinstance(administradoras, tuple):
                 administradoras = list(administradoras)
+            print(f"🎯 Administradoras selecionadas: {administradoras}")
             df_filtrado = df_filtrado[df_filtrado['administradora'].isin(administradoras)]
+            print(f"📊 Após filtrar administradoras: {len(df_filtrado)} linhas")
 
         if df_filtrado.empty:
             return "🚫 Nenhuma cota encontrada com os filtros aplicados."
 
-        # Tolerâncias amplas
-        credito_min, credito_max = credito_desejado * 0.85, credito_desejado * 1.15
-        entrada_min, entrada_max = entrada_desejada * 0.80, entrada_desejada * 1.20
-        parcela_min, parcela_max = parcela_desejada * 0.60, parcela_desejada * 1.40
+        # Debug: mostra algumas administradoras disponíveis
+        adm_disponiveis = df_filtrado['administradora'].unique()[:5]
+        print(f"🏢 Primeiras administradoras disponíveis: {adm_disponiveis}")
+
+        # Tolerâncias amplas para garantir resultados
+        credito_min, credito_max = credito_desejado * 0.80, credito_desejado * 1.20
+        entrada_min, entrada_max = entrada_desejada * 0.75, entrada_desejada * 1.25
+        parcela_min, parcela_max = parcela_desejada * 0.50, parcela_desejada * 1.50
 
         grupos = agrupar_por_administradora(df_filtrado)
-        resultados = []
+        print(f"📦 Grupos formados: {len(grupos)} administradoras")
         
+        resultados = []
         MIN_COTAS = 3
         MAX_COTAS = 10
 
         for adm, cotas in grupos.items():
+            print(f"🔍 Processando {adm} com {len(cotas)} cotas")
+            
             if len(cotas) < MIN_COTAS:
                 continue
                 
-            # Amostra aleatória para performance
-            if len(cotas) > 20:
-                cotas = random.sample(cotas, 20)
-                
-            # Busca combinações de 3 a 10 cotas
-            for r in range(MIN_COTAS, min(MAX_COTAS + 1, len(cotas) + 1)):
-                for combinacao in itertools.combinations(cotas, r):
-                    try:
-                        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))
+            # Ordena por valor de crédito (otimização)
+            cotas_ordenadas = sorted(cotas, key=lambda x: x.get('valor_credito', 0))
+            
+            # Busca combinações de forma inteligente
+            for tamanho in range(MIN_COTAS, min(MAX_COTAS + 1, len(cotas_ordenadas) + 1)):
+                # Amostra para evitar explosão combinatória
+                for i in range(0, len(cotas_ordenadas), max(1, len(cotas_ordenadas) // 5)):
+                    for j in range(i + tamanho, min(i + 20, len(cotas_ordenadas))):
+                        combinacao = cotas_ordenadas[i:j]
+                        if len(combinacao) != tamanho:
+                            continue
                             
-                            if len(resultados) >= 50:  # Limite seguro
-                                break
-                    except KeyError as e:
-                        print(f"⚠️ Coluna não encontrada: {e}")
-                        continue
+                        try:
+                            total_credito = sum(c.get('valor_credito', 0) for c in combinacao)
+                            total_entrada_base = sum(c.get('valor_entrada', 0) for c in combinacao)
+                            total_entrada = total_entrada_base + (total_credito * 0.085)
+                            total_parcelas = sum(c.get('valor_parcela', 0) 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.get('saldo_devedor', 0) for c in combinacao)
+                                valor_final = round(total_entrada + total_saldo, 2)
+                                diferenca = abs(valor_final - total_credito)
+                                
+                                resultados.append((adm, combinacao, diferenca))
+                                
+                                if len(resultados) >= 50:
+                                    break
+                        except Exception as e:
+                            print(f"⚠️ Erro em combinação: {e}")
+                            continue
+                    
+                    if len(resultados) >= 50:
+                        break
                         
                 if len(resultados) >= 50:
                     break
@@ -131,14 +159,18 @@ def buscar_combinacoes_rapido(credito_desejado, entrada_desejada, parcela_deseja
             if len(resultados) >= 50:
                 break
 
+        print(f"✅ Busca concluída: {len(resultados)} combinações encontradas")
+        
         if not resultados:
-            return "🚫 Nenhuma combinação adequada encontrada. Tente ajustar os valores."
+            return "🚫 Nenhuma combinação adequada encontrada. Tente ampliar os filtros."
 
         resultados.sort(key=lambda x: x[2])
         return formatar_resultados(resultados[:15])
         
     except Exception as e:
-        return f"❌ Erro inesperado: {str(e)}"
+        error_msg = f"❌ Erro inesperado: {str(e)}"
+        print(error_msg)
+        return error_msg
 
 def formatar_resultados(resultados):
     """Formata os resultados para exibição com diversificação por administradora."""