# Criar um Pagamento Parcelado (Plazox)

O **Smart SDK** suporta pagamentos diferidos (frequentemente referidos como **Plazox**). Este recurso permite que os portadores de cartão dividam o valor da transação em parcelas diretamente no Ponto de Venda (POS).

## Pré-requisitos

Antes de tentar um pagamento parcelado, você deve verificar se o terminal está configurado para suportar este recurso.

### Verificando a Disponibilidade

Você pode verificar se o recurso "Plazox" ou de pagamento diferido está habilitado na configuração atual inspecionando o objeto `TpvInfo` obtido durante a inicialização.

```kotlin
suspend fun checkInstallmentSupport() {
    val result = initializationRepository.getTpvInfoRepositoryResult()

    if (result is RepositoryResult.Success) {
        val config = result.data.config

        // Check the 'showPlazox' flag
        if (config.showPlazox) {
            println("✅ Installments (Plazox) are enabled on this device.")
        } else {
            println("❌ Installments are disabled.")
        }
    }
}
```

## Realizando o Pagamento

Para iniciar um pagamento parcelado, você utiliza a função padrão `makePayment`, mas fornece o parâmetro opcional `financialConditions`.

**Função**: `makePayment`  
**Parâmetro**: `financialConditions` (Tipo: `FinancialConditions?`).

### Implementação

```kotlin
suspend fun payWithInstallments(amount: BigDecimal) {
    // 1. Define the amount
    val money = Money(amount, Currency.getInstance("EUR"))

    // 2. Define Financial Conditions
    // Pass the specific conditions required (or an empty object depending on specific bank logic)
    // Note: The specific structure of FinancialConditions depends on the library version
    val conditions = FinancialConditions(/* ... configuration parameters ... */)

    // 3. Call makePayment with the conditions
    val result = paymentRepository.makePayment(
        amount = money,
        financialConditions = conditions // Trigger the financial flow
    )

    handlePaymentResult(result)
}
```

<Callout type="note">

Se o cartão suportar parcelamento e o recurso estiver habilitado (`showPlazox`), o Get Smart SDK Payment Service pode solicitar automaticamente que o usuário escolha as parcelas na tela do dispositivo, mesmo sem parâmetros estritos, dependendo da configuração do host.

</Callout>

## Tratando o Resultado

Se o pagamento for aceito e processado como uma transação parcelada, o objeto `Transaction` resultante conterá um bloco `financialInfo` com os detalhes do pagamento diferido.

### O Objeto FinancialInfo

A data class `Transaction` inclui um campo opcional `financialInfo`. Se este campo não for nulo, a transação envolveu termos de parcelamento.

**Exemplo de Tratamento:**

```kotlin
fun handlePaymentResult(result: RepositoryResult<PaymentResult>) {
    if (result is RepositoryResult.Success && result.data is PaymentResult.Accepted) {
        val transaction = (result.data as PaymentResult.Accepted).data

        // Check for Financial Info
        val finance = transaction.financialInfo

        if (finance != null) {
            println("💰 Deferred Payment Confirmed")
            // Access specific financial details if available in the FinancialInfo model
            // (Refer to the Javadoc in the ZIP for specific fields of FinancialInfo)
        } else {
            println("✅ Standard Payment (One-off)")
        }
    }
}
```

## Resumo

Para implementar pagamentos parcelados:
1.  **Verifique** `TpvConfig.showPlazox` para garantir que o recurso está ativo.
2.  **Chame** `makePayment` passando o parâmetro `financialConditions`.
3.  **Valide** o `Transaction.financialInfo` na resposta para confirmar os termos.