ApiPaymentMethodResponse.kt

package com.ioki.passenger.api.models

import com.ioki.passenger.api.models.ApiPaymentMethodResponse.Summary.Brand
import com.ioki.passenger.api.models.ApiPaymentMethodResponse.Summary.Kind
import com.ioki.passenger.api.models.ApiPaymentMethodResponse.Summary.Wallet
import kotlinx.serialization.KSerializer
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.builtins.serializer
import kotlinx.serialization.encoding.Decoder
import kotlinx.serialization.encoding.Encoder

@Serializable
public data class ApiPaymentMethodResponse(
    @SerialName(value = "payment_method_type")
    val paymentMethodType: ApiPaymentMethodType = ApiPaymentMethodType.UNSUPPORTED,
    @SerialName(value = "requires_paypal_secure_element")
    val requiresPaypalSecureElement: Boolean,
    val id: String?,
    val summary: Summary?,
) {
    @Serializable
    public data class Summary(
        val kind: Kind = Kind.UNSUPPORTED,
        val wallet: Wallet?,
        val brand: Brand?,
        val title: String,
        val last4: String?,
        val expiration: String?,
        @SerialName(value = "mandate_url")
        val mandateUrl: String?,
    ) {
        @Serializable(with = ApiPaymentMethodResponseKindSerializer::class)
        public enum class Kind {
            @SerialName(value = "card")
            CREDIT_CARD,

            @SerialName(value = "sepa_debit")
            SEPA_DEBIT,

            @SerialName(value = "paypal")
            PAYPAL,

            @SerialName(value = "cash")
            CASH,

            @SerialName(value = "service_credits")
            SERVICE_CREDITS,

            @SerialName(value = "pos_payment")
            POS_PAYMENT,

            @SerialName(value = "external_payment")
            EXTERNAL_PAYMENT,

            UNSUPPORTED,
        }

        @Serializable(with = ApiPaymentMethodResponseWalletSerializer::class)
        public enum class Wallet {
            @SerialName(value = "google_pay")
            GOOGLE_PAY,

            @SerialName(value = "apple_pay")
            APPLE_PAY,

            UNSUPPORTED,
        }

        @Serializable(with = ApiPaymentMethodResponseBrandSerializer::class)
        public enum class Brand {
            @SerialName(value = "visa")
            VISA,

            @SerialName(value = "mastercard")
            MASTERCARD,

            @SerialName(value = "amex")
            AMEX,

            @SerialName(value = "cartes_bancaires")
            CARTES_BANCAIRES,

            @SerialName(value = "diners_club")
            DINERS_CLUB,

            @SerialName(value = "discover")
            DISCOVER,

            @SerialName(value = "jcb")
            JCB,

            @SerialName(value = "unionpay")
            UNIONPAY,

            UNSUPPORTED,
        }
    }
}

internal object ApiPaymentMethodResponseKindSerializer : KSerializer<Kind> {
    override val descriptor = String.serializer().descriptor

    override fun serialize(encoder: Encoder, value: Kind) {
        encoder.encodeString(
            when (value) {
                Kind.CREDIT_CARD -> "card"
                Kind.SEPA_DEBIT -> "sepa_debit"
                Kind.PAYPAL -> "paypal"
                Kind.CASH -> "cash"
                Kind.SERVICE_CREDITS -> "service_credits"
                Kind.POS_PAYMENT -> "pos_payment"
                Kind.EXTERNAL_PAYMENT -> "external_payment"
                Kind.UNSUPPORTED -> "unsupported"
            },
        )
    }

    override fun deserialize(decoder: Decoder): Kind = when (decoder.decodeString()) {
        "card" -> Kind.CREDIT_CARD
        "sepa_debit" -> Kind.SEPA_DEBIT
        "paypal" -> Kind.PAYPAL
        "cash" -> Kind.CASH
        "service_credits" -> Kind.SERVICE_CREDITS
        "pos_payment" -> Kind.POS_PAYMENT
        "external_payment" -> Kind.EXTERNAL_PAYMENT
        else -> Kind.UNSUPPORTED
    }
}

internal object ApiPaymentMethodResponseWalletSerializer : KSerializer<Wallet> {
    override val descriptor = String.serializer().descriptor

    override fun serialize(encoder: Encoder, value: Wallet) {
        encoder.encodeString(
            when (value) {
                Wallet.GOOGLE_PAY -> "google_pay"
                Wallet.APPLE_PAY -> "apple_pay"
                Wallet.UNSUPPORTED -> "unsupported"
            },
        )
    }

    override fun deserialize(decoder: Decoder): Wallet = when (decoder.decodeString()) {
        "google_pay" -> Wallet.GOOGLE_PAY
        "apple_pay" -> Wallet.APPLE_PAY
        else -> Wallet.UNSUPPORTED
    }
}

internal object ApiPaymentMethodResponseBrandSerializer : KSerializer<Brand> {
    override val descriptor = String.serializer().descriptor

    override fun serialize(encoder: Encoder, value: Brand) {
        encoder.encodeString(
            when (value) {
                Brand.VISA -> "visa"
                Brand.MASTERCARD -> "mastercard"
                Brand.AMEX -> "amex"
                Brand.CARTES_BANCAIRES -> "cartes_bancaires"
                Brand.DINERS_CLUB -> "diners_club"
                Brand.DISCOVER -> "discover"
                Brand.JCB -> "jcb"
                Brand.UNIONPAY -> "unionpay"
                Brand.UNSUPPORTED -> "unsupported"
            },
        )
    }

    override fun deserialize(decoder: Decoder): Brand = when (decoder.decodeString()) {
        "visa" -> Brand.VISA
        "mastercard" -> Brand.MASTERCARD
        "amex" -> Brand.AMEX
        "cartes_bancaires" -> Brand.CARTES_BANCAIRES
        "diners_club" -> Brand.DINERS_CLUB
        "discover" -> Brand.DISCOVER
        "jcb" -> Brand.JCB
        "unionpay" -> Brand.UNIONPAY
        else -> Brand.UNSUPPORTED
    }
}