Update app.py

app.py

@@ -92,43 +92,18 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
 
     print(f"🔍 Total de administradoras no filtro: {len(grupos_filtrados)}")
     
-    # 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)
+    # 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
     else:
-        tolerancia_credito = 0.10
-        tolerancia_entrada = 0.10
-        tolerancia_parcela = 0.30
-        max_cotas_combinacao = 4
+        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
 
     # Define faixas de tolerância
     credito_min = credito_desejado * (1 - tolerancia_credito)
@@ -145,32 +120,29 @@ 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
     
-    # 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)...")
+    # Para cada administradora, busca combinações
+    for adm, cotas in grupos_filtrados.items():
+        print(f"🔍 Analisando administradora: {adm} ({len(cotas)} cotas)")
         
-        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
+        # Para valores altos, NÃO filtramos cotas individuais primeiro
+        # Isso permite que cotas menores sejam combinadas para atingir valores altos
+        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
+            max_combinacoes_por_adm = 200 if credito_desejado > 5000000 else 100
+            combinacoes_geradas = 0
             
-            for combinacao in itertools.combinations(cotas_ordenadas, num_cotas):
-                if testes_realizados >= max_testes:
+            for combinacao in itertools.combinations(cotas_para_combinar, r):
+                if combinacoes_geradas >= max_combinacoes_por_adm:
                     break
                     
-                testes_realizados += 1
+                total_combinacoes_testadas += 1
+                combinacoes_geradas += 1
                 
                 total_credito = sum(c['valor_credito'] for c in combinacao)
                 total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -188,28 +160,30 @@ def buscar_combinacoes_otimizado(credito_desejado, entrada_desejada, parcela_des
 
                     resultados.append((adm, combinacao, diferenca))
                     
-                    if len(resultados) >= max_combinacoes * 2:
+                    # Para se já encontrou combinações suficientes
+                    if len(resultados) >= max_combinacoes * 3:
                         break
             
-            if len(resultados) >= max_combinacoes * 2:
+            if len(resultados) >= max_combinacoes * 3:
                 break
         
-        if len(resultados) >= max_combinacoes * 2:
+        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)}")
 
-    # 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)
 
-    # 3. ORDENA E RETORNA OS MELHORES RESULTADOS
+    # 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=10):
-    """Busca combinações com tolerâncias extremamente amplas para valores altos."""
+    """Busca combinações com tolerâncias mais amplas para valores altos."""
     global grupos_imovel
     
     # Filtra administradoras se especificado
@@ -218,18 +192,17 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
     else:
         grupos_filtrados = grupos_imovel
 
-    # 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
+    # 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
     else:
-        tolerancia_credito = 0.30
-        tolerancia_entrada = 0.30
-        tolerancia_parcela = 0.70
-        max_cotas_combinacao = 8
+        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
 
     credito_min = credito_desejado * (1 - tolerancia_credito)
     credito_max = credito_desejado * (1 + tolerancia_credito)
@@ -242,27 +215,22 @@ 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
     
-    # 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...")
+    for adm, cotas in grupos_filtrados.items():
+        print(f"🔍 BUSCA AMPLA - Analisando administradora: {adm}")
         
-        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
+        # 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 combinacao in itertools.combinations(cotas, num_cotas):
-                if testes_realizados >= max_testes:
+            for combinacao in itertools.combinations(cotas, r):
+                if combinacoes_geradas >= max_combinacoes_por_adm:
                     break
                     
-                testes_realizados += 1
+                total_combinacoes_testadas += 1
+                combinacoes_geradas += 1
                 
                 total_credito = sum(c['valor_credito'] for c in combinacao)
                 total_entrada_base = sum(c['valor_entrada'] for c in combinacao)
@@ -279,52 +247,34 @@ def buscar_combinacoes_amplo(credito_desejado, entrada_desejada, parcela_desejad
 
                     resultados.append((adm, combinacao, diferenca))
                     
-                    if len(resultados) >= max_combinacoes:
+                    if len(resultados) >= max_combinacoes * 2:
                         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:
-        # Última tentativa: busca a combinação mais próxima possível
-        return gerar_sugestao_mais_proxima(credito_desejado, entrada_desejada, parcela_desejada, grupos_filtrados)
+        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 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')
-    
-    # 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)
+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."
     
-    if melhor_combinacao:
-        adm, combinacao, _ = melhor_combinacao
+    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)
@@ -339,24 +289,22 @@ def gerar_sugestao_mais_proxima(credito_desejado, entrada_desejada, parcela_dese
         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
 
-        return f"""
-⚠️ Nenhuma combinação exata encontrada, mas aqui está a mais próxima:
-
+        resposta += f"""
+--- COMBINAÇÃO {idx} ---
 🏢 Administradora: {adm}
 🔢 Códigos: {', '.join(codigos)} ({len(combinacao)} cotas)
-💰 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)})
+💰 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)})
-
-💡 Sugestão: Ajuste seus parâmetros ou considere múltiplas administradoras.
+🗓️ Taxa Mensal: {taxa_mensal:.2f}%
+🗓️ Taxa Anual: {taxa_mensal * 12:.2f}%
 """
-    
-    return "🚫 Nenhuma combinação adequada encontrada com os parâmetros fornecidos."
+    return resposta
 
 # Carrega a planilha uma vez quando o aplicativo inicia
 carregar_planilha()