/**
 * Copyright © 2022 Anagog Ltd. All rights reserved.
 */

package com.jedaireactnativepackage.react_bridge

import com.anagog.jedai.anagog_api.AnagogApi
import com.anagog.jedai.common.ApplicationEvent
import com.anagog.jedai.common.poi.Point
import com.anagog.jedai.common.stats.TimeRange
import com.anagog.jedai.core.logger.JedAILogger
import com.anagog.jedai.core.sdk_state.SdkState
import com.facebook.react.bridge.*
import com.jedaireactnativepackage.utils.toReadableMap

private const val MODULE_NAME = "JedAIModule"

internal class JedaiModule(private val reactContext: ReactApplicationContext) :
  ReactContextBaseJavaModule(reactContext) {
  private val sLogger: JedAILogger by lazy { JedAILogger.getLogger("com.anagog.reactnativepackage.JedaiModule") }

  init {
    EventEmitter.init()
    reactContext.removeLifecycleEventListener(EventEmitter)
    reactContext.addLifecycleEventListener(EventEmitter)
    AnagogApi.removeEventListener(pluginAnagogMessageListener) //Remove previous listener if exists (This may happened when doing react app refresh - Cmnd+r in metro)
    AnagogApi.obtainEventStream(pluginAnagogMessageListener)
    AnagogApi.setBestMomentCallback(pluginBestMomentEventCallback)
    AnagogApi.bestMomentNotificationHandler(pluginBestMomentNotificationHandler)
  }

  override fun getName(): String {
    return MODULE_NAME
  }

  @ReactMethod
  fun fireMicromoment(microMoment: ReadableMap, resolver: Promise) {
    sLogger.info("fireMicromoment: $microMoment")
    val identifier = microMoment.getString("identifier") ?: return
    val appEvent = ApplicationEvent(identifier)
    val textParameter = microMoment.getMap("textParameters")
    val numericParameter = microMoment.getMap("numericParameters")
    val locationParameter = microMoment.getMap("locationParameters")
    val booleanParameters = microMoment.getMap("booleanParameters")


    textParameter?.entryIterator?.forEach { entry ->
      appEvent.addParameter(entry.key as String, entry.value as String)
    }

    numericParameter?.entryIterator?.forEach {
      appEvent.addParameter(it.key as String, (it.value as Double).toFloat())
    }

    booleanParameters?.entryIterator?.forEach { entry ->
      appEvent.addParameter(entry.key as String, (entry.value as Boolean))
    }

    locationParameter?.entryIterator?.forEach {
      val location = it.value as ReadableMap
      val latitude = location.getDouble("latitude")
      val longitude = location.getDouble("longitude")
      val point = Point(latitude, longitude)
      appEvent.addParameter(it.key as String, point)
    }

    sLogger.info("appEvent: $appEvent, ${appEvent.textParameters}, ${appEvent.numericParameters}, ${appEvent.locationParameters}")

    AnagogApi.fireMicromoment(appEvent, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }


  @ReactMethod
  fun logInfo(log: String) {
    sLogger.info(log)
  }

  @ReactMethod
  fun logError(log: String) {
    sLogger.error(log)
  }

  @ReactMethod
  fun syncCampaigns(resolver: Promise) {
    sLogger.info("syncCampaigns: ")

    AnagogApi.syncCampaigns(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun simulateCampaign(campaignIdentifier: String?, resolver: Promise) {
    sLogger.info("simulateCampaign: ")
    AnagogApi.simulateCampaign(campaignIdentifier, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun getVersion(resolver: Promise) {
    sLogger.info("getVersion: ")
    AnagogApi.getVersion(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(it)
    }
  }

  @ReactMethod
  fun setUserDefinedString(name: String, value: String?, resolver: Promise) {
    sLogger.info("JedAIModule: setUserDefinedString: name $name, value: $value")
    AnagogApi.setUserDefinedString(name, value, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun getUserDefinedString(name: String, resolver: Promise) {
    sLogger.info("JedAIModule: getUserDefinedString: name $name")
    AnagogApi.getUserDefinedString(name, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(it)
    }
  }

  @ReactMethod
  fun setUserDefinedInteger(name: String, value: Int, resolver: Promise) {
    sLogger.info("JedAIModule: setUserDefinedInteger: name $name, value: $value")
    AnagogApi.setUserDefinedInteger(name = name, value = value,
      onError = { resolver.reject(it) }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun getUserDefinedInteger(name: String, resolver: Promise) {
    sLogger.info("JedAIModule: getUserDefinedInteger: name $name")
    AnagogApi.getUserDefinedInteger(name, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(it)
    }
  }


  @ReactMethod
  fun setUserDefinedDecimal(name: String, value: Double, resolver: Promise) {
    sLogger.info("JedAIModule: setUserDefinedDecimal: name $name, value: $value")
    AnagogApi.setUserDefinedDecimal(name = name, value = value, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun getUserDefinedDecimal(name: String, resolver: Promise) {
    sLogger.info("JedAIModule: getUserDefinedDecimal: name $name")
    AnagogApi.getUserDefinedDecimal(name, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(it)
    }
  }

  @ReactMethod
  fun getStats(
    metricName: String,
    index1: String?,
    index2: String?,
    timeFrame: String?,
    resolver: Promise
  ) {
    val timeRange = timeFrame?.let {
      kotlin.runCatching { TimeRange.valueOf(it) }.getOrElse { TimeRange.OVERALL }
    }
    sLogger.info("getStats: name $metricName, index1: $index1, index2: $index2, timeFrame: $timeRange")

    AnagogApi.getStats(metricName, index1 = index1, index2 = null, timeRange = timeRange, onError = {
      resolver.reject(it)
    }) {
      sLogger.info("getStats:success: $it")
      val result = Arguments.createMap().also {  args ->
        args.putString("metricName", it?.name)
        args.putString("index1", it?.index1)
        args.putString("index2", it?.index2)

        it?.integerValue?.let { int ->
          args.putInt("integerValue", int)
        }
        it?.decimalValue?.let { dec ->
          args.putDouble("decimalValue", dec)
        }
      }
      resolver.resolve(result)
    }
  }

  @ReactMethod
  fun requestMicrosegmentsSnapshotReport(resolver: Promise) {
    sLogger.info("requestMicrosegmentsSnapshotReport: ")
    AnagogApi.requestMicrosegmentsSnapshotReport(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun requestEncodedEnrichmentReport(resolver: Promise) {
    sLogger.info("requestEncodedEnrichmentReport: ")
    AnagogApi.requestEncodedEnrichmentReport(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun exportDataEnrichment(requestedMetrics: ReadableArray?, resolver: Promise) {
    val metricsSet: List<String>? = requestedMetrics?.toArrayList()?.map { it.toString() }
    sLogger.info("exportDataEnrichment: $metricsSet")
    AnagogApi.exportDataEnrichment(metricsSet, onError = {
      resolver.reject(it)
    }) { metrics ->
      resolver.resolve(metrics?.toReadableMap())
    }
  }

  @ReactMethod
  fun forceScheduleReports(resolver: Promise) {
    sLogger.info("forceScheduleReports: ")
    AnagogApi.forceScheduleReports(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun sendUserInteractionEvent(
    campaignIdentifier: String,
    activityType: String,
    resolver: Promise
  ) {
    sLogger.info("sendUserInteractionEvent: campaignIdentifier: $campaignIdentifier, activityType: $activityType")
    AnagogApi.sendUserInteractionEvent(campaignIdentifier, activityType, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun streamIsReady() {
    sLogger.info("streamIsReady: ")
    EventEmitter.setStreamReady(true)
  }

  @ReactMethod
  fun getJedAIStatus(resolver: Promise) {
    sLogger.info("getJedAIStatus: ")
    AnagogApi.getJedAIStatus{
      resolver.resolve(it == SdkState.RUNNING)
    }
  }

  @ReactMethod
  fun getCampaigns(resolver: Promise) {
    sLogger.info("getCampaigns: ")
    val list = Arguments.createArray()
    AnagogApi.getCampaigns(onError = {
      resolver.reject(it)
    }) {
      it?.forEach { campaign ->
        val map = Arguments.createMap()
        map.putString("title", campaign["title"])
        map.putString("identifier", campaign["identifier"])
        list.pushMap(map)
      }
      resolver.resolve(list)
    }
  }

  @ReactMethod
  fun enableJedAI(resolver: Promise) {
    sLogger.info("enableJedAI: ")
    AnagogApi.startAnagogSdk()
    resolver.resolve(null)
  }

  @ReactMethod
  fun disableJedAI(resolver: Promise) {
    sLogger.info("disableJedAI: ")
    AnagogApi.stopAnagogSdk(false)
  }

  @ReactMethod
  fun disableAndPurgeJedAI(resolver: Promise) {
    sLogger.info("disableAndPurgeJedAI: ")
    AnagogApi.stopAnagogSdk(true)
  }

  /** OnBoarding ****/

  /**
   * OnBoarding start.
   * @param resolver Promise.
   */
  @ReactMethod
  fun onboardingStart(resolver: Promise) {
    sLogger.info("onboardingStart: ")
    AnagogApi.startOnboarding(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  /**
   * OnBoarding Completed.
   * @param resolver Promise.
   */
  @ReactMethod
  fun onboardingComplete(resolver: Promise) {
    sLogger.info("onboardingComplete: ")
    AnagogApi.onboardingCompleted(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  /**
   * OnBoarding Mark as Completed.
   * @param resolver Promise.
   */
  @ReactMethod
  fun onboardingMarkAsCompleted(resolver: Promise) {
    sLogger.info("onboardingMarkAsCompleted: ")
    AnagogApi.markAsCompletedOnboarding(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  /**
   * OnBoarding Rest.
   * @param resolver Promise.
   */
  @ReactMethod
  fun onboardingReset(resolver: Promise) {
    sLogger.info("onboardingReset: ")
    AnagogApi.resetOnboarding(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }


  // Page Visit

  /**
   * Enter page.
   * @param pageName Name of the page.
   * @param resolver Promise.
   */
  @ReactMethod
  fun enterPage(pageName: String, resolver: Promise) {
    sLogger.info("enterPage: $pageName")
    AnagogApi.enterPage(pageName = pageName, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  /**
   * Exit page.
   * @param resolver Promise.
   */
  @ReactMethod
  fun exitPage(resolver: Promise) {
    sLogger.info("exitPage: ")
    AnagogApi.exitPage(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  /** Debugging ****/
  @ReactMethod
  fun openDebuggingScreen(data: ReadableMap, resolver: Promise) {
    sLogger.info("openDebuggingScreen: data: $data")
    val debugScreenArgs = data.getString("version")?.let {
      mapOf("ReactNative Package Version" to it)
    }

    AnagogApi.openDebuggingScreen(reactContext.applicationContext, debugScreenArgs, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun shareFeedback(resolver: Promise) {
    sLogger.info("shareFeedback: ")
    AnagogApi.share(reactContext.applicationContext, onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(null)
    }
  }

  @ReactMethod
  fun generateFeedback(resolver: Promise) {
    sLogger.info("generateFeedback: ")
    AnagogApi.generateFeedback(onError = {
      resolver.reject(it)
    }) {
      resolver.resolve(it)
    }
  }

  /** Pns ****/

  /**
   * Forward Anagog FCM from host app to Anagog SDK.
   * @param resolver Promise.
   */
  @ReactMethod
  fun onPushNotificationReceived(data: ReadableMap, resolver: Promise) {
    sLogger.info("onPushNotificationReceived: data: ${data.toString()}")
    try {
      AnagogApi.onPushNotificationReceived(data.toHashMap() as Map<String, String>, onError = {
        resolver.reject(it)
      }) {
        resolver.resolve(true)
      }
    } catch (e: Throwable) {
      resolver.reject(e)
    }
  }
}