package com.onramp

import com.buyhatke.onrampsdk.OnrampSDK
import com.buyhatke.onrampsdk.listeners.OnrampSDKEventListener
import com.buyhatke.onrampsdk.ui.WidgetResponse
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.ReadableMap
import com.facebook.react.bridge.WritableMap
import com.facebook.react.bridge.WritableNativeMap
import com.facebook.react.modules.core.DeviceEventManagerModule
import com.google.gson.Gson
import java.util.Objects
import org.json.JSONException
import org.json.JSONObject

class OnrampModule(private val reactContext: ReactApplicationContext) :
        ReactContextBaseJavaModule(reactContext), OnrampSDKEventListener {

    override fun getName(): String {
        return NAME
    }
    companion object {
        const val NAME = "OnrampSDK"
    }

    private fun sendEvent(eventName: String, params: WritableMap?) {
        reactContext
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                .emit(eventName, params)
    }

    private fun readableMapToMap(readableMap: ReadableMap): Map<String, Any?> {
        val map = mutableMapOf<String, Any?>()
        val iterator = readableMap.keySetIterator()
        while (iterator.hasNextKey()) {
            val key = iterator.nextKey()
            when (readableMap.getType(key)) {
                com.facebook.react.bridge.ReadableType.Null -> map[key] = null
                com.facebook.react.bridge.ReadableType.Boolean -> map[key] = readableMap.getBoolean(key)
                com.facebook.react.bridge.ReadableType.Number -> {
                    // Convert numbers to strings for native SDK
                    val doubleVal = readableMap.getDouble(key)
                    map[key] = if (doubleVal == doubleVal.toLong().toDouble()) {
                        doubleVal.toLong().toString()
                    } else {
                        doubleVal.toString()
                    }
                }
                com.facebook.react.bridge.ReadableType.String -> map[key] = readableMap.getString(key)
                com.facebook.react.bridge.ReadableType.Map -> map[key] = readableMapToMap(readableMap.getMap(key)!!)
                com.facebook.react.bridge.ReadableType.Array -> map[key] = readableMap.getArray(key)?.toArrayList()
            }
        }
        return map
    }

    @ReactMethod
    fun startSdk(args: ReadableMap) {
        val params = readableMapToMap(args)
        OnrampSDK.startOnrampSDK(reactApplicationContext, params)
        OnrampSDK.registerOnrampSDKEventListener(this)
    }

    @ReactMethod
    fun startOnrampLogin(args: ReadableMap) {
        val params = readableMapToMap(args)
        OnrampSDK.startOnrampLogin(reactApplicationContext, params)
        OnrampSDK.registerOnrampSDKEventListener(this)
    }

    @ReactMethod
    fun initiateOnrampKyc(args: ReadableMap) {
        val params = readableMapToMap(args)
        OnrampSDK.initiateOnrampKyc(reactApplicationContext, params)
        OnrampSDK.registerOnrampSDKEventListener(this)
    }

    @ReactMethod
    fun closeSdk() {
        OnrampSDK.stopOnrampSDK()
    }

    @Throws(JSONException::class)
    private fun convertJsonToMap(jsonObject: JSONObject): WritableMap? {
        val map: WritableMap = WritableNativeMap()
        val iterator = jsonObject.keys()
        while (iterator.hasNext()) {
            val key = iterator.next()
            val value = jsonObject.opt(key)

            when (value) {
                is JSONObject -> {
                    map.putMap(key, convertJsonToMap(value))
                }
                is Boolean -> {
                    map.putBoolean(key, value)
                }
                is Int -> {
                    map.putInt(key, value)
                }
                is Double -> {
                    map.putDouble(key, value)
                }
                is String -> {
                    map.putString(key, value)
                }
                null -> {
                    map.putNull(key)
                }
                else -> {
                    map.putString(key, value.toString())
                }
            }
        }

        return map
    }

    override fun onDataReceived(data: WidgetResponse) {
        val resultMap = Arguments.createMap()
        val g = Gson()
        resultMap.putString("type", Objects.requireNonNull(data).type)
        resultMap.putBoolean("isOnramp", Objects.requireNonNull(data).isOnramp)
        val jo = JSONObject(g.toJson(data.data))
        val wm = convertJsonToMap(jo)
        resultMap.putMap("data", wm)
        sendEvent("widgetEvents", resultMap)
    }

    @ReactMethod
    fun addListener(eventName: String) {
        // Keep: Required for RN built in Event Emitter Calls.
    }

    @ReactMethod
    fun removeListeners(count: Int) {
        // Keep: Required for RN built in Event Emitter Calls.
    }
}