package com.checkoutreactnativecomponents

import android.content.Context
import com.checkout.components.interfaces.model.ApiCallResult
import com.checkout.components.interfaces.model.CallbackResult
import com.checkout.components.interfaces.model.paymentsession.PaymentAction
import com.checkout.components.interfaces.model.paymentsession.PaymentSessionSubmissionResult

import com.checkoutreactnativecomponents.utils.Constants
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReadableMap

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

public object CheckoutModuleHandler {
    private val moduleScope = CoroutineScope(Dispatchers.Main)

    public fun initialize(args: ReadableMap, context: Context, promise: Promise) {
        val publicKey = args.getString(Constants.PUBLIC_KEY) ?: return promise.reject(
            NAME,
            "Missing required parameter: ${Constants.PUBLIC_KEY}",
        )

        val environment = args.getString(Constants.ENVIRONMENT) ?: return promise.reject(
            NAME,
            "Missing required parameter: ${Constants.ENVIRONMENT}",
        )

        val paymentSession = args.getMap(Constants.PAYMENT_SESSION) ?: return promise.reject(
            NAME,
            "Missing required parameter: ${Constants.PAYMENT_SESSION}",
        )

        val paymentSessionId = paymentSession.getString(Constants.PAYMENT_SESSION_ID) ?: return promise.reject(
            NAME,
            "Missing required parameter: ${Constants.PAYMENT_SESSION} -> ${Constants.PAYMENT_SESSION_ID}",
        )

        val paymentSessionSecret = paymentSession.getString(Constants.PAYMENT_SESSION_SECRET) ?: return promise.reject(
            NAME,
            "Missing required parameter: ${Constants.PAYMENT_SESSION} -> ${Constants.PAYMENT_SESSION_SECRET}",
        )

        val registeredCallbacks = args.getArray(Constants.REGISTERED_CALLBACKS)?.toArrayList()?.mapNotNull { it.toString() } ?: emptyList()
        CheckoutManager.callbacks = registeredCallbacks
        CheckoutManager.setPublicKey(publicKey)
        CheckoutManager.setEnvironment(environment)
        CheckoutManager.setPaymentSession(paymentSessionId, paymentSessionSecret)

        args.getString(Constants.LOCALE)?.let {
            CheckoutManager.setLocale(it)
        }

        args.getMap(Constants.TRANSLATIONS)?.let {
            CheckoutManager.setTranslations(it)
        }

        args.getMap(Constants.STYLE)?.let {
            CheckoutManager.setAppearance(it)
        }

        moduleScope.launch {
            try {
                CheckoutManager.initializeSDK(context)
                promise.resolve(true)
            } catch (e: Exception) {
                promise.reject(NAME, e.message, e)
            }
        }
    }

    public fun clear(promise: Promise) {
        CheckoutManager.clear()
        promise.resolve(true)
    }

    public fun resolveTokenized(callbackId: String, success: Boolean, error: String? = null, promise: Promise) {
        val result = if (success) CallbackResult.Accepted else CallbackResult.Rejected(error)
        CheckoutManager.resolveCallback(callbackId, result)
        promise.resolve(null)
    }

    public fun resolveSubmit(callbackId: String, args: ReadableMap, promise: Promise) {
        if (!args.hasKey(Constants.HANDLE_SUBMIT_SUCCESS)) {
            CheckoutManager.cancelCallback(Constants.HANDLE_SUBMIT_ID)
            promise.reject(NAME, "Missing required parameter: ${Constants.HANDLE_SUBMIT_SUCCESS}")
            return
        }
        val result = if (args.getBoolean(Constants.HANDLE_SUBMIT_SUCCESS)) {
            if (!args.hasKey(Constants.PAYMENT_SESSION_SUBMISSION_RESULT)) {
                CheckoutManager.cancelCallback(Constants.HANDLE_SUBMIT_ID)
                promise.reject(
                    NAME,
                    "Missing required parameter: ${Constants.PAYMENT_SESSION_SUBMISSION_RESULT}",
                )
                return
            }
            val paymentSessionSubmissionResultMap = args.getMap(Constants.PAYMENT_SESSION_SUBMISSION_RESULT)

            if (paymentSessionSubmissionResultMap != null &&
               ( !paymentSessionSubmissionResultMap.hasKey(Constants.PAYMENT_SESSION_SUBMISSION_ID) ||
                !paymentSessionSubmissionResultMap.hasKey(Constants.PAYMENT_SESSION_SUBMISSION_TYPE) ||
                !paymentSessionSubmissionResultMap.hasKey(Constants.PAYMENT_SESSION_SUBMISSION_STATUS))
            ) {
                CheckoutManager.cancelCallback(Constants.HANDLE_SUBMIT_ID)
                promise.reject(
                    NAME,
                    "Missing required parameters for: ${Constants.PAYMENT_SESSION_SUBMISSION_RESULT}",
                )
                return
            }

            val paymentSessionSubmissionResult = paymentSessionSubmissionResultMap?.let { resultMap ->
                PaymentSessionSubmissionResult(
                    id = resultMap.getString(Constants.PAYMENT_SESSION_SUBMISSION_ID) ?: "",
                    type = resultMap.getString(Constants.PAYMENT_SESSION_SUBMISSION_TYPE) ?: "",
                    status = resultMap.getString(Constants.PAYMENT_SESSION_SUBMISSION_STATUS) ?: "",
                    action = resultMap.getMap(Constants.PAYMENT_SESSION_SUBMISSION_PAYMENT_ACTION)?.let { actionMap ->
                        PaymentAction(
                            type = actionMap.getString(Constants.PAYMENT_SESSION_SUBMISSION_PAYMENT_ACTION_TYPE) ?: "",
                            url = actionMap.getString(Constants.PAYMENT_SESSION_SUBMISSION_PAYMENT_ACTION_URL),
                        )
                    },
                    declineReason = resultMap.getString(Constants.PAYMENT_SESSION_RESULT_DECLINE_REASON),
                )
            } ?: run {
                CheckoutManager.cancelCallback(Constants.HANDLE_SUBMIT_ID)
                promise.reject(
                    NAME,
                    "Missing required parameter: ${Constants.PAYMENT_SESSION_SUBMISSION_RESULT}",
                )
                return
            }
            ApiCallResult.Success(paymentSessionSubmissionResult)
        } else ApiCallResult.Failure

        CheckoutManager.resolveCallback(callbackId, result)
        promise.resolve(null)
    }

    internal const val NAME = Constants.CHECKOUT_MODULE_HANDLER
}