import dao.TellerDao
import dao.TransactionDao
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import redis.clients.jedis.JedisPooled
import response.TransactionSuccessResponse

class NeftRequestProcessor {

    companion object {
        private val logger: Logger = LoggerFactory.getLogger(NeftRequestProcessor::class.java)
        private const val PROCESSED_TRANSACTION_LIST = "ipks:processed_outward_transactions"
        private val migratedDCCBCodes = listOf("0012")

        fun process(transactionNumber: String): Pair<String, String>? {

            val outwardTransaction = TransactionDao().getTransactionRequest(transactionNumber) ?: run {
                logger.error("TXN: #{} FAILED REASON: Transaction not found", transactionNumber)
                return null
            }
            logger.info("TXN: #{} FOUND", transactionNumber)
            val jedis = JedisPooled("localhost", 6379)
            val processedTransactionList = jedis.smembers(PROCESSED_TRANSACTION_LIST)
            val dccbCode = outwardTransaction.dccbCode.padStart(4, '0')
            val branchCode = outwardTransaction.branchCode.padStart(3, '0')
            if (dccbCode !in migratedDCCBCodes) {
                logger.error("TXN: #{} FAILED REASON: DCCB Code not migrated", transactionNumber)
                return null
            }

            if (transactionNumber in processedTransactionList) {
                logger.error("TXN: #{} FAILED REASON: Transaction already processed", transactionNumber)
                return null
            }
            val makerTeller = TellerDao.getTeller(dccbCode, branchCode) ?: run {
                logger.error("TXN: #{} FAILED REASON: Teller not found", transactionNumber)
                return null
            }
            val transactionPair = TransactionFactory(outwardTransaction, makerTeller).createTransactionPair()
            val (transferResponse, neftResponse) = try {
                TransactionExecutor().executePair(transactionPair)
            } catch (e: Exception) {
                logger.error("TXN: #{} FAILED REASON: {}", transactionNumber, e.message)
                return null
            }

            logger.info(
                "TXN: #{} TRF_TXN: {} NEFT_TXN: {}",
                transactionNumber,
                transferResponse.status,
                neftResponse.status
            )

            jedis.sadd(PROCESSED_TRANSACTION_LIST, outwardTransaction.transactionNumber)

            if (transferResponse.status == "SUCCESS" && neftResponse.status == "SUCCESS") {
                val transferQueueNumber = (transferResponse as TransactionSuccessResponse).response.queueId
                val neftQueueNumber = (neftResponse as TransactionSuccessResponse).response.queueId
                try {
                    logger.debug("TXN: UPDATING RESULTS")
                    TransactionDao().updateSuccessTransaction(outwardTransaction, transferQueueNumber, neftQueueNumber)
                    logger.info("TXN: #{} UPDATED RESULTS SUCCESSFULLY", transactionNumber)
                } catch (e: Exception) {
                    logger.error(
                        "TXN: #{} QUEUE INITIATED BUT FAILED TO UPDATE RESULT: {}",
                        transactionNumber,
                        e.message
                    )
                }

                return Pair(transferQueueNumber, neftQueueNumber)
            } else {
                logger.error("TXN: #{} QUEUE INITIATED BUT FAILED TO UPDATE RESULT", transactionNumber)
                return null
            }
        }
    }
}