pip install httpx python-dotenv

# config.py
import os
from dotenv import load_dotenv

load_dotenv()

# URLs das APIs
BASE_URL = os.getenv("CSUITE_BASE_URL", "https://csuite.internut.com.br")
FOURC_DECISION_API = f"{BASE_URL}/4c/decision"
FOURC_FEATURE_API = f"{BASE_URL}/4c/feature-service"
FOURC_SCORING_API = f"{BASE_URL}/4c/scoring-service"
EXECUTIVE_API = f"{BASE_URL}/executive"
CONTEXT_API = f"{BASE_URL}/context/api/csuite"
CASHFLOW_API = f"{BASE_URL}/cashflow/api/cashflow"

# Credenciais
AUTH_EMAIL = os.getenv("CSUITE_EMAIL")
AUTH_PASSWORD = os.getenv("CSUITE_PASSWORD")

# auth.py
import httpx
from config import BASE_URL

async def get_auth_token():
    """Obtém token de autenticação"""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{BASE_URL}/auth/login",
            json={
                "email": AUTH_EMAIL,
                "password": AUTH_PASSWORD
            }
        )
        response.raise_for_status()
        return response.json()["access_token"]

# Cache do token
_token = None

async def get_token():
    """Retorna token (com cache)"""
    global _token
    if _token is None:
        _token = await get_auth_token()
    return _token

# examples/4c_features.py
import httpx
from config import FOURC_FEATURE_API, get_token

async def get_customer_features(customer_id: int, context: dict = None):
    """
    Obtém features agregadas de um cliente

    Args:
        customer_id: ID do cliente
        context: Contexto adicional (ex: SKU específico)

    Returns:
        Dict com features do cliente
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{FOURC_FEATURE_API}/features/customer",
            json={
                "customer_id": customer_id,
                "context": context or {}
            },
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
import asyncio

async def main():
    features = await get_customer_features(
        customer_id=123,
        context={"sku": "BK4-2516"}
    )
    print(f"Features do cliente 123:")
    print(f"  - Recency: {features['features']['recency_days']} dias")
    print(f"  - Frequência (12m): {features['features']['freq_12m']}")
    print(f"  - Valor (12m): R$ {features['features']['value_12m']:.2f}")
    print(f"  - RFM Score: {features['features']['rfm']:.2f}")

asyncio.run(main())

# examples/4c_scoring.py
import httpx
from config import FOURC_SCORING_API, FOURC_FEATURE_API, get_token

async def calculate_intent_score(customer_id: int):
    """
    Calcula score de intenção de compra

    Args:
        customer_id: ID do cliente

    Returns:
        Dict com score de intenção
    """
    token = await get_token()

    # 1. Obter features
    async with httpx.AsyncClient() as client:
        features_resp = await client.post(
            f"{FOURC_FEATURE_API}/features/customer",
            json={"customer_id": customer_id},
            headers={"Authorization": f"Bearer {token}"}
        )
        features_resp.raise_for_status()
        features = features_resp.json()["features"]

    # 2. Calcular score de intenção
    async with httpx.AsyncClient() as client:
        score_resp = await client.post(
            f"{FOURC_SCORING_API}/score/intent",
            json={
                "customer_id": customer_id,
                "features": features
            },
            headers={"Authorization": f"Bearer {token}"}
        )
        score_resp.raise_for_status()
        return score_resp.json()

# Uso
async def main():
    score = await calculate_intent_score(customer_id=123)
    print(f"Score de intenção do cliente 123: {score['intent_score']:.2%}")
    print(f"Modelo usado: {score['model_version']}")

asyncio.run(main())

# examples/4c_decision.py
import httpx
from config import FOURC_DECISION_API, get_token

async def make_decision(
    customer_id: int,
    candidates: list,
    constraints: dict = None
):
    """
    Toma decisão completa (cliente, oferta, canal, timing)

    Args:
        customer_id: ID do cliente
        candidates: Lista de ofertas candidatas
        constraints: Constraints (min_intent, max_contacts, etc)

    Returns:
        Dict com decisão completa
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{FOURC_DECISION_API}/decide",
            json={
                "customer_id": customer_id,
                "candidates": candidates,
                "constraints": constraints or {},
                "include_explanations": True,
                "include_natural_justification": True
            },
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    decision = await make_decision(
        customer_id=123,
        candidates=[
            {"sku": "BK4-2516", "price": 1500.00},
            {"sku": "BK4-2517", "price": 2000.00}
        ],
        constraints={
            "min_intent": 0.45,
            "max_contacts_per_day": 2,
            "respect_opt_out": True
        }
    )

    if decision["approved"]:
        print(f"✅ Decisão aprovada!")
        print(f"  - Oferta: {decision['offer']['sku']} (R$ {decision['offer']['price']:.2f})")
        print(f"  - Canal: {decision['channel']}")
        print(f"  - Timing: {decision['timing']['send_at']}")
        print(f"  - Scores:")
        print(f"    * Intenção: {decision['scores']['intent']:.2%}")
        print(f"    * Oferta: {decision['scores']['offer']:.2%}")
        print(f"    * Canal: {decision['scores']['channel']:.2%}")
        print(f"    * Timing: {decision['scores']['timing']:.2%}")
        if decision.get("natural_justification"):
            print(f"  - Justificativa: {decision['natural_justification']}")
    else:
        print(f"❌ Decisão pulada: {decision['skip_reason']}")

asyncio.run(main())

# examples/4c_auto_decision.py
import httpx
from config import FOURC_DECISION_API, get_token

async def auto_decision(customer_id: int):
    """
    Decisão automática (sistema escolhe oferta)

    Args:
        customer_id: ID do cliente

    Returns:
        Dict com decisão automática
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{FOURC_DECISION_API}/decide/auto",
            json={
                "customer_id": customer_id,
                "include_explanations": True,
                "include_natural_justification": True
            },
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    decision = await auto_decision(customer_id=123)

    if decision["approved"]:
        print(f"✅ Decisão automática gerada!")
        print(f"  - Oferta escolhida: {decision['offer']['sku']}")
        print(f"  - Canal: {decision['channel']}")
        print(f"  - Enviar em: {decision['timing']['send_at']}")

asyncio.run(main())

# examples/4c_execute.py
import httpx
from config import FOURC_DECISION_API, get_token

async def execute_decision(decision_id: str):
    """
    Executa decisão (envia mensagem via WhatsApp/Email)

    Args:
        decision_id: ID da decisão

    Returns:
        Dict com resultado da execução
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{FOURC_DECISION_API}/send",
            json={"decision_id": decision_id},
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    # 1. Gerar decisão
    decision = await auto_decision(customer_id=123)

    if decision["approved"]:
        # 2. Executar decisão
        execution = await execute_decision(decision["decision_id"])
        print(f"✅ Mensagem enviada!")
        print(f"  - Execution ID: {execution['execution_id']}")
        print(f"  - Status: {execution['status']}")
        print(f"  - Canal: {execution['channel']}")

asyncio.run(main())

# examples/executive_dashboard.py
import httpx
from config import EXECUTIVE_API, get_token

async def get_executive_dashboard(org_id: int):
    """
    Obtém resumo do dashboard executivo

    Args:
        org_id: ID da organização

    Returns:
        Dict com resumo executivo
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{EXECUTIVE_API}/dashboard/summary/{org_id}",
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    dashboard = await get_executive_dashboard(org_id=1)

    print(f"📊 Dashboard Executivo - Org {dashboard['org_id']}")
    print(f"  - Alertas abertos: {dashboard['alerts_open']}")
    print(f"  - Alertas fechados: {dashboard['alerts_closed']}")
    print(f"  - Action items pendentes: {dashboard['items_pending']}")
    print(f"  - Action items completados: {dashboard['items_completed']}")
    print(f"  - Última execução: {dashboard['last_run']}")
    print(f"  - Métricas (30 dias):")
    print(f"    * Receita: R$ {dashboard['metrics']['revenue_30d']:,.2f}")
    print(f"    * Pedidos: {dashboard['metrics']['orders_30d']}")
    print(f"    * Clientes ativos: {dashboard['metrics']['customers_active']}")

asyncio.run(main())

# examples/executive_agent.py
import httpx
from config import EXECUTIVE_API, get_token

async def run_cfo_agent(org_id: int, force: bool = False):
    """
    Executa agente CFO para análise financeira

    Args:
        org_id: ID da organização
        force: Forçar execução mesmo se já executado recentemente

    Returns:
        Dict com resultado da execução
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{EXECUTIVE_API}/agents/{org_id}/cfo/run",
            json={"force": force},
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    result = await run_cfo_agent(org_id=1, force=False)

    print(f"✅ Agente CFO executado!")
    print(f"  - Run ID: {result['run_id']}")
    print(f"  - Status: {result['status']}")
    print(f"  - Alertas gerados: {result.get('alerts_generated', 0)}")
    print(f"  - Action items criados: {result.get('action_items_created', 0)}")

asyncio.run(main())

# examples/executive_alerts.py
import httpx
from config import EXECUTIVE_API, get_token

async def get_alerts(org_id: int = None, priority: str = None, status: str = "open"):
    """
    Obtém lista de alertas

    Args:
        org_id: ID da organização (opcional)
        priority: Prioridade (high, medium, low)
        status: Status (open, closed, in_progress)

    Returns:
        Lista de alertas
    """
    token = await get_token()

    params = {}
    if org_id:
        params["org_id"] = org_id
    if priority:
        params["priority"] = priority
    if status:
        params["status"] = status

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{EXECUTIVE_API}/alerts",
            params=params,
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    alerts = await get_alerts(priority="high", status="open")

    print(f"🚨 Alertas de Alta Prioridade ({len(alerts)}):")
    for alert in alerts:
        print(f"  - {alert['title']}")
        print(f"    Tipo: {alert['type']}")
        print(f"    Severidade: {alert['severity']}")
        print(f"    Criado em: {alert['created_at']}")
        print()

asyncio.run(main())

# examples/executive_action_items.py
import httpx
from config import EXECUTIVE_API, get_token

async def create_action_item(
    alert_id: str,
    title: str,
    description: str,
    priority: str = "medium",
    due_date: str = None
):
    """
    Cria action item a partir de alerta

    Args:
        alert_id: ID do alerta
        title: Título do action item
        description: Descrição
        priority: Prioridade (high, medium, low)
        due_date: Data de vencimento (ISO format)

    Returns:
        Dict com action item criado
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{EXECUTIVE_API}/action-items",
            json={
                "alert_id": alert_id,
                "title": title,
                "description": description,
                "priority": priority,
                "due_date": due_date
            },
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    # 1. Obter alerta
    alerts = await get_alerts(priority="high", status="open")
    if alerts:
        alert = alerts[0]

        # 2. Criar action item
        action_item = await create_action_item(
            alert_id=alert["id"],
            title="Resolver problema de fluxo de caixa",
            description="Acelerar cobrança de clientes com pagamento em atraso",
            priority="high",
            due_date="2025-12-10T00:00:00Z"
        )

        print(f"✅ Action item criado!")
        print(f"  - ID: {action_item['id']}")
        print(f"  - Título: {action_item['title']}")
        print(f"  - Prioridade: {action_item['priority']}")

asyncio.run(main())

# examples/context_events.py
import httpx
from config import CONTEXT_API, get_token

async def get_events(days: int = 7, event_type: str = None):
    """
    Obtém eventos de curto prazo

    Args:
        days: Número de dias para buscar
        event_type: Tipo de evento (opcional)

    Returns:
        Lista de eventos
    """
    token = await get_token()

    params = {"days": days}
    if event_type:
        params["type"] = event_type

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{CONTEXT_API}/events",
            params=params,
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    events = await get_events(days=7)

    print(f"📅 Eventos dos últimos 7 dias ({len(events)}):")
    for event in events:
        print(f"  - {event['title']}")
        print(f"    Tipo: {event['type']}")
        print(f"    Data: {event['date']}")
        print(f"    Impacto: {event.get('impact', 'N/A')}")
        print()

asyncio.run(main())

# examples/context_trends.py
import httpx
from config import CONTEXT_API, get_token

async def get_trends(metric: str = None, days: int = 30):
    """
    Obtém tendências de médio prazo

    Args:
        metric: Métrica específica (opcional)
        days: Período em dias

    Returns:
        Lista de tendências
    """
    token = await get_token()

    params = {"days": days}
    if metric:
        params["metric"] = metric

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{CONTEXT_API}/trends",
            params=params,
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    trends = await get_trends(days=30)

    print(f"📈 Tendências (30 dias):")
    for trend in trends:
        print(f"  - {trend['metric']}: {trend['direction']} ({trend['strength']:.2%})")
        print(f"    Período: {trend['period']}")
        print()

asyncio.run(main())

# examples/cashflow_timeline.py
import httpx
from config import CASHFLOW_API, get_token

async def get_cashflow_timeline(days: int = 90):
    """
    Obtém timeline de fluxo de caixa

    Args:
        days: Número de dias para projetar

    Returns:
        Dict com timeline
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"{CASHFLOW_API}/timeline",
            params={"days": days},
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    timeline = await get_cashflow_timeline(days=90)

    print(f"💰 Timeline de Fluxo de Caixa (90 dias):")
    print(f"  - Saldo inicial: R$ {timeline['initial_balance']:,.2f}")
    print(f"  - Saldo final projetado: R$ {timeline['final_balance']:,.2f}")
    print(f"  - Entradas totais: R$ {timeline['total_inflows']:,.2f}")
    print(f"  - Saídas totais: R$ {timeline['total_outflows']:,.2f}")
    print(f"  - Saldo mínimo: R$ {timeline['min_balance']:,.2f}")

asyncio.run(main())

# examples/cashflow_simulate.py
import httpx
from config import CASHFLOW_API, get_token

async def simulate_scenario(scenario_name: str, parameters: dict):
    """
    Simula cenário de fluxo de caixa

    Args:
        scenario_name: Nome do cenário
        parameters: Parâmetros da simulação

    Returns:
        Dict com resultado da simulação
    """
    token = await get_token()

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CASHFLOW_API}/simulator/run",
            json={
                "scenario": scenario_name,
                "parameters": parameters
            },
            headers={"Authorization": f"Bearer {token}"}
        )
        response.raise_for_status()
        return response.json()

# Uso
async def main():
    # Simular cenário de acelerar cobrança
    result = await simulate_scenario(
        scenario_name="accelerate_collection",
        parameters={
            "collection_days_reduction": 5,
            "discount_rate": 0.02  # 2% de desconto
        }
    )

    print(f"📊 Simulação: Acelerar Cobrança")
    print(f"  - Saldo final: R$ {result['final_balance']:,.2f}")
    print(f"  - Impacto: R$ {result['impact']:,.2f}")
    print(f"  - Risco: {result['risk_level']}")

asyncio.run(main())

# examples/integrated_reactivation.py
import httpx
import asyncio
from config import *

async def reactivate_customer_workflow(customer_id: int):
    """
    Workflow completo de reativação de cliente:
    1. Detectar cliente inativo (Context API)
    2. Obter features (4C Feature Service)
    3. Calcular score de intenção (4C Scoring Service)
    4. Gerar decisão de reativação (4C Decision API)
    5. Executar decisão (4C Executor)
    6. Monitorar resultado
    """
    token = await get_token()
    headers = {"Authorization": f"Bearer {token}"}

    async with httpx.AsyncClient() as client:
        # 1. Verificar se cliente está inativo
        signals = await client.get(
            f"{CONTEXT_API}/signals",
            params={"type": "customer_inactive", "customer_id": customer_id},
            headers=headers
        )
        signals.raise_for_status()
        signals_data = signals.json()

        if not signals_data:
            print(f"Cliente {customer_id} não está inativo")
            return

        print(f"✅ Cliente {customer_id} detectado como inativo")

        # 2. Obter features
        features_resp = await client.post(
            f"{FOURC_FEATURE_API}/features/customer",
            json={"customer_id": customer_id, "context": {"goal": "reactivation"}},
            headers=headers
        )
        features_resp.raise_for_status()
        features = features_resp.json()["features"]
        print(f"✅ Features obtidas (RFM: {features['rfm']:.2f})")

        # 3. Calcular score de intenção
        intent_resp = await client.post(
            f"{FOURC_SCORING_API}/score/intent",
            json={"customer_id": customer_id, "features": features},
            headers=headers
        )
        intent_resp.raise_for_status()
        intent_score = intent_resp.json()["intent_score"]
        print(f"✅ Score de intenção: {intent_score:.2%}")

        if intent_score < 0.3:
            print(f"❌ Score muito baixo, não prosseguir com reativação")
            return

        # 4. Gerar decisão de reativação
        decision_resp = await client.post(
            f"{FOURC_DECISION_API}/decide/auto",
            json={
                "customer_id": customer_id,
                "context": {"goal": "reactivation", "urgency": "medium"},
                "include_explanations": True
            },
            headers=headers
        )
        decision_resp.raise_for_status()
        decision = decision_resp.json()

        if not decision["approved"]:
            print(f"❌ Decisão não aprovada: {decision['skip_reason']}")
            return

        print(f"✅ Decisão gerada:")
        print(f"  - Oferta: {decision['offer']['sku']}")
        print(f"  - Canal: {decision['channel']}")
        print(f"  - Timing: {decision['timing']['send_at']}")

        # 5. Executar decisão
        execute_resp = await client.post(
            f"{FOURC_DECISION_API}/send",
            json={"decision_id": decision["decision_id"]},
            headers=headers
        )
        execute_resp.raise_for_status()
        execution = execute_resp.json()

        print(f"✅ Mensagem enviada!")
        print(f"  - Execution ID: {execution['execution_id']}")
        print(f"  - Status: {execution['status']}")

        return {
            "customer_id": customer_id,
            "decision_id": decision["decision_id"],
            "execution_id": execution["execution_id"],
            "intent_score": intent_score
        }

# Uso
asyncio.run(reactivate_customer_workflow(customer_id=123))

# examples/integrated_alert_response.py
import httpx
import asyncio
from config import *

async def respond_to_financial_alert(alert_id: str):
    """
    Responde a alerta financeiro:
    1. Obter alerta (Executive API)
    2. Simular impacto de ações (Cashflow API)
    3. Gerar decisões para clientes com atraso (4C Decision API)
    4. Criar action items (Executive API)
    5. Fechar alerta quando resolvido
    """
    token = await get_token()
    headers = {"Authorization": f"Bearer {token}"}

    async with httpx.AsyncClient() as client:
        # 1. Obter alerta
        alert_resp = await client.get(
            f"{EXECUTIVE_API}/alerts/{alert_id}",
            headers=headers
        )
        alert_resp.raise_for_status()
        alert = alert_resp.json()

        print(f"🚨 Alerta: {alert['title']}")
        print(f"  - Tipo: {alert['type']}")
        print(f"  - Severidade: {alert['severity']}")

        if alert["type"] != "financial":
            print("❌ Alerta não é financeiro")
            return

        # 2. Simular impacto de acelerar cobrança
        simulate_resp = await client.post(
            f"{CASHFLOW_API}/simulator/run",
            json={
                "scenario": "accelerate_collection",
                "parameters": {
                    "collection_days_reduction": 5,
                    "discount_rate": 0.02
                }
            },
            headers=headers
        )
        simulate_resp.raise_for_status()
        simulation = simulate_resp.json()

        print(f"📊 Simulação:")
        print(f"  - Impacto: R$ {simulation['impact']:,.2f}")
        print(f"  - Saldo final: R$ {simulation['final_balance']:,.2f}")

        # 3. Obter clientes com atraso (assumindo que vem do alerta)
        # Em produção, isso viria de uma query ao banco
        customers_with_delay = [123, 456, 789]  # Exemplo

        # 4. Gerar decisões para clientes com atraso
        decisions = []
        for customer_id in customers_with_delay:
            decision_resp = await client.post(
                f"{FOURC_DECISION_API}/decide/auto",
                json={
                    "customer_id": customer_id,
                    "context": {
                        "goal": "collection",
                        "urgency": "high"
                    }
                },
                headers=headers
            )
            decision_resp.raise_for_status()
            decision = decision_resp.json()

            if decision["approved"]:
                decisions.append(decision)
                print(f"✅ Decisão gerada para cliente {customer_id}")

        # 5. Criar action item
        action_item_resp = await client.post(
            f"{EXECUTIVE_API}/action-items",
            json={
                "alert_id": alert_id,
                "title": "Acelerar cobrança de clientes",
                "description": f"Geradas {len(decisions)} decisões para clientes com atraso",
                "priority": "high",
                "due_date": "2025-12-10T00:00:00Z"
            },
            headers=headers
        )
        action_item_resp.raise_for_status()
        action_item = action_item_resp.json()

        print(f"✅ Action item criado: {action_item['id']}")

        return {
            "alert_id": alert_id,
            "simulation": simulation,
            "decisions_generated": len(decisions),
            "action_item_id": action_item["id"]
        }

# Uso
asyncio.run(respond_to_financial_alert(alert_id="alert-123"))

# Exemplo
python examples/4c_decision.py
python examples/integrated_reactivation.py