Update app.py

app.py

@@ -92,18 +92,43 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
 
     print(f"🔍 Total de administradoras no filtro: {len(grupos_filtrados)}")
     
-    # TOLERÂNCIAS - Ajustadas para valores altos
-    # Para valores muito altos, aumentamos as tolerâncias
-    if credito_desejado > 5000000:  # Para valores acima de 5 milhões
-        tolerancia_credito = 0.15  # 15%
-        tolerancia_entrada = 0.15  # 15%
-        tolerancia_parcela = 0.40  # 40%
-        max_cotas_combinacao = 6  # Até 6 cotas por combinação
+    # ANÁLISE DAS COTAS DISPONÍVEIS - CRÍTICO PARA VALORES ALTOS
+    todas_cotas = []
+    for adm, cotas in grupos_filtrados.items():
+        todas_cotas.extend(cotas)
+        print(f"📊 {adm}: {len(cotas)} cotas")
+    
+    if not todas_cotas:
+        return "🚫 Nenhuma cota disponível para análise."
+    
+    # Calcula estatísticas das cotas
+    creditos = [c['valor_credito'] for c in todas_cotas]
+    max_credito = max(creditos)
+    avg_credito = sum(creditos) / len(creditos)
+    
+    print(f"📊 Estatísticas das cotas disponíveis:")
+    print(f"📊 Maior crédito individual: R$ {max_credito:,.2f}")
+    print(f"📊 Crédito médio: R$ {avg_credito:,.2f}")
+    print(f"📊 Total de cotas: {len(todas_cotas)}")
+    
+    # TOLERÂNCIAS INTELIGENTES BASEADAS NAS ESTATÍSTICAS
+    # Para valores muito altos, aumentamos significativamente as tolerâncias
+    if credito_desejado > 1000000:  # Acima de 1 milhão
+        # Quanto maior o valor, maior a tolerância necessária
+        fator_ajuste = min(1.0, credito_desejado / 5000000)  # Normaliza entre 0 e 1
+        
+        tolerancia_credito = 0.20 + (0.30 * fator_ajuste)  # 20% a 50%
+        tolerancia_entrada = 0.20 + (0.25 * fator_ajuste)  # 20% a 45%
+        tolerancia_parcela = 0.40 + (0.40 * fator_ajuste)  # 40% a 80%
+        
+        # Ajusta número máximo de cotas baseado na necessidade
+        cotas_estimadas = max(3, min(10, math.ceil(credito_desejado / avg_credito)))
+        max_cotas_combinacao = min(12, cotas_estimadas + 3)
     else:
-        tolerancia_credito = 0.10  # 10%
-        tolerancia_entrada = 0.10  # 10%
-        tolerancia_parcela = 0.30  # 30%
-        max_cotas_combinacao = 4  # Até 4 cotas por combinação
+        tolerancia_credito = 0.10
+        tolerancia_entrada = 0.10
+        tolerancia_parcela = 0.30
+        max_cotas_combinacao = 4
 
     # Define faixas de tolerância
     credito_min = credito_desejado * (1 - tolerancia_credito)
@@ -120,29 +145,32 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
     print(f"🔧 Faixas aceitáveis: Parcela: R$ {parcela_min:,.2f} - R$ {parcela_max:,.2f}")
     print(f"🔧 Máximo de cotas por combinação: {max_cotas_combinacao}")
 
+    # ESTRATÉGIA DE BUSCA OTIMIZADA PARA VALORES ALTOS
     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
-        # Isso permite que cotas menores sejam combinadas para atingir valores altos
-        cotas_para_combinar = cotas
+    # 1. PRIMEIRO: busca combinações progressivas por número de cotas
+    for num_cotas in range(1, max_cotas_combinacao + 1):
+        if len(resultados) >= max_combinacoes:
+            break
+            
+        print(f"🔍 Buscando combinações com {num_cotas} cota(s)...")
         
-        # 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
-            max_combinacoes_por_adm = 200 if credito_desejado > 5000000 else 100
-            combinacoes_geradas = 0
+        for adm, cotas in grupos_filtrados.items():
+            if len(resultados) >= max_combinacoes:
+                break
+                
+            # Para valores altos, prioriza cotas maiores primeiro
+            cotas_ordenadas = sorted(cotas, key=lambda x: x['valor_credito'], reverse=True)
+            
+            # Limita o número de testes por administradora
+            max_testes = 150
+            testes_realizados = 0
             
-            for combinacao in itertools.combinations(cotas_para_combinar, r):
-                if combinacoes_geradas >= max_combinacoes_por_adm:
+            for combinacao in itertools.combinations(cotas_ordenadas, num_cotas):
+                if testes_realizados >= max_testes:
                     break
                     
-                total_combinacoes_testadas += 1
-                combinacoes_geradas += 1
+                testes_realizados += 1
                 
                 total_credito = sum(c['valor_credito'] for c in combinacao)
                 total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -160,30 +188,28 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
 
                     resultados.append((adm, combinacao, diferenca))
                     
-                    # Para se já encontrou combinações suficientes
-                    if len(resultados) >= max_combinacoes * 3:
+                    if len(resultados) >= max_combinacoes * 2:
                         break
             
-            if len(resultados) >= max_combinacoes * 3:
+            if len(resultados) >= max_combinacoes * 2:
                 break
         
-        if len(resultados) >= max_combinacoes * 3:
+        if len(resultados) >= max_combinacoes * 2:
             break
 
-    print(f"🔍 Total de combinações testadas: {total_combinacoes_testadas}")
     print(f"🔍 Combinações válidas encontradas: {len(resultados)}")
 
+    # 2. SE NÃO ENCONTROU, TENTA BUSCA COM TOLERÂNCIAS MAIS AMPLAS
     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
+    # 3. ORDENA E RETORNA OS MELHORES RESULTADOS
     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=10):
-    """Busca combinações com tolerâncias mais amplas para valores altos."""
+    """Busca combinações com tolerâncias extremamente amplas para valores altos."""
     global grupos_imovel
     
     # Filtra administradoras se especificado
@@ -192,17 +218,18 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
     else:
         grupos_filtrados = grupos_imovel
 
-    # Tolerâncias mais amplas para valores altos
-    if credito_desejado > 5000000:
-        tolerancia_credito = 0.25  # 25%
-        tolerancia_entrada = 0.25  # 25%
-        tolerancia_parcela = 0.60  # 60%
-        max_cotas_combinacao = 8  # Até 8 cotas por combinação
+    # TOLERÂNCIAS MUITO AMPLAS ESPECIALMENTE PARA VALORES ALTOS
+    if credito_desejado > 1000000:
+        # Tolerâncias extremas para valores muito altos
+        tolerancia_credito = 0.50  # 50%
+        tolerancia_entrada = 0.50  # 50%
+        tolerancia_parcela = 1.00  # 100%
+        max_cotas_combinacao = 15  # Até 15 cotas por combinação
     else:
-        tolerancia_credito = 0.20  # 20%
-        tolerancia_entrada = 0.20  # 20%
-        tolerancia_parcela = 0.50  # 50%
-        max_cotas_combinacao = 6  # Até 6 cotas por combinação
+        tolerancia_credito = 0.30
+        tolerancia_entrada = 0.30
+        tolerancia_parcela = 0.70
+        max_cotas_combinacao = 8
 
     credito_min = credito_desejado * (1 - tolerancia_credito)
     credito_max = credito_desejado * (1 + tolerancia_credito)
@@ -215,22 +242,27 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
     print(f"🔍 BUSCA AMPLA: Máximo de cotas por combinação: {max_cotas_combinacao}")
 
     resultados = []
-    total_combinacoes_testadas = 0
     
-    for adm, cotas in grupos_filtrados.items():
-        print(f"🔍 BUSCA AMPLA - Analisando administradora: {adm}")
+    # Estratégia de busca mais agressiva
+    for num_cotas in range(2, max_cotas_combinacao + 1):  # Começa com 2 cotas
+        if len(resultados) >= max_combinacoes:
+            break
+            
+        print(f"🔍 BUSCA AMPLA - Procurando com {num_cotas} cotas...")
         
-        # Gera combinações
-        for r in range(1, min(max_cotas_combinacao + 1, len(cotas) + 1)):
-            combinacoes_geradas = 0
-            max_combinacoes_por_adm = 300
+        for adm, cotas in grupos_filtrados.items():
+            if len(resultados) >= max_combinacoes:
+                break
+                
+            # Testa combinações de forma mais ampla
+            max_testes = 100
+            testes_realizados = 0
             
-            for combinacao in itertools.combinations(cotas, r):
-                if combinacoes_geradas >= max_combinacoes_por_adm:
+            for combinacao in itertools.combinations(cotas, num_cotas):
+                if testes_realizados >= max_testes:
                     break
                     
-                total_combinacoes_testadas += 1
-                combinacoes_geradas += 1
+                testes_realizados += 1
                 
                 total_credito = sum(c['valor_credito'] for c in combinacao)
                 total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -247,34 +279,52 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
 
                     resultados.append((adm, combinacao, diferenca))
                     
-                    if len(resultados) >= max_combinacoes * 2:
+                    if len(resultados) >= max_combinacoes:
                         break
-            
-            if len(resultados) >= max_combinacoes * 2:
-                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."
+        # Última tentativa: busca a combinação mais próxima possível
+        return gerar_sugestao_mais_proxima(credito_desejado, entrada_desejada, parcela_desejada, grupos_filtrados)
 
     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", ".")
-
-def formatar_resultados(resultados):
-    """Formata os resultados para exibição."""
-    if not resultados:
-        return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+def gerar_sugestao_mais_proxima(credito_desejado, entrada_desejada, parcela_desejada, grupos_filtrados):
+    """Gera sugestão da combinação mais próxima quando não encontra resultados exatos."""
+    todas_cotas = []
+    for cotas in grupos_filtrados.values():
+        todas_cotas.extend(cotas)
+    
+    if not todas_cotas:
+        return "🚫 Nenhuma cota disponível para análise."
+    
+    melhor_combinacao = None
+    menor_diferenca = float('inf')
     
-    resposta = ""
-    for idx, (adm, combinacao, _) in enumerate(resultados, 1):
+    # Testa combinações de 2 a 10 cotas
+    for num_cotas in range(2, 11):
+        for adm, cotas in grupos_filtrados.items():
+            for combinacao in itertools.combinations(cotas, num_cotas):
+                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)
+                
+                # Calcula diferenças percentuais
+                diff_credito = abs(total_credito - credito_desejado) / credito_desejado
+                diff_entrada = abs(total_entrada - entrada_desejada) / entrada_desejada
+                diff_parcela = abs(total_parcelas - parcela_desejada) / parcela_desejada if parcela_desejada > 0 else 0
+                
+                diferenca_total = diff_credito + diff_entrada + diff_parcela
+                
+                if diferenca_total < menor_diferenca:
+                    menor_diferenca = diferenca_total
+                    melhor_combinacao = (adm, combinacao, diferenca_total)
+    
+    if melhor_combinacao:
+        adm, combinacao, _ = melhor_combinacao
         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)
@@ -289,22 +339,24 @@ def formatar_resultados(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
 
-        resposta += f"""
---- COMBINAÇÃO {idx} ---
+        return f"""
+⚠️ Nenhuma combinação exata encontrada, mas aqui está a mais próxima:
+
 🏢 Administradora: {adm}
 🔢 Códigos: {', '.join(codigos)} ({len(combinacao)} cotas)
-💰 Crédito Total: {formatar_moeda(total_credito)}
-💵 Entrada (+comissão): {formatar_moeda(total_entrada)}
+💰 Crédito Total: {formatar_moeda(total_credito)} (Desejado: {formatar_moeda(credito_desejado)})
+💵 Entrada: {formatar_moeda(total_entrada)} (Desejado: {formatar_moeda(entrada_desejada)})
+💲 Parcela: {formatar_moeda(total_parcelas)} (Desejado: {formatar_moeda(parcela_desejada)})
 📉 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}%
+
+💡 Sugestão: Ajuste seus parâmetros ou considere múltiplas administradoras.
 """
-    return resposta
+    
+    return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
 
 # Carrega a planilha uma vez quando o aplicativo inicia
 carregar_planilha()