package com.paytmroutersdkreactnative

import android.os.Bundle
import android.text.TextUtils
import android.util.Log
import android.widget.Toast
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReactContextBaseJavaModule
import com.facebook.react.bridge.ReactMethod
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.WritableMap
import com.paytm.routersdk.RouterOrder
import com.paytm.routersdk.RouterTransactionCallback
import com.paytm.routersdk.RouterTransactionManager

class PaytmRouterSdkModule(reactContext: ReactApplicationContext) :
  ReactContextBaseJavaModule(reactContext) {

  private val ERROR_CODE = "0"
  private val PAYTM_CALLBACK_TAG = "PaytmCallback"

  override fun getName(): String {
    return NAME
  }

  // Example method
  // See https://reactnative.dev/docs/native-modules-android
  @ReactMethod
  fun multiply(a: Double, b: Double, promise: Promise) {
    promise.resolve(a * b)
  }

  @ReactMethod
  fun startTransaction(
    orderId: String?,
    mid: String?,
    txnToken: String?,
    amount: String?,
    callbackUrl: String?,
    isStaging: Boolean?,
    promise: Promise
  ) {

    if (TextUtils.isEmpty(orderId)
      || TextUtils.isEmpty(mid)
      || TextUtils.isEmpty(txnToken)
      || TextUtils.isEmpty(amount)
    ) {
      setErrorResponse("Transaction params missing", promise)
      Toast.makeText(reactApplicationContext, "Transaction params missing", Toast.LENGTH_LONG)
        .show()
      return
    }

    val baseUrl = "https://router.paytm.in"

    val paytmOrder = RouterOrder(
      orderId,
      mid,
      txnToken,
      amount,
      callbackUrl
    )

    val transactionManager = RouterTransactionManager(
      paytmOrder,
      object : RouterTransactionCallback {
        override fun onTransactionResponse(response: Bundle?) {
          Log.d(PAYTM_CALLBACK_TAG, "Transaction Response: $response")
          setResponse(getData(response ?: Bundle.EMPTY), promise)
        }

        override fun networkNotAvailable() {
          Log.d(PAYTM_CALLBACK_TAG, "Transaction response: network error")
          setErrorResponse("network not available", promise)
        }

        override fun onErrorProceed(error: String?) {
          Log.d(PAYTM_CALLBACK_TAG, "Transaction response: onErrorProceed $error")
          setErrorResponse(error ?: "some error", promise)
        }

        override fun someUIErrorOccurred(errorMsg: String?) {
          Log.d(PAYTM_CALLBACK_TAG, "Transaction response: someUIErrorOccurred $errorMsg")
          setErrorResponse(errorMsg ?: "some UI error", promise)
        }

        override fun onErrorLoadingWebPage(errorCode: Int, errorMsg: String?, failingUrl: String?) {
          Log.d(
            PAYTM_CALLBACK_TAG,
            "Transaction response: onErrorLoadingWebPage $errorCode $errorMsg $failingUrl"
          )
          setErrorResponse(errorMsg ?: "error loading web page", promise)
        }

        override fun onTransactionCancel(errorMsg: String?, response: Bundle?) {
          Log.d(PAYTM_CALLBACK_TAG, "Transaction response: onTransactionCancel $errorMsg $response")
          setErrorResponse(errorMsg ?: "transactionCancel", promise)
        }
      }
    )

    transactionManager.setCallingBridge("ReactNative")
    transactionManager.setStaging(isStaging?: false)
    transactionManager.startTransaction(currentActivity)
  }

  private fun setErrorResponse(message: String, promise: Promise) {
    promise.reject(ERROR_CODE, message)
  }

  private fun setResponse(data: WritableMap, promise: Promise) {
    promise.let {
      try {
        promise.resolve(data)
      } catch (e: Exception) {
        promise.reject(ERROR_CODE, e.message)
      }
    }
  }

  private fun getData(bundle: Bundle): WritableMap {
    val data = Arguments.createMap()
    for (key in bundle.keySet()) {
      data.putString(key, bundle.getString(key, ""))
    }
    return data
  }

  companion object {
    const val NAME = "PaytmRouterSdk"
  }
}