package com.qualtrics.reactdigital

import android.util.Log
import com.facebook.react.bridge.*
import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
import com.qualtrics.reactdigital.RNQualtricsDigitalSpec
import com.qualtrics.digital.*

class RNQualtricsDigitalModule internal constructor(context: ReactApplicationContext) :
  RNQualtricsDigitalSpec(context) {

  private var gInitializationResult: InitializationResult? = null
  private var gTargetingResult: TargetingResult? = null

  override fun getName(): String {
    return NAME
  }

  //region initialize
  @ReactMethod
  override fun initialize(brandId: String?, zoneId: String?, interceptId: String?) {
    Qualtrics.instance().initialize(brandId, zoneId, interceptId, reactApplicationContext)
  }

  @ReactMethod
  override fun initializeWithCompletion(brandId: String?, zoneId: String?, interceptId: String?) {
    Qualtrics.instance().initialize(brandId, zoneId, interceptId, reactApplicationContext) { initializationResult ->
      val initializeResult: WritableMap = Arguments.createMap()
      if (initializationResult != null) {
        gInitializationResult = initializationResult
        initializeResult.putBoolean("passed", initializationResult.passed())
        initializeResult.putString("message", initializationResult.message)
      }
      reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
        .emit(INITIALIZE_EVENT, initializeResult)
    }
  }

  @ReactMethod
  override fun initializeProject(brandId: String?, zoneId: String?, extRefId: String?) {
    Qualtrics.instance().initializeProject(brandId, zoneId, extRefId, reactApplicationContext) { initializationResult ->
      val initializeProjectResult = Arguments.createMap()
      for (interceptId in initializationResult.keys) {
        val resultMap = Arguments.createMap()
        val result = initializationResult[interceptId]
        resultMap.putBoolean("passed", result!!.passed())
        resultMap.putString("message", result.message)
        initializeProjectResult.putMap(interceptId, resultMap)
      }
      reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
        .emit(INITIALIZE_PROJECT_EVENT, initializeProjectResult)
    }
  }
  //endregion

  //region evaluate
  @ReactMethod
  override fun evaluateTargetingLogic() {
    val targetResult: WritableMap = Arguments.createMap()
    val initializeFailed = gInitializationResult != null && !gInitializationResult!!.passed()
    if (initializeFailed) {
      targetResult.putBoolean("passed", gInitializationResult!!.passed())
      targetResult.putString("surveyUrl", null)
      reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
        .emit(EVALUATE_EVENT, targetResult)
      return
    }
    Qualtrics.instance().evaluateTargetingLogic { targetingResult ->
      if (targetingResult != null) {
        gTargetingResult = targetingResult
        targetResult.putBoolean("passed", targetingResult.passed())
        targetResult.putString("surveyUrl", targetingResult.surveyUrl)
      }
      reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
        .emit(EVALUATE_EVENT, targetResult)
    }
  }

  @ReactMethod
  override fun evaluateProject() {
    val evaluateProjectResult: WritableMap = Arguments.createMap()
    Qualtrics.instance().evaluateProject { targetingResults ->
      for (interceptId in targetingResults.keys) {
        val resultMap: WritableMap = Arguments.createMap()
        val targetingResult = targetingResults[interceptId]
        val creativeTypeName = if (targetingResult!!.creativeType == null) null else targetingResult.creativeType.name
        resultMap.putBoolean("passed", targetingResult.passed())
        resultMap.putString("surveyUrl", targetingResult.surveyUrl)
        resultMap.putString("creativeType", creativeTypeName)
        resultMap.putString("targetingResultStatus", targetingResult.targetingResultStatus.toString())
        if (targetingResult.error != null) {
          resultMap.putString("error", targetingResult.error.message)
        }
        evaluateProjectResult.putMap(interceptId, resultMap)
      }
      reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
        .emit(EVALUATE_PROJECT_EVENT, evaluateProjectResult)
    }
  }

  @ReactMethod
  override fun evaluateIntercept(interceptId: String?) {
    val evaluateInterceptResult: WritableMap = Arguments.createMap()
    Qualtrics.instance().evaluateIntercept(interceptId) { targetingResult ->
      val creativeTypeName = if (targetingResult.creativeType == null) null else targetingResult.creativeType.name
      evaluateInterceptResult.putBoolean("passed", targetingResult.passed())
      evaluateInterceptResult.putString("surveyUrl", targetingResult.surveyUrl)
      evaluateInterceptResult.putString("creativeType", creativeTypeName)
      evaluateInterceptResult.putString("targetingResultStatus", targetingResult.targetingResultStatus.toString())
      if (targetingResult.error != null) {
        evaluateInterceptResult.putString("error", targetingResult.error.message)
      }
      reactApplicationContext.getJSModule(RCTDeviceEventEmitter::class.java)
        .emit(EVALUATE_INTERCEPT_EVENT, evaluateInterceptResult)
    }
  }
  //endregion

  //region display
  @ReactMethod
  override fun display(autoCloseSurvey: Boolean, callback: Callback) {
    val initializeFailed = gInitializationResult != null && !gInitializationResult!!.passed()
    if (initializeFailed) {
      callback.invoke(false)
      return
    }
    UiThreadUtil.runOnUiThread(Runnable {
      if (getCurrentActivity() != null) {
        val displayResult = Qualtrics.instance().display(getCurrentActivity(), autoCloseSurvey)
        if (displayResult) {
          gTargetingResult = null
        }
        callback.invoke(displayResult)
      } else {
        Log.w(TAG, "Display requires active activity")
        callback.invoke(false)
      }
    })
  }

  @ReactMethod
  override fun displayTarget(surveyUrl: String?, autoCloseSurvey: Boolean?, callback: Callback?) {
    UiThreadUtil.runOnUiThread(Runnable {
      val closeSurvey = autoCloseSurvey ?: false
      var displayTargetResult = false
      if (surveyUrl == null) {
        if (gTargetingResult != null && gTargetingResult!!.surveyUrl != null) {
          Qualtrics.instance().displayTarget(getCurrentActivity(), gTargetingResult!!.surveyUrl, closeSurvey)
          displayTargetResult = true
        }
      } else {
        try {
          Qualtrics.instance().displayTarget(getCurrentActivity(), surveyUrl, closeSurvey)
          displayTargetResult = true
        } catch (e: Exception) {
          Log.w(TAG, "DisplayTarget requires valid surveyUrl")
        }
      }
      callback?.invoke(displayTargetResult)
    })
  }

  @ReactMethod
  override fun displayIntercept(interceptId: String?, autoCloseSurvey: Boolean?, callback: Callback?) {
    UiThreadUtil.runOnUiThread(Runnable {
      val closeSurvey = autoCloseSurvey ?: false
      if (getCurrentActivity() != null) {
        val displayResult = Qualtrics.instance().displayIntercept(getCurrentActivity(), interceptId, 0, closeSurvey)
        callback?.invoke(displayResult)
      } else {
        Log.w(TAG, "Display requires active activity")
        callback?.invoke(false)
      }
    })
  }
  //endregion

  //region properties
  @ReactMethod
  override fun setString(key: String, value: String) {
    Qualtrics.instance().properties.setContext(reactApplicationContext)
    Qualtrics.instance().properties.setString(key, value)
  }

  @ReactMethod
  override fun setNumber(key: String, value: Double) {
    Qualtrics.instance().properties.setNumber(key, value)
  }

  @ReactMethod
  override fun setDateTime(key: String) {
    Qualtrics.instance().properties.setDateTime(key)
  }

  @ReactMethod
  override fun setLastDisplayTimeForIntercept(interceptId: String) {
    Qualtrics.instance().properties.setLastDisplayTimeForIntercept(interceptId)
  }

  @ReactMethod
  override fun setNotificationIconAsset(asset: String?) {
    val resID: Int = reactApplicationContext.getResources().getIdentifier(asset, "drawable", reactApplicationContext.getPackageName())
    Qualtrics.instance().properties.notificationIconAsset = resID
  }
  //endregion

  @ReactMethod
  override fun registerViewVisit(viewName: String?) {
    Qualtrics.instance().registerViewVisit(viewName)
  }

  @ReactMethod
  override fun resetTimer() {
    Qualtrics.instance().resetTimer()
  }

  @ReactMethod
  override fun resetViewCounter() {
    Qualtrics.instance().resetViewCounter()
  }

  @ReactMethod
  override fun recordClick() {
    if (gTargetingResult != null) {
      gTargetingResult?.recordClick()
    }
  }

  @ReactMethod
  override fun recordImpression() {
    if (gTargetingResult != null) {
      gTargetingResult?.recordImpression()
    }
  }

  @ReactMethod
  override fun getInitializedIntercepts(callback: Callback) {
    val writableArray: WritableArray = Arguments.createArray()
    val intercepts: List<String> = Qualtrics.instance().initializedIntercepts
    for (intercept in intercepts) {
      writableArray.pushString(intercept)
    }
    callback.invoke(writableArray)
  }

  @ReactMethod
  override fun getPassingIntercepts(callback: Callback) {
    val writableArray: WritableArray = Arguments.createArray()
    val intercepts: List<String> = Qualtrics.instance().passingIntercepts
    for (intercept in intercepts) {
      writableArray.pushString(intercept)
    }
    callback.invoke(writableArray)
  }

  companion object {
    const val NAME = "RNQualtricsDigital"
    private const val TAG = "Qualtrics"
    private const val EVALUATE_EVENT = "evaluateEvent"
    private const val INITIALIZE_EVENT = "initializeEvent"
    private const val INITIALIZE_PROJECT_EVENT = "initializeProjectEvent"
    private const val EVALUATE_PROJECT_EVENT = "evaluateProjectEvent"
    private const val EVALUATE_INTERCEPT_EVENT = "evaluateInterceptEvent"
  }
}