package com.tamarasdk

import android.app.Activity
import android.content.Intent
import android.os.Handler
import android.os.Looper
import android.widget.Toast
import com.facebook.react.bridge.BaseActivityEventListener
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReactContextBaseJavaModule
import com.facebook.react.bridge.ReactMethod
import com.google.gson.Gson

class TamaraSdkModule(reactContext: ReactApplicationContext) :
    ReactContextBaseJavaModule(reactContext), Tamara {

    private var _promise: Promise? = null

    private val activityEventListener =
        object : BaseActivityEventListener() {
            override fun onActivityResult(
                activity: Activity?,
                requestCode: Int,
                resultCode: Int,
                data: Intent?
            ) {
                when (requestCode) {
                    TamaraPayment.REQUEST_TAMARA_PAYMENT -> {
                        if (
                            TamaraPaymentHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraPaymentHelper.getData(data!!)
                            when (result?.status) {
                                PaymentResult.STATUS_CANCEL -> {
                                    _promise?.resolve("Payment canceled")
                                    Toast.makeText(activity, "Payment canceled", Toast.LENGTH_LONG)
                                        .show()
                                }
                                PaymentResult.STATUS_FAILURE -> {
                                    _promise?.resolve(result.getMessage() ?: "Payment error")
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Payment error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                }
                                PaymentResult.STATUS_SUCCESS -> {
                                    val checkout = TamaraPaymentHelper.checkOutSession(data)
                                    _promise?.resolve(Gson().toJson(checkout))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_ORDER_DETAIL -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    _promise?.resolve(result.getMessage() ?: "Order Detail error")
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val orderDetail =
                                        TamaraInformationHelper.getDataOrderDetail(data)
                                    _promise?.resolve(Gson().toJson(orderDetail))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_CAPTURE_PAYMENT -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Capture Payment error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                    _promise?.resolve(
                                        result.getMessage() ?: "Capture Payment error"
                                    )
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val capturePayment =
                                        TamaraInformationHelper.getDataCapturePayment(data)
                                    _promise?.resolve(Gson().toJson(capturePayment))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_REFUNDS -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Refunds error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                    _promise?.resolve(result.getMessage() ?: "Refunds error")
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val refunds = TamaraInformationHelper.getDataRefunds(data)
                                    _promise?.resolve(Gson().toJson(refunds))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_REFERENCE -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Order Reference error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val orderReference =
                                        TamaraInformationHelper.getOrderReference(data)
                                    _promise?.resolve(Gson().toJson(orderReference))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_CART_PAGE -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Cart page error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val cartPage = TamaraInformationHelper.getCartPage(data)
                                    _promise?.resolve(Gson().toJson(cartPage))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_PRODUCT -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Product error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val product = TamaraInformationHelper.getProduct(data)
                                    _promise?.resolve(Gson().toJson(product))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_CANCEL -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Cancel order error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val cancelOrder = TamaraInformationHelper.getCancelOrder(data)
                                    _promise?.resolve(Gson().toJson(cancelOrder))
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_AUTHORISE -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Authorise order error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val authorise = TamaraInformationHelper.getAuthoriseOrder(data)
                                    Handler(Looper.getMainLooper()).post {
                                        _promise?.resolve(Gson().toJson(authorise))
                                    }
                                }
                            }
                        }
                    }
                    TamaraPayment.REQUEST_TAMARA_PAYMENT_OPTIONS -> {
                        if (
                            TamaraInformationHelper.shouldHandleActivityResult(
                                requestCode,
                                resultCode,
                                data
                            )
                        ) {
                            var result = TamaraInformationHelper.getData(data!!)
                            when (result?.status) {
                                InformationResult.STATUS_FAILURE -> {
                                    Toast.makeText(
                                            activity,
                                            result.getMessage() ?: "Check payment availability error",
                                            Toast.LENGTH_LONG
                                        )
                                        .show()
                                }
                                InformationResult.STATUS_SUCCESS -> {
                                    val paymentOptions = TamaraInformationHelper.getPaymentOptions(data)
                                    Handler(Looper.getMainLooper()).post {
                                        _promise?.resolve(Gson().toJson(paymentOptions))
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

    init {
        reactContext.addActivityEventListener(activityEventListener)
    }

    override fun getName(): String {
        return "TamaraSdk"
    }

    /////
    @ReactMethod
    fun initSdk(
        authToken: String,
        apiUrl: String,
        notificationWebHook: String,
        publishKey: String,
        notificationToken: String,
        isSandbox: Boolean,
        promise: Promise
    ) {
        _promise = promise
        init(
            authToken,
            apiUrl,
            notificationWebHook,
            publishKey,
            notificationToken,
            isSandbox
        )
    }

    @ReactMethod
    fun startPayment(
        checkoutUrl: String,
        successCallbackUrl: String,
        failureCallbackUrl: String,
        cancelCallbackUrl: String,
        promise: Promise
    ) {
        _promise = promise
        paymentCheckout(checkoutUrl, successCallbackUrl, failureCallbackUrl, cancelCallbackUrl)
    }

    @ReactMethod
    fun orderDetail(orderId: String, promise: Promise) {
        _promise = promise
        getOrderDetail(orderId)
    }

    @ReactMethod
    fun capturePayment(jsonData: String, promise: Promise) {
        _promise = promise
        getCapturePayment(jsonData)
    }

    @ReactMethod
    fun createOrder(orderReferenceId: String, description: String, promise: Promise) {
        _promise = promise
        createOrder(orderReferenceId, description)
    }

    @ReactMethod
    fun setCountry(countryCode: String, currency: String, promise: Promise) {
        _promise = promise
        setCountry(countryCode, currency)
    }

    @ReactMethod
    fun setPaymentType(paymentType: String, promise: Promise) {
        _promise = promise
        setPaymentType(paymentType)
    }

    @ReactMethod
    fun setPlatform(platform: String, promise: Promise) {
        _promise = promise
        setPlatform(platform)
    }

    @ReactMethod
    fun setInstalments(instalments: Int, promise: Promise) {
        _promise = promise
        setInstalments(instalments)
    }

    @ReactMethod
    fun setLocale(locale: String, promise: Promise) {
        _promise = promise
        setLocale(locale)
    }

    @ReactMethod
    fun setOrderNumber(orderNumber: String, promise: Promise) {
        _promise = promise
        setOrderNumber(orderNumber)
    }

    @ReactMethod
    fun setExpiresInMinutes(expiresInMinutes: Int, promise: Promise) {
        _promise = promise
        setExpiresInMinutes(expiresInMinutes)
    }

    @ReactMethod
    fun setRiskAssessment(jsonData: String, promise: Promise) {
        _promise = promise
        val result =  setRiskAssessment(jsonData)
        promise.resolve(result)
    }

    @ReactMethod
    fun setAdditionalData(jsonData: String, promise: Promise) {
        _promise = promise
        setAdditionalData(jsonData)
    }

    @ReactMethod
    fun addCustomFieldsAdditionalData(jsonData: String, promise: Promise) {
        _promise = promise
        addCustomFieldsAdditionalData(jsonData)
    }

    @ReactMethod
    fun setCustomerInfo(
        firstName: String,
        lastName: String,
        phoneNumber: String,
        email: String,
        isFirstOrder: Boolean,
        promise: Promise
    ) {
        _promise = promise
        setCustomerInfo(firstName, lastName, phoneNumber, email, isFirstOrder)
    }

    @ReactMethod
    fun addItem(
        name: String,
        referenceId: String,
        sku: String,
        type: String,
        unitPrice: Double,
        tax: Double,
        discount: Double,
        quantity: Int,
        promise: Promise
    ) {
        _promise = promise
        addItem(name, referenceId, sku, type, unitPrice, tax, discount, quantity)
    }

    @ReactMethod
    fun setShippingAddress(
        firstName: String,
        lastName: String,
        phoneNumber: String,
        addressLine1: String,
        addressLine2: String,
        country: String,
        region: String,
        city: String,
        promise: Promise
    ) {
        _promise = promise
        setShippingAddress(
            firstName,
            lastName,
            phoneNumber,
            addressLine1,
            addressLine2,
            country,
            region,
            city
        )
    }

    @ReactMethod
    fun setBillingAddress(
        firstName: String,
        lastName: String,
        phoneNumber: String,
        addressLine1: String,
        addressLine2: String,
        country: String,
        region: String,
        city: String,
        promise: Promise
    ) {
        _promise = promise
        setBillingAddress(
            firstName,
            lastName,
            phoneNumber,
            addressLine1,
            addressLine2,
            country,
            region,
            city
        )
    }

    @ReactMethod
    fun setCurrency(newCurrency: String, promise: Promise) {
        _promise = promise
        setCurrency(newCurrency)
    }

    @ReactMethod
    fun setShippingAmount(amount: Double, promise: Promise) {
        _promise = promise
        setShippingAmount(amount)
    }

    @ReactMethod
    fun setDiscount(amount: Double, name: String, promise: Promise) {
        _promise = promise
        setDiscount(amount, name)
    }

    @ReactMethod
    fun paymentOrder(promise: Promise) {
        _promise = promise
        paymentOrder()
    }


    @ReactMethod
    fun checkPaymentOptions(jsonData: String, promise: Promise) {
        _promise = promise
        checkPaymentOptions(jsonData)
    }

    @ReactMethod
    fun refunds(orderId: String, jsonData: String, promise: Promise) {
        _promise = promise
        refunds(orderId, jsonData)
    }

    @ReactMethod
    fun cancelOrder(orderId: String, jsonData: String, promise: Promise) {
        _promise = promise
        cancelOrder(orderId, jsonData)
    }

    @ReactMethod
    fun updateOrderReference(orderId: String, orderReferenceId: String, promise: Promise) {
        _promise = promise
        updateOrderReference(orderId, orderReferenceId)
    }

    @ReactMethod
    fun renderCartPage(
        language: String,
        country: String,
        publicKey: String,
        amount: Double,
        promise: Promise
    ) {
        _promise = promise
        renderCartPage(language, country, publicKey, amount)
    }

    @ReactMethod
    fun renderProduct(
        language: String,
        country: String,
        publicKey: String,
        amount: Double,
        promise: Promise
    ) {
        _promise = promise
        renderProduct(language, country, publicKey, amount)
    }

    @ReactMethod
    fun authoriseOrder(orderId: String, promise: Promise) {
        _promise = promise
        authoriseOrder(orderId)
    }

    @ReactMethod
    fun clearItem(promise: Promise) {
        _promise = promise
        clearItem()
    }

    ////
    override fun init(
        authToken: String,
        apiUrl: String,
        notificationWebHook: String,
        publishKey: String,
        notificationToken: String,
        isSanbox: Boolean
    ) {
        TamaraPayment.initialize(
            authToken,
            apiUrl,
            notificationWebHook,
            publishKey,
            notificationToken,
            isSanbox
        )
    }

    override fun paymentCheckout(
        checkOutUrl: String,
        successCallbackUrl: String,
        failureCallbackUrl: String,
        cancelCallbackUrl: String
    ) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.startPayment(
            activity!!,
            checkOutUrl,
            successCallbackUrl,
            failureCallbackUrl,
            cancelCallbackUrl
        )
    }

    override fun getOrderDetail(orderId: String) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.getOrderDetail(activity!!, orderId)
    }

    override fun getCapturePayment(jsonData: String) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.getCapturePayment(activity!!, jsonData)
    }

    override fun createOrder(orderReferenceId: String, description: String) {
        TamaraPayment.createOrder(orderReferenceId, description)
    }

    override fun setCountry(countryCode: String, currency: String) {
        TamaraPayment.setCountry(countryCode, currency)
    }

    override fun setPaymentType(paymentType: String) {
        TamaraPayment.setPaymentType(paymentType)
    }

    override fun setPlatform(platform: String) {
        TamaraPayment.setPlatform(platform)
    }

    override fun setInstalments(instalments: Int) {
        TamaraPayment.setInstalments(instalments)
    }

    override fun setLocale(locale: String) {
        TamaraPayment.setLocale(locale)
    }

    override fun setOrderNumber(orderNumber: String) {
        TamaraPayment.setOrderNumber(orderNumber)
    }

    override fun setExpiresInMinutes(expiresInMinutes: Int) {
        TamaraPayment.setExpiresInMinutes(expiresInMinutes)
    }

    override fun setRiskAssessment(jsonData: String): Boolean  {
      val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
      return TamaraPayment.setRiskAssessment(jsonData, activity = activity)
    }

    override fun setAdditionalData(jsonData: String) {
        TamaraPayment.setAdditionalData(jsonData)
    }

    override fun addCustomFieldsAdditionalData(jsonData: String) {
        TamaraPayment.addCustomFieldsAdditionalData(jsonData)
    }

    override fun setCustomerInfo(
        firstName: String,
        lastName: String,
        phoneNumber: String,
        email: String,
        isFirstOrder: Boolean
    ) {
        TamaraPayment.setCustomerInfo(firstName, lastName, phoneNumber, email, isFirstOrder)
    }

    override fun addItem(
        name: String,
        referenceId: String,
        sku: String,
        type: String,
        unitPrice: Double,
        tax: Double,
        discount: Double,
        quantity: Int
    ) {
        TamaraPayment.addItem(name, referenceId, sku, type, unitPrice, tax, discount, quantity)
    }

    override fun setShippingAddress(
        firstName: String,
        lastName: String,
        phoneNumber: String,
        addressLine1: String,
        addressLine2: String,
        country: String,
        region: String,
        city: String
    ) {
        TamaraPayment.setShippingAddress(
            firstName,
            lastName,
            phoneNumber,
            addressLine1,
            addressLine2,
            country,
            region,
            city
        )
    }

    override fun setBillingAddress(
        firstName: String,
        lastName: String,
        phoneNumber: String,
        addressLine1: String,
        addressLine2: String,
        country: String,
        region: String,
        city: String
    ) {
        TamaraPayment.setBillingAddress(
            firstName,
            lastName,
            phoneNumber,
            addressLine1,
            addressLine2,
            country,
            region,
            city
        )
    }

    override fun setCurrency(newCurrency: String) {
        TamaraPayment.setCurrency(newCurrency)
    }

    override fun setShippingAmount(amount: Double) {
        TamaraPayment.setShippingAmount(amount)
    }

    override fun setDiscount(amount: Double, name: String) {
        TamaraPayment.setDiscount(amount, name)
    }

    override fun paymentOrder() {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.startPayment(activity!!)
    }

    override fun checkPaymentOptions(jsonData: String) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.checkPaymentOptions(activity!!, jsonData)
    }

    override fun refunds(orderId: String, jsonData: String) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.refunds(activity!!, orderId, jsonData)
    }

    override fun cancelOrder(orderId: String, jsonData: String) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.cancelOrder(activity!!, orderId, jsonData)
    }

    override fun updateOrderReference(orderId: String, orderReferenceId: String) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.updateOrderReference(activity!!, orderId, orderReferenceId)
    }

    override fun renderCartPage(
        language: String,
        country: String,
        publicKey: String,
        amount: Double
    ) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.renderWidgetCartPage(activity!!, language, country, publicKey, amount)
    }

    override fun renderProduct(
        language: String,
        country: String,
        publicKey: String,
        amount: Double
    ) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.renderWidgetProduct(activity!!, language, country, publicKey, amount)
    }

    override fun authoriseOrder(orderId: String) {
        val activity = currentActivity ?: throw IllegalStateException("Current activity is null")
        TamaraPayment.authoriseOrder(activity!!, orderId)
    }

    override fun clearItem() {
        TamaraPayment.clearItem()
    }
}