package com.reactnativepayu

import android.app.Activity
import android.text.TextUtils
import android.webkit.WebView
import com.facebook.react.bridge.*
import com.payu.base.models.*
import com.payu.checkoutpro.PayUCheckoutPro
import com.payu.checkoutpro.models.PayUCheckoutProConfig
import com.payu.checkoutpro.utils.PayUCheckoutProConstants
import com.payu.checkoutpro.utils.PayUCheckoutProConstants.CP_HASH_NAME
import com.payu.checkoutpro.utils.PayUCheckoutProConstants.CP_HASH_STRING
import com.payu.ui.model.listeners.PayUCheckoutProListener
import com.payu.ui.model.listeners.PayUHashGenerationListener


class PayUPayment(activity: Activity,params:ReadableMap,promise:Promise) {
    private var activity: Activity? = null
    var key:String? = "7rnFly" // "6dkn2R8b";
    var hash_value1:String? = ""
    var hash_value2:String? = ""
    var hash_value3:String? = ""
    var hash_value4:String? = ""
    var callBack: Promise? = null
    init {
      this.activity = activity
      this.key = params.getString("key")
      this.hash_value1 = params.getString("hash_value1")
      this.hash_value2 = params.getString("hash_value2")
      this.hash_value3 = params.getString("hash_value3")
      this.hash_value4 = params.getString("hash_value4")
      this.callBack = promise

      val paymentParams = preparePayUBizParams(params)
      initUiSdk(paymentParams,params)
    }

    private fun preparePayUBizParams(params: ReadableMap): PayUPaymentParams {
//        val vasForMobileSdkHash = HashGenerationUtils.generateHashFromSDK(
//            "${key}|${PayUCheckoutProConstants.CP_VAS_FOR_MOBILE_SDK}|${PayUCheckoutProConstants.CP_DEFAULT}|",
//            salt
//        )
      val vasForMobileSdkHash = hash_value1
//        val paymenRelatedDetailsHash = HashGenerationUtils.generateHashFromSDK(
//            "${key}|${PayUCheckoutProConstants.CP_PAYMENT_RELATED_DETAILS_FOR_MOBILE_SDK}|${""}|",
//            salt
//        )
      val paymenRelatedDetailsHash = hash_value2
        val additionalParamsMap: HashMap<String, Any?> = HashMap()
        additionalParamsMap[PayUCheckoutProConstants.CP_UDF1] = "udf1"
        additionalParamsMap[PayUCheckoutProConstants.CP_UDF2] = "udf2"
        additionalParamsMap[PayUCheckoutProConstants.CP_UDF3] = "udf3"
        additionalParamsMap[PayUCheckoutProConstants.CP_UDF4] = "udf4"
        additionalParamsMap[PayUCheckoutProConstants.CP_UDF5] = "udf5"

        //Below params should be passed only when integrating Multi-currency support
        //TODO Please pass your own Merchant Access Key below as provided by your Key Account Manager at PayU.
//        additionalParamsMap[PayUCheckoutProConstants.CP_MERCHANT_ACCESS_KEY] = merchantAccessKey

        //Below hashes are static hashes and can be calculated and passed in additional params
        additionalParamsMap[PayUCheckoutProConstants.CP_VAS_FOR_MOBILE_SDK] = vasForMobileSdkHash
        additionalParamsMap[PayUCheckoutProConstants.CP_PAYMENT_RELATED_DETAILS_FOR_MOBILE_SDK] =
            paymenRelatedDetailsHash

        val siDetails: PayUSIParams? =null
        return PayUPaymentParams.Builder().setAmount(params.getString("amount"))
            .setIsProduction(params.getBoolean("is_production"))
            .setKey(key)
            .setProductInfo(params.getString("productInfo"))
            .setPhone(params.getString("phone"))
            .setTransactionId(params.getString("transactionId"))
            .setFirstName(params.getString("firstName"))
            .setEmail(params.getString("email"))
            .setSurl(params.getString("surl"))
            .setFurl(params.getString("furl"))
            .setUserCredential("")
            .setAdditionalParams(additionalParamsMap)
            .setPayUSIParams(siDetails)
            .build()
    }

    private fun initUiSdk(payUPaymentParams: PayUPaymentParams, react_params: ReadableMap) {
        PayUCheckoutPro.open(
            activity = activity!!,
            payUPaymentParams,
            getCheckoutProConfig(),
            object : PayUCheckoutProListener {

                override fun onPaymentSuccess(response: Any) {
                  response as HashMap<String, Any?>
                  val map = WritableNativeMap()
                  map.putString("status","success")
                  map.putMap("data",MapUtil.toWritableMap(response))
                  callBack?.resolve(map)
                }

                override fun onPaymentFailure(response: Any) {
                  response as HashMap<String, Any?>
                  val json = WritableNativeMap()
                  json.putString("status","failed")
                  json.putString("message","Payment Failure!")
                  json.putMap("data",MapUtil.toWritableMap(response))
                  callBack?.resolve(json)
                }

                override fun onPaymentCancel(isTxnInitiated: Boolean) {
                  val json = WritableNativeMap()
                    json.putString("status","failed")
                    json.putString("message","User Cancelled!")
                    callBack?.resolve(json)
                }

                override fun onError(errorResponse: ErrorResponse) {
                    var errorMessage: String = ""
                    var errorCode: Int = 0
                    if (errorResponse.errorMessage != null && errorResponse.errorMessage!!.isNotEmpty()) {
                      errorMessage = errorResponse.errorMessage!!
                      errorCode = errorResponse.errorCode!!
                    }
                  val json = WritableNativeMap()
                  json.putString("status","failed")
                  json.putString("message","Error!")
                  json.putInt("error_code",errorCode)
                  json.putString("error_message",errorMessage)
                  callBack?.resolve(json)
                }

                override fun generateHash(
                    map: HashMap<String, String?>,
                    hashGenerationListener: PayUHashGenerationListener
                ) {
                    if (map.containsKey(CP_HASH_STRING) && map.containsKey(CP_HASH_NAME)
                    ) {

                        val hashData = map[CP_HASH_STRING]
                        val hashName = map[CP_HASH_NAME]
                        println(hashData)
                        var hash: String? = null

                        //Below hash should be calculated only when integrating Multi-currency support. If not integrating MCP
                        // then no need to have this if check.
                        hash = if (hashName.equals(PayUCheckoutProConstants.CP_LOOKUP_API_HASH, ignoreCase = true)){

                            //Calculate HmacSHA1 hash using the hashData and merchant secret key
//                            HashGenerationUtils.generateHashFromSDK(
//                                hashData!!,
//                                salt,
//                                null
//                            )
                           if(hashData!!.contains("eligibleBinsForEMI",ignoreCase = true)) {
                                hash_value4
                            } else {
                                hash_value3
                            }
                        } else {
                            //calculate SDH-512 hash using hashData and salt
//                            HashGenerationUtils.generateHashFromSDK(
//                                hashData!!,
//                                salt
//                            )
                          hash_value3
                        }

                        if (!TextUtils.isEmpty(hash)) {
                            val hashMap: HashMap<String, String?> = HashMap()
                            hashMap[hashName!!] = hash!!
                            hashGenerationListener.onHashGenerated(hashMap)
                        }
                    }
                }

                override fun setWebViewProperties(webView: WebView?, bank: Any?) {
                }
            })
    }


    private fun getCheckoutProConfig(): PayUCheckoutProConfig {
        val checkoutProConfig = PayUCheckoutProConfig()
        checkoutProConfig.paymentModesOrder = getCheckoutOrderList()
        checkoutProConfig.offerDetails = getOfferDetailsList()
        checkoutProConfig.showCbToolbar = false
        checkoutProConfig.autoSelectOtp = false
        checkoutProConfig.autoApprove = false
        checkoutProConfig.surePayCount = 0
//        checkoutProConfig.cartDetails = reviewOrderAdapter?.getOrderDetailsList()
//        checkoutProConfig.showExitConfirmationOnPaymentScreen =
//            !binding.switchDiableCBDialog.isChecked
//        checkoutProConfig.showExitConfirmationOnCheckoutScreen =
//            !binding.switchDiableUiDialog.isChecked
//        checkoutProConfig.merchantName = binding.etMerchantName.text.toString()
//        checkoutProConfig.merchantLogo = R.drawable.merchant_logo
        checkoutProConfig.waitingTime = 3000
        checkoutProConfig.merchantResponseTimeout = 3000
        val noteDetails = ArrayList<PaymentType>()
        noteDetails.add(PaymentType.CARD)
        noteDetails.add(PaymentType.UPI)
        noteDetails.add(PaymentType.UPI_INTENT)
        val no = CustomNote("",noteDetails)
        val ar = ArrayList<CustomNote>()
        ar.add(no)
        checkoutProConfig.customNoteDetails = ar
        return checkoutProConfig
    }

    private fun getCheckoutOrderList(): ArrayList<PaymentMode> {
        val checkoutOrderList = ArrayList<PaymentMode>()
        checkoutOrderList.add(
            PaymentMode(
                PaymentType.UPI,
                PayUCheckoutProConstants.CP_GOOGLE_PAY
            )
        )
        checkoutOrderList.add(
            PaymentMode(
                PaymentType.WALLET,
                PayUCheckoutProConstants.CP_PHONEPE
            )
        )
        checkoutOrderList.add(
            PaymentMode(
                PaymentType.WALLET,
                PayUCheckoutProConstants.CP_PAYTM
            )
        )
        return checkoutOrderList
    }


    private fun getOfferDetailsList(): ArrayList<PayUOfferDetails> {
        return ArrayList()
    }
}