Lectura de tarjetas

enum class OperationType {
   PAYMENT,
   PREAUTHORIZATION,
   REFUND,
   ANNULMENT,
   POSTAUTHORIZATION
}

val cardProcessData = CardProcessData()
 cardProcessData.findCardProcess(
            operationFlow = doOperationFlow(amount),
            context = this,
            inputModeType = InputMode.ALL
        )
cardProcessData.selectApp.observe(this, selectAppObserver)
cardProcessData.navigate.observe(this, navigateObserver)
 
    private fun doOperationFlow(
        baseAmount: String,
        tipAmount: String,
        totalAmount: String
    ): OperationFlow {
        operationFlow.amount = Amount()
        
        // Crear breakdown para el monto base (siempre presente)
        val breakdownAmount = Breakdown()
        breakdownAmount.description = OPERATION
        breakdownAmount.amount = StringUtils.notFormatAmount(baseAmount)
        Log.i(TAG, "AMOUNT: ${breakdownAmount.amount}")
 
        // Crear lista de breakdowns
        val breakdownList = mutableListOf<Breakdown>()
        breakdownList.add(breakdownAmount)
 
        // Agregar breakdown de propina solo si es mayor a 0
        val tipAmountValue = tipAmount.toIntOrNull() ?: 0
        if (tipAmountValue > 0) {
            val breakdownTipAmount = Breakdown()
            breakdownTipAmount.description = TIP
            breakdownTipAmount.amount = StringUtils.notFormatAmount(tipAmount)
            breakdownList.add(breakdownTipAmount)
            Log.i(TAG, "TIP: ${breakdownTipAmount.amount}")
        } else {
            Log.i(TAG, "No tip amount")
        }
 
        operationFlow.capture = Capture()
        operationFlow.capture!!.card = Card()
        operationFlow.apply {
            amount?.let {
                it.total = StringUtils.notFormatAmount(totalAmount)
                it.currency = currency
                it.breakdown = breakdownList
            }
        }
        if (operationType.isNotNull()) {
            if (operationType != "PAYMENT" && operationType != "PREAUTHORIZATION") {
                if (currency == CURRENCY_LABEL_MX) {
                    operationFlow.transactionType = OperationType.REFUND
                } else {
                    if (isToday(transaction.operation.datetime)) {
                        operationFlow.transactionType = OperationType.ANNULMENT
                    } else {
                        operationFlow.transactionType = OperationType.REFUND
                    }
                }
                //Se agregan identificadores del pago original
                operationFlow.acquirer_id = transaction.operation.acquirer_id
                operationFlow.payment_id = transaction.operation.id
            } else {
                when (operationType) {
                    OperationType.PAYMENT.name -> operationFlow.transactionType =
                        OperationType.PAYMENT
 
                    OperationType.PREAUTHORIZATION.name -> operationFlow.transactionType =
                        OperationType.PREAUTHORIZATION
                }
            }
        } else {
            operationFlow.transactionType = OperationType.PAYMENT
        }
 
        //inicializar otros objetos
        operationFlow.capture!!.card?.holder = Holder()
        operationFlow.terminal = Terminal()
 
        OperationFlowHolder.operationFlow = operationFlow
        return operationFlow
    }
 
    private val navigateObserver: (Any) -> Unit = {
        when (it) {
            is Bundle -> {
        
                val status = it.get("status")
                val statusResult: StatusResult = status as StatusResult
 
                val action = ActionType.valueOf(statusResult.readerAction ?: EMPTY)
                when (action) {
                     ActionType.START_READER_AGAIN_WITH_SWIPE -> {
                        cardProcessData.setFallbackFlag() // Importante para notificar al adquirente que fue fallback banda, no requerido para los otros actions, solo para START_READER_AGAIN_WITH_SWIPE
                        instructionMessageState.value = status.message ?: "Use la banda"
                        cardProcessData.findCardProcess(
                            operationFlow = operationFlow,
                            context = this,
                            inputModeType = InputMode.SWIPE,
                            encryptedPanToValidate = if (operationType != "PAYMENT" && operationType != "PREAUTHORIZATION") {
                                transaction.card.pan
                            } else null
                        )
                    }
                    
                    ActionType.START_READER_AGAIN_WITH_CONTACT -> {
                        // Action para solicitar nuevamente la lectura insertando la tarjeta 
                    }
                   
                    ActionType.START_READER_AGAIN_WITH_CONTACTLESS -> {
                        // Action para solicitar nuevamente la lectura acercando la tarjeta 
                    }
 
                    else -> {
                        // Mostrar mensaje de error: statusResult.description
                    }
                }
            }
 
            is String -> {
                //La lectura fue exitosa, continuar a validar BIN
                val bundle = Bundle().apply {
                    putString("bin", it)
                }
                val intent = Intent(this, CardRulesValidationActivity::class.java).apply {
                    putExtras(bundle)
                }
                startActivity(intent)
            }
        }
    }

cardProcessData.readerInfoMessage.observe(this) { infoMessages ->
    infoMessages?.let { infoMessagesObserver(it) }
}
private val infoMessagesObserver: (DataToast) -> Unit = { infoMessages ->
    Log.i(TAG, "${infoMessages.message}")
}