package com.reactnativegeouniq

import android.content.Context
import androidx.annotation.NonNull
import com.facebook.react.ReactApplication
import com.facebook.react.bridge.*
import com.facebook.react.modules.core.DeviceEventManagerModule
import com.geouniq.android.GeoUniq

class GeouniqModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {

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

    @ReactMethod
    fun enable(successCallback: Callback) {
        GeoUniq.getInstance(reactContext).enable()
        successCallback.invoke()
    }

    @ReactMethod
    fun disable(successCallback: Callback) {
        GeoUniq.getInstance(reactContext).disable()
        successCallback.invoke()
    }

    @ReactMethod
    fun showPrivacyPolicyAndSet(errorCallback: Callback, successCallback: Callback) {
        if (currentActivity == null) {
            errorCallback.invoke("Current activity is null")
            return
        }

        GeoUniq.getInstance(reactContext).showPrivacyPolicyAndSet(currentActivity!!) { iConsentsMap: GeoUniq.IConsentsMap ->
            val writableMap = WritableNativeMap()
            GeoUniq.ConsentItem.values().forEach { item ->
                writableMap.putBoolean(item.name, iConsentsMap.get(item))
            }
            successCallback.invoke(writableMap)
        }
    }

    @ReactMethod
    fun showPrivacyPolicySwitchesAndSet(errorCallback: Callback, successCallback: Callback) {
        if (currentActivity == null) {
            errorCallback.invoke("Current activity is null")
            return
        }

        GeoUniq.getInstance(reactContext).showPrivacyPolicySwitchesAndSet(currentActivity!!) { iConsentsMap: GeoUniq.IConsentsMap ->
            val writableMap = WritableNativeMap()
            GeoUniq.ConsentItem.values().forEach { item ->
                writableMap.putBoolean(item.name, iConsentsMap.get(item))
            }
            successCallback.invoke(writableMap)

        }
    }

    @ReactMethod
    fun getPrivacyConsentsMap(errorCallback: Callback, successCallback: Callback) {
        if (currentActivity == null) {
            errorCallback.invoke("Current activity is null")
            return
        }
        val privacyConsentsMap = GeoUniq.getInstance(reactContext).privacyConsentsMap
        val writableMap: WritableMap = WritableNativeMap()
        for (item in GeoUniq.ConsentItem.values()) {
            writableMap.putBoolean(item.name, privacyConsentsMap[item])
        }
        successCallback.invoke(writableMap)
    }

    @ReactMethod
    private fun setPrivacyConsent(consentName: String, status: Boolean, errorCallback: Callback, successCallback: Callback) {
        var consentItem: GeoUniq.ConsentItem? = null
        try {
            consentItem = GeoUniq.ConsentItem.valueOf(consentName)
        } catch (ignored: Exception) {
        }
        if (consentItem != null) {
            GeoUniq.getInstance(reactContext).setPrivacyConsent(consentItem, status)
            successCallback.invoke()
        } else {
            errorCallback.invoke("Wrong consent name")
        }
    }

    @ReactMethod
    private fun getPrivacyConsent(consentName: String, errorCallback: Callback, successCallback: Callback) {
        var consentItem: GeoUniq.ConsentItem? = null
        try {
            consentItem = GeoUniq.ConsentItem.valueOf(consentName)
        } catch (ignored: Exception) {
        }
        if (consentItem != null) {
            val privacyConsent = GeoUniq.getInstance(reactContext).getPrivacyConsent(consentItem)
            successCallback.invoke(privacyConsent)
        } else {
            errorCallback.invoke("Wrong consent name")
        }
    }

    @ReactMethod
    fun showConsentDialogAndSet(errorCallback: Callback, successCallback: Callback) {
        if (currentActivity == null) {
            errorCallback.invoke("Current activity is null")
            return
        }
        GeoUniq.getInstance(reactContext).showPrivacyPolicyAndSet(currentActivity!!) { b -> successCallback.invoke(b) }
    }

    @ReactMethod
    private fun setConsentStatus(status: Boolean, successCallback: Callback) {
        GeoUniq.getInstance(reactContext).setPrivacyConsent(GeoUniq.ConsentItem.ANALYSIS, status)
        GeoUniq.getInstance(reactContext).setPrivacyConsent(GeoUniq.ConsentItem.CUSTOMIZATION_AND_ADTARGETING, status)
        successCallback.invoke()
    }

    @ReactMethod
    private fun getConsentStatus(successCallback: Callback) {
        val analysisStatus = GeoUniq.getInstance(reactContext).getPrivacyConsent(GeoUniq.ConsentItem.ANALYSIS)
        val adTargetingStatus = GeoUniq.getInstance(reactContext).getPrivacyConsent(GeoUniq.ConsentItem.CUSTOMIZATION_AND_ADTARGETING)
        val consentStatus = analysisStatus || adTargetingStatus
        successCallback.invoke(consentStatus)
    }

    @ReactMethod
    private fun setDeviceIdListener(successCallback: Callback) {
        GeoUniq.getInstance(reactContext).setDeviceIdListener { deviceID -> successCallback.invoke(deviceID) }
    }

    @ReactMethod
    private fun getDeviceId(successCallback: Callback) {
        val deviceId = GeoUniq.getInstance(reactContext).deviceId
        successCallback.invoke(deviceId)
    }

    @ReactMethod
    private fun isDeviceIdAvailable(errorCallback: Callback, successCallback: Callback) {
        if (currentActivity == null) {
            errorCallback.invoke("Current activity is null")
            return
        }
        val isDeviceIdAvailable = GeoUniq.getInstance(reactContext).isDeviceIdAvailable
        successCallback.invoke(isDeviceIdAvailable)
    }

    @ReactMethod
    private fun setCustomId(customId: String, successCallback: Callback) {
        val isSet = GeoUniq.getInstance(reactContext).setCustomId(customId)
        successCallback.invoke(customId, isSet)
    }

    @ReactMethod
    private fun solveIssues(errorCallback: Callback, successCallback: Callback) {
        GeoUniq.getInstance(reactContext).setErrorListener(GeoUniq.IErrorListener { requestResult ->
            if (currentActivity == null) {
                errorCallback.invoke("Current activity is null")
                return@IErrorListener
            }
            if (requestResult.hasResolution()) {
                requestResult.startResolution(currentActivity)
            } else {
                successCallback.invoke()
            }
        })
    }

    @ReactMethod
    private fun getSdkVersion(callback: Callback) {
        callback.invoke(GeoUniq.SDK_VERSION)
    }

    @ReactMethod
    private fun setGeoFence(name: String, latitude: Double, longitude: Double, radius: Double, callback: Callback) {
        val geoPoint = GeoUniq.GeoPoint(latitude, longitude)
        val area = GeoUniq.CircularArea(name, geoPoint, radius)
        val builder = GeoUniq.GeoFence.Builder()
        val geofence = builder
                .setArea(area)
                .setCallbackClass(GeoFencesListener::class.java)
                .create()

        val geoFenceId = GeoUniq.getInstance(reactContext).setGeoFence(geofence)
        callback.invoke(geoFenceId)
    }

    @ReactMethod
    private fun removeGeoFence(geofenceId: String, callback: Callback) {
        val removed = GeoUniq.getInstance(reactContext).removeGeoFence(geofenceId)
        if (removed) {
            callback.invoke(geofenceId)
        } else {
            callback.invoke(geofenceId)
        }
    }

    class GeoFencesListener : GeoUniq.GeoFenceListener {
        override fun onStatusChanged(@NonNull context: Context, @NonNull geoFence: GeoUniq.GeoFence) {
            if (context.applicationContext is ReactApplication) {
                val params = Arguments.createMap()
                params.putString(geoFence.id, geoFence.status.name)
                (context.applicationContext as ReactApplication)
                        .reactNativeHost
                        .reactInstanceManager
                        .currentReactContext
                        ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                        ?.emit("GeoUniqGeofenceUpdate", params)
            }
        }
    }
}