package com.rookandroidtransmission.transformations

import com.facebook.react.bridge.ReadableArray
import com.facebook.react.bridge.ReadableMap
import com.rookmotion.rook.transmission.domain.model.granular.BloodGlucoseGranularDataMgPerDlNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.BloodPressureDaySystolicDiastolicBpNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.BloodPressureGranularDataSystolicDiastolicBpNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.HrGranularDataBpmItem
import com.rookmotion.rook.transmission.domain.model.granular.HrvRmssdGranularDataNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.HrvSdnnGranularDataNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.HydrationAmountGranularDataMlNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.HydrationLevelGranularDataPercentageNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.MenstruationFlowMlGranularDataNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.MoodGranularDataScaleItem
import com.rookmotion.rook.transmission.domain.model.granular.SaturationGranularDataPercentageItem
import com.rookmotion.rook.transmission.domain.model.granular.TemperatureGranularDataCelsiusItem
import com.rookmotion.rook.transmission.domain.model.granular.TemperatureItem
import com.rookmotion.rook.transmission.domain.model.granular.Vo2GranularDataMlPerMinItem
import com.rookmotion.rook.transmission.domain.model.summary.BodySummaryItem
import java.lang.reflect.ParameterizedType
import java.time.LocalDate
import java.time.ZonedDateTime

object EncodeBodySummaryItem {

  fun fromReadableMap(readableMap: ReadableMap): BodySummaryItem {

    var clazz = BodySummaryItem::class.java

    val instance = BodySummaryItem(
       dateTime =  ZonedDateTime.now(),
       sourceOfData = "HC",
    )

    var keys = readableMap.keySetIterator()

    while(keys.hasNextKey()) {
      val fieldName = keys.nextKey()
      val fieldValue = readableMap.getDynamic(fieldName)

      try {

        val field = clazz.getDeclaredField(fieldName)
        field.isAccessible = true

        when {

          field.type == String::class.java -> field.set(instance, fieldValue.asString())
          field.type == Integer::class.java-> field.set(instance, fieldValue.asInt())
          field.type == Int::class.java -> field.set(instance, fieldValue.asInt())
          field.type == Double::class.java -> field.set(instance, fieldValue.asDouble())
          field.type == Double::class.javaObjectType -> field.set(instance, fieldValue.asDouble())
          field.type == Boolean::class.java -> field.set(instance, fieldValue.asBoolean())
          field.type == Boolean::class.javaObjectType -> field.set(instance, fieldValue.asBoolean())
          field.type == ZonedDateTime::class.java -> field.set(instance, RookDateTimeUtils.stringToZonedDateTime(fieldValue.asString()))
          field.type == LocalDate::class.java -> field.set(instance, RookDateTimeUtils.stringToLocalDate(fieldValue.asString()))
          field.type == BloodPressureDaySystolicDiastolicBpNumberItem::class.java -> {
            val rawBloodItem = fieldValue.asMap()
            field.set(instance, BloodPressureDaySystolicDiastolicBpNumberItem(
              systolicBp = rawBloodItem.getDouble("systolicBp"),
              diastolicBp = rawBloodItem.getDouble("diastolicBp")
            ))
          }
          field.type == TemperatureItem::class.java -> {
            val rawTemperatureItem = fieldValue.asMap()
            field.set(instance, TemperatureItem(
              temperatureCelsius = rawTemperatureItem.getDouble("temperatureCelsius"),
              measurementType = rawTemperatureItem.getString("measurementType") ?: ""
            ))
          }
          field.type == List::class.java && field.genericType is ParameterizedType -> {
            val genericType = field.genericType as ParameterizedType
            field.set(instance, parseList(fieldValue.asArray(), genericType))
          }

        }

      }
      catch (e: NoSuchFieldException) {
        println("El campo $fieldName no existe en la clase SleepSummaryItem")
      }

    }

    return instance
  }

  private fun parseList(array: ReadableArray, genericType: ParameterizedType): List<Any>? {

    if (genericType.actualTypeArguments.first() == BloodGlucoseGranularDataMgPerDlNumberItem::class.java) {
      return fromReadableArrayToGranularDataBPM(array)
    }

    if (genericType.actualTypeArguments.first() == BloodPressureGranularDataSystolicDiastolicBpNumberItem::class.java) {
      return fromReadableArrayToBloodPressureGranularDataSystolicDiastolicBpNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == HydrationAmountGranularDataMlNumberItem::class.java) {
      return fromReadableArrayToHydrationAmountGranularDataMlNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == HydrationLevelGranularDataPercentageNumberItem::class.java) {
      return fromReadableArrayToHydrationLevelGranularDataPercentageNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == HrGranularDataBpmItem::class.java) {
      return fromReadableArrayToHrGranularDataBpmItem(array)
    }

    if (genericType.actualTypeArguments.first() == HrvSdnnGranularDataNumberItem::class.java) {
      return fromReadableArrayToHrvSdnnGranularDataNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == HrvRmssdGranularDataNumberItem::class.java) {
      return fromReadableArrayToHrvRmssdGranularDataNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == MoodGranularDataScaleItem::class.java) {
      return fromReadableArrayToMoodGranularDataScaleItem(array)
    }

    if (genericType.actualTypeArguments.first() == SaturationGranularDataPercentageItem::class.java) {
      return fromReadableArrayToSaturationGranularDataPercentageItem(array)
    }

    if (genericType.actualTypeArguments.first() == Vo2GranularDataMlPerMinItem::class.java) {
      return fromReadableArrayToVo2GranularDataMlPerMinItem(array)
    }

    if (genericType.actualTypeArguments.first() == TemperatureGranularDataCelsiusItem::class.java) {
      return fromReadableArrayToTemperatureGranularDataCelsiusItem(array)
    }

    if (genericType.actualTypeArguments.first() == MenstruationFlowMlGranularDataNumberItem::class.java) {
      return fromReadableArrayToMenstruationFlowMlGranularDataNumberItem(array)
    }

    return null
  }

  fun fromReadableArrayToGranularDataBPM(readableArray: ReadableArray): List<BloodGlucoseGranularDataMgPerDlNumberItem> {

    val data: MutableList<BloodGlucoseGranularDataMgPerDlNumberItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = BloodGlucoseGranularDataMgPerDlNumberItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        bloodGlucoseMgPerDlNumber = rawItem.getDouble("bloodGlucoseMgPerDlNumber"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToBloodPressureGranularDataSystolicDiastolicBpNumberItem(readableArray: ReadableArray): List<BloodPressureGranularDataSystolicDiastolicBpNumberItem> {

    val data: MutableList<BloodPressureGranularDataSystolicDiastolicBpNumberItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = BloodPressureGranularDataSystolicDiastolicBpNumberItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        systolicBp = rawItem.getDouble("systolicBp"),
        diastolicBp = rawItem.getDouble("diastolicBp"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToHydrationAmountGranularDataMlNumberItem(readableArray: ReadableArray): List<HydrationAmountGranularDataMlNumberItem> {

    val data: MutableList<HydrationAmountGranularDataMlNumberItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = HydrationAmountGranularDataMlNumberItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        intervalDurationSeconds = rawItem.getInt("intervalDurationSeconds"),
        hydrationAmountMl = rawItem.getDouble("hydrationAmountMl"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToHydrationLevelGranularDataPercentageNumberItem(readableArray: ReadableArray): List<HydrationLevelGranularDataPercentageNumberItem> {

    val data: MutableList<HydrationLevelGranularDataPercentageNumberItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = HydrationLevelGranularDataPercentageNumberItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        intervalDurationSeconds = rawItem.getInt("intervalDurationSeconds"),
        hydrationLevelPercentage = rawItem.getDouble("hydrationLevelPercentage"),
      )

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToHrGranularDataBpmItem(readableArray: ReadableArray): List<HrGranularDataBpmItem> {

    val data: MutableList<HrGranularDataBpmItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = HrGranularDataBpmItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        hrBpm = rawItem.getInt("hrBpm"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToHrvSdnnGranularDataNumberItem(readableArray: ReadableArray): List<HrvSdnnGranularDataNumberItem> {

    val data: MutableList<HrvSdnnGranularDataNumberItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = HrvSdnnGranularDataNumberItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        hrvSdnn = rawItem.getDouble("hrvSdnn"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToHrvRmssdGranularDataNumberItem(readableArray: ReadableArray): List<HrvRmssdGranularDataNumberItem> {

    val data: MutableList<HrvRmssdGranularDataNumberItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = HrvRmssdGranularDataNumberItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        hrvRmssd = rawItem.getDouble("hrvRmssd"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToMoodGranularDataScaleItem(readableArray: ReadableArray): List<MoodGranularDataScaleItem> {

    val data: MutableList<MoodGranularDataScaleItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = MoodGranularDataScaleItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        intervalDurationSeconds = rawItem.getInt("intervalDurationSeconds"),
        moodScale = rawItem.getDouble("moodScale"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToSaturationGranularDataPercentageItem(readableArray: ReadableArray): List<SaturationGranularDataPercentageItem> {

    val data: MutableList<SaturationGranularDataPercentageItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = SaturationGranularDataPercentageItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        saturationPercentage = rawItem.getDouble("saturationPercentage"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToVo2GranularDataMlPerMinItem(readableArray: ReadableArray): List<Vo2GranularDataMlPerMinItem> {

    val data: MutableList<Vo2GranularDataMlPerMinItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = Vo2GranularDataMlPerMinItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        vo2MlPerMin = rawItem.getDouble("vo2MlPerMin"),
      )

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToTemperatureGranularDataCelsiusItem(readableArray: ReadableArray): List<TemperatureGranularDataCelsiusItem> {

    val data: MutableList<TemperatureGranularDataCelsiusItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = TemperatureGranularDataCelsiusItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        temperatureCelsius = rawItem.getDouble("temperatureCelsius"),
        measurementType = rawItem.getString("measurementType") ?: "",
      )

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToMenstruationFlowMlGranularDataNumberItem(readableArray: ReadableArray): List<MenstruationFlowMlGranularDataNumberItem> {

    val data: MutableList<MenstruationFlowMlGranularDataNumberItem> = mutableListOf()

    for (i in 0 until readableArray.size()) {

      val rawItem = readableArray.getMap(i);

      val bpmItem = MenstruationFlowMlGranularDataNumberItem(
        dateTime = RookDateTimeUtils.stringToZonedDateTime(rawItem.getString("dateTime") ?: "2023-01-01"),
        flowMl = rawItem.getDouble("flowMl"),
      )

      data.add(bpmItem)
    }

    return data
  }

}