from src.lib.json_logic import jsonLogic

# Dados
dados = {
    "usuario": {"nome": "João", "idade": 25},
    "produto": {"preco": 100}
}

# Regra
regra = {
    "and": [
        {">": [{"var": "usuario.idade"}, 18]},
        {"<": [{"var": "produto.preco"}, 200]}
    ]
}

# Execução
resultado = jsonLogic(regra, dados)
print(resultado)  # True

import asyncio
from src.lib.json_logic import jsonLogicAsync

# Função assíncrona personalizada
async def consultar_score_credito(cpf):
    # Simula consulta a API externa
    await asyncio.sleep(0.2)
    return 750

# Função síncrona
def calcular_limite(score):
    return score * 10

# Registro de funções
funcoes = {
    "get_score": consultar_score_credito,
    "calc_limite": calcular_limite,
}

# Dados
dados = {"cpf": "12345678901", "valor_solicitado": 5000}

# Regra que combina sync e async
regra = {
    ">=": [
        {"apply": [
            "calc_limite",
            {"apply": ["get_score", {"var": "cpf"}]}
        ]},
        {"var": "valor_solicitado"}
    ]
}

# Execução assíncrona
async def main():
    resultado = await jsonLogicAsync(regra, dados, funcoes)
    print(f"Crédito aprovado: {resultado}")

asyncio.run(main())

from src.lib.json_logic import jsonLogicAuto

# Detecta automaticamente se deve usar sync ou async
resultado = jsonLogicAuto(regra, dados, funcoes)

if asyncio.iscoroutine(resultado):
    # Tem funções async - execute com await
    final_result = await resultado
else:
    # Apenas funções sync - resultado direto
    final_result = resultado

import asyncio
from src.lib.json_logic import jsonLogic_async

# Funções de negócio assíncronas
async def consultar_serasa(cpf):
    await asyncio.sleep(0.3)  # Simula latência
    return {"score": 720, "restricoes": False}

async def verificar_renda(user_id):
    await asyncio.sleep(0.2)
    return {"valor": 5000, "comprovada": True}

# Função síncrona
def calcular_limite_credito(renda, score):
    if score > 700:
        return renda * 3
    elif score > 600:
        return renda * 2
    return renda * 0.5

# Registro de funções
funcoes = {
    "get_serasa": consultar_serasa,
    "get_renda": verificar_renda,
    "calc_limite": calcular_limite_credito,
}

# Dados da solicitação
dados = {
    "cpf": "12345678901",
    "user_id": 123,
    "valor_solicitado": 10000
}

# Regra complexa de aprovação
regra_aprovacao = {
    "and": [
        # Score > 600 e sem restrições
        {">": [
            {"apply_async": ["get_serasa", {"var": "cpf"}]},
            {"score": 600}
        ]},
        {"==": [
            {"apply_async": ["get_serasa", {"var": "cpf"}]},
            {"restricoes": False}
        ]},
        # Renda comprovada
        {"==": [
            {"apply_async": ["get_renda", {"var": "user_id"}]},
            {"comprovada": True}
        ]},
        # Valor <= limite calculado
        {"<=": [
            {"var": "valor_solicitado"},
            {"apply": [
                "calc_limite",
                {"apply_async": ["get_renda", {"var": "user_id"}]},
                {"apply_async": ["get_serasa", {"var": "cpf"}]}
            ]}
        ]}
    ]
}

async def processar_credito():
    inicio = time.time()
    aprovado = await jsonLogic_async(regra_aprovacao, dados, funcoes)
    fim = time.time()
    
    print(f"Crédito {'APROVADO' if aprovado else 'NEGADO'}")
    print(f"Processamento: {fim - inicio:.2f}s")

asyncio.run(processar_credito())

# ✅ Use SYNC para operações CPU-bound
regra_matematica = {"+": [{"var": "a"}, {"var": "b"}]}
resultado = jsonLogic(regra_matematica, dados)

# ✅ Use ASYNC para operações I/O-bound
regra_com_api = {"apply": ["consultar_api", {"var": "id"}]}
resultado = await jsonLogicAsync(regra_com_api, dados, funcoes_async)

# ✅ Use AUTO para detecção automática
resultado = jsonLogicAuto(regra, dados, funcoes_mistas)
if asyncio.iscoroutine(resultado):
    resultado = await resultado

# Antes
resultado = jsonLogic(regra, dados, funcoes)

# Depois  
resultado = await jsonLogic_async(regra, dados, funcoes)

# Mantenha funções existentes
funcoes_sync = {"calc": lambda x, y: x + y}

# Adicione novas funções async
async def fetch_data(id):
    return await api_call(id)

# Combine ambas
funcoes_completas = {
    **funcoes_sync,
    "fetch": fetch_data,
}

# Use operações específicas
regra = {
    "apply": ["calc", 10, 20],        # Síncrona
    "apply_async": ["fetch", "123"]   # Assíncrona
}