package com.rookandroidtransmission

import android.util.Log
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.rookmotion.rook.transmission.RookTransmissionManager

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
import com.facebook.react.bridge.ReadableMap
import com.rookandroidtransmission.transformations.EncodeBloodGlocoseEventItem
import com.rookandroidtransmission.transformations.EncodeBloodPressureEvent
import com.rookandroidtransmission.transformations.EncodeBodyMetricsEvent
import com.rookandroidtransmission.transformations.EncodeBodySummaryItem
import com.rookandroidtransmission.transformations.EncodeHeartRateEventItem
import com.rookandroidtransmission.transformations.EncodeHydrationEventItem
import com.rookandroidtransmission.transformations.EncodeMoodEventItem
import com.rookandroidtransmission.transformations.EncodeNutritionEvent
import com.rookandroidtransmission.transformations.EncodeOxygenationEventItem
import com.rookandroidtransmission.transformations.EncodePhysicalEventItem
import com.rookandroidtransmission.transformations.EncodePhysicalSummaryItem
import com.rookandroidtransmission.transformations.EncodeSleepSummaryItem
import com.rookandroidtransmission.transformations.EncodeStressEventItem
import com.rookandroidtransmission.transformations.EncodeTemperatureEventItem
import com.rookmotion.rook.transmission.RookTransmissionConfiguration
import com.rookmotion.rook.transmission.domain.environment.RookTransmissionAndroidClass
import com.rookmotion.rook.transmission.domain.environment.RookTransmissionEnvironment

class RookAndroidTransmissionModule(reactContext: ReactApplicationContext) :
  ReactContextBaseJavaModule(reactContext) {

  override fun getName(): String {
    return NAME
  }

  private var manager: RookTransmissionManager? = null
  private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)

  private fun checkManager() {
    if (manager !== null) Throwable("First init the transmission manager")
  }

  @ReactMethod
  fun isRookTransmissionAlreadyInitialized(promise: Promise) {
    if (manager !== null) {
      promise.resolve(true)
      return
    }
    else promise.resolve(false)
  }

  @ReactMethod
  fun initManager(config: ReadableMap, promise: Promise) {
    if (manager !== null) {
      promise.resolve(true)
      return
    }

    scope.launch {

      var environment = RookTransmissionEnvironment.SANDBOX

      if (config.getString("environment") == "production")
        environment = RookTransmissionEnvironment.PRODUCTION

      if (config.getString("environment") == "development") RookTransmissionAndroidClass.test()
      else RookTransmissionAndroidClass.disableTest()

      val result = RookTransmissionConfiguration.initRookTransmission(
        reactApplicationContext,
        clientUUID = config.getString("clientUUID") ?: "",
        environment = environment,
        enableLogs = true
      )

      result.fold({

        manager = RookTransmissionManager(
          reactApplicationContext,
          clientUUID = config.getString("clientUUID") ?: "",
          userID = config.getString("userID") ?: "",
          secretKey = config.getString("password") ?: "",
        )

        promise.resolve(true)
      }, {
        if (it is NullPointerException) {
          promise.reject(Throwable("Unauthorized please check yours credentials"))
        }
        else promise.reject(it)
      })
    }
  }

  @ReactMethod
  fun updateUserTimeZone(timezone: ReadableMap, promise: Promise){
    scope.launch {
      try {
        checkManager()

        val zone = timezone.getString("timezone") ?: "UTC"
        val offset = timezone.getInt("offset")

        manager?.uploadUserTimeZone(zone, offset)

        promise.resolve(true)
      }
      catch (e: Error) {
        promise.reject(e)
      }
    }
  }

  /* Sleep Methods */
  @ReactMethod
  fun enqueueSleepSummary(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val sleepItem = EncodeSleepSummaryItem.fromReadableMap(item)

        sleepItem.sleepStartDateTime.toLocalDate()

        var result = manager?.enqueueSleepSummary(sleepItem)

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadSleepSummaries(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadSleepSummaries()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedSleepSummaries(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedSleepSummaries()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  /* Body Methods */
  @ReactMethod
  fun enqueueBodySummary(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var bodySummaryItem = EncodeBodySummaryItem.fromReadableMap(item)

        var result = manager?.enqueueBodySummary(bodySummaryItem)

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedBodySummaries(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedBodySummaries()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadBodySummaries(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadBodySummaries()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }
  /* Physical Methods */
  @ReactMethod
  fun enqueuePhysicalSummary(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val physicalSummaryItem = EncodePhysicalSummaryItem.fromReadableMap(item)
        var result = manager?.enqueuePhysicalSummary(physicalSummaryItem)

        promise.resolve(true)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedPhysicalSummaries(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedPhysicalSummaries()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadPhysicalSummaries(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadPhysicalSummaries()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueuePhysicalEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val physicalEventItem = EncodePhysicalEventItem.fromReadableMap(item)

       var result = manager?.enqueuePhysicalEvent(physicalEventItem)
        promise.resolve(true)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedPhysicalEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedPhysicalEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadPhysicalEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadPhysicalEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueBloodGlucoseEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val bloodGlucoseEventItem = EncodeBloodGlocoseEventItem.fromReadableMap(item)

        var result = manager?.enqueueBloodGlucoseEvent(bloodGlucoseEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadBloodGlucoseEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadBloodGlucoseEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedBloodGlucoseEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedBloodGlucoseEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueBloodPressureEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val bloodPressureEventItem = EncodeBloodPressureEvent.fromReadableMap(item)

        var result = manager?.enqueueBloodPressureEvent(bloodPressureEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadBloodPressureEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadBloodPressureEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedBloodPressureEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedBloodPressureEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueBodyMetricsEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val bodyMetricsEventItem = EncodeBodyMetricsEvent.fromReadableMap(item)

        var result = manager?.enqueueBodyMetricsEvent(bodyMetricsEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadBodyMetricsEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadBodyMetricsEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedBodyMetricsEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedBodyMetricsEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueHeartRateEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val heartRateEventItem = EncodeHeartRateEventItem.fromReadableMap(item)

        var result = manager?.enqueueHeartRateEvent(heartRateEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadHeartRateEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadHeartRateEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedHeartRateEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedHeartRateEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueHydrationEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val hydrationEventItem = EncodeHydrationEventItem.fromReadableMap(item)

        var result = manager?.enqueueHydrationEvent(hydrationEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadHydrationEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadHydrationEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedHydrationEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedHydrationEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueMoodEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val moodEventItem = EncodeMoodEventItem.fromReadableMap(item)

        var result = manager?.enqueueMoodEvent(moodEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadMoodEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadMoodEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedMoodEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedMoodEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueNutritionEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val nutritionEventItem = EncodeNutritionEvent.fromReadableMap(item)

        var result = manager?.enqueueNutritionEvent(nutritionEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadNutritionEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadNutritionEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedNutritionEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedNutritionEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueOxygenationEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val oxygenationEventItem = EncodeOxygenationEventItem.fromReadableMap(item)

        var result = manager?.enqueueOxygenationEvent(oxygenationEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadOxygenationEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadOxygenationEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedOxygenationEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedOxygenationEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun enqueueStressEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val stressEventItem = EncodeStressEventItem.fromReadableMap(item)

        var result = manager?.enqueueStressEvent(stressEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadStressEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadStressEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedStressEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedStressEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

 @ReactMethod
  fun enqueueTemperatureEvent(item: ReadableMap, promise: Promise) {
    scope.launch {
      try {

        checkManager()

        val temperatureEventItem = EncodeTemperatureEventItem.fromReadableMap(item)

        var result = manager?.enqueueTemperatureEvent(temperatureEventItem)

        promise.resolve(result)

      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun uploadTemperatureEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.uploadTemperatureEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  @ReactMethod
  fun clearQueuedTemperatureEvents(promise: Promise) {
    scope.launch {
      try {

        checkManager()

        var result = manager?.clearQueuedTemperatureEvents()

        promise.resolve(result)
      }
      catch(e: Exception) {
        promise.reject(e)
      }
    }
  }

  companion object {
    const val NAME = "RookAndroidTransmission"
  }
}