package com.rookandroidtransmission.transformations

import com.facebook.react.bridge.ReadableArray
import com.facebook.react.bridge.ReadableMap
import com.rookmotion.rook.transmission.domain.model.event.BloodGlucoseEventItem
import com.rookmotion.rook.transmission.domain.model.event.BloodPressureEventItem
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 java.lang.reflect.ParameterizedType
import java.time.LocalDate
import java.time.ZonedDateTime

object EncodeBloodPressureEvent {

  fun fromReadableMap(readableMap: ReadableMap): BloodPressureEventItem{

    val clazz = BloodPressureEventItem::class.java

    val instance = BloodPressureEventItem(
      dateTime=  ZonedDateTime.now(),
      sourceOfData =  "HC",
      wasTheUserUnderPhysicalActivity = true,
    )

    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 == 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() == BloodPressureGranularDataSystolicDiastolicBpNumberItem::class.java) {
      return EncodeBodySummaryItem.fromReadableArrayToBloodPressureGranularDataSystolicDiastolicBpNumberItem(array)
    }

    return null

  }
}