package com.rookandroidtransmission.transformations

import com.facebook.react.bridge.ReadableArray
import com.facebook.react.bridge.ReadableMap
import com.rookmotion.rook.transmission.domain.model.event.PhysicalEventItem
import com.rookmotion.rook.transmission.domain.model.granular.ActivityLevelGranularDataNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.CadenceGranularDataRpmItem
import com.rookmotion.rook.transmission.domain.model.granular.ElevationGranularDataMetersItem
import com.rookmotion.rook.transmission.domain.model.granular.FloorsClimbedGranularDataFloorsItem
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.LapGranularDataLapsNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.PositionGranularDataLatLngDegItem
import com.rookmotion.rook.transmission.domain.model.granular.PositionLatLngDegItem
import com.rookmotion.rook.transmission.domain.model.granular.PowerGranularDataWattsNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.SaturationGranularDataPercentageItem
import com.rookmotion.rook.transmission.domain.model.granular.SpeedGranularDataMetersPerSecondItem
import com.rookmotion.rook.transmission.domain.model.granular.StepsGranularDataStepsPerHrItem
import com.rookmotion.rook.transmission.domain.model.granular.StepsGranularDataStepsPerMinItem
import com.rookmotion.rook.transmission.domain.model.granular.SwimmingDistanceGranularDataMetersItem
import com.rookmotion.rook.transmission.domain.model.granular.TorqueGranularDataNewtonMetersItem
import com.rookmotion.rook.transmission.domain.model.granular.TraveledDistanceGranularDataMetersItem
import com.rookmotion.rook.transmission.domain.model.granular.TssGranularData1To500ScoreNumberItem
import com.rookmotion.rook.transmission.domain.model.granular.VelocityVectorSpeedAndDirectionItem
import com.rookmotion.rook.transmission.domain.model.granular.Vo2GranularDataMlPerMinItem
import java.lang.reflect.ParameterizedType
import java.time.LocalDate
import java.time.ZonedDateTime

object EncodePhysicalEventItem {

  fun fromReadableMap(readableMap: ReadableMap): PhysicalEventItem {
    val clazz = PhysicalEventItem::class.java

    val instance = PhysicalEventItem(
      dateTime= ZonedDateTime.now(),
      sourceOfData = "HC",
      wasTheUserUnderPhysicalActivity = true,
      activityStartTimeDateTime=  ZonedDateTime.now(),
      activityEndTimeDateTime = ZonedDateTime.now(),
      activityDurationSeconds = 0,
      activityTypeName =  "activity",
    )

    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 == VelocityVectorSpeedAndDirectionItem::class.java -> {
            val rawTemperatureItem = fieldValue.asMap()
            field.set(instance, VelocityVectorSpeedAndDirectionItem(
              speedMetersPerSecond = rawTemperatureItem.getDouble("speedMetersPerSecond"),
              direction = rawTemperatureItem.getString("direction") ?: ""
            ))
          }
          field.type == PositionLatLngDegItem::class.java -> {
            val rawTemperatureItem = fieldValue.asMap()
            field.set(instance, PositionLatLngDegItem(
              lat = rawTemperatureItem.getDouble("lat"),
              lng = rawTemperatureItem.getDouble("lng")
            ))
          }
          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() == ActivityLevelGranularDataNumberItem::class.java) {
      return EncodePhysicalSummaryItem.fromReadableArrayToActivityLevelGranularDataNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == StepsGranularDataStepsPerMinItem::class.java) {
      return fromReadableArrayToStepsGranularDataStepsPerMinItem(array)
    }

    if (genericType.actualTypeArguments.first() == TraveledDistanceGranularDataMetersItem::class.java) {
      return EncodePhysicalSummaryItem.fromReadableArrayToTraveledDistanceGranularDataMetersItem(array)
    }

    if (genericType.actualTypeArguments.first() == FloorsClimbedGranularDataFloorsItem::class.java) {
      return EncodePhysicalSummaryItem.fromReadableArrayToFloorsClimbedGranularDataFloorsItem(array)
    }

    if (genericType.actualTypeArguments.first() == ElevationGranularDataMetersItem::class.java) {
      return EncodePhysicalSummaryItem.fromReadableArrayToElevationGranularDataMetersItem(array)
    }

    if (genericType.actualTypeArguments.first() == SwimmingDistanceGranularDataMetersItem::class.java) {
      return EncodePhysicalSummaryItem.fromReadableArrayToSwimmingDistanceGranularDataMetersItem(array)
    }

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

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

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

    if (genericType.actualTypeArguments.first() == SpeedGranularDataMetersPerSecondItem::class.java) {
      return fromReadableArrayToSpeedGranularDataMetersPerSecondItem(array)
    }

    if (genericType.actualTypeArguments.first() == CadenceGranularDataRpmItem::class.java) {
      return fromReadableArrayToCadenceGranularDataRpmItem(array)
    }

    if (genericType.actualTypeArguments.first() == TorqueGranularDataNewtonMetersItem::class.java) {
      return fromReadableArrayToTorqueGranularDataNewtonMetersItem(array)
    }

    if (genericType.actualTypeArguments.first() == LapGranularDataLapsNumberItem::class.java) {
      return fromReadableArrayToLapGranularDataLapsNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == PowerGranularDataWattsNumberItem::class.java) {
      return fromReadableArrayToPowerGranularDataWattsNumberItem(array)
    }

    if (genericType.actualTypeArguments.first() == PositionGranularDataLatLngDegItem::class.java) {
      return fromReadableArrayToPositionGranularDataLatLngDegItem(array)
    }

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

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

    if (genericType.actualTypeArguments.first() == TssGranularData1To500ScoreNumberItem::class.java) {
      return fromReadableArrayToTssGranularData1To500ScoreNumberItem(array)
    }

    return null
  }

  private fun fromReadableArrayToStepsGranularDataStepsPerMinItem(readableArray: ReadableArray): List<StepsGranularDataStepsPerMinItem> {

    val data: MutableList<StepsGranularDataStepsPerMinItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToSpeedGranularDataMetersPerSecondItem(readableArray: ReadableArray): List<SpeedGranularDataMetersPerSecondItem> {

    val data: MutableList<SpeedGranularDataMetersPerSecondItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToCadenceGranularDataRpmItem(readableArray: ReadableArray): List<CadenceGranularDataRpmItem> {

    val data: MutableList<CadenceGranularDataRpmItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToTorqueGranularDataNewtonMetersItem(readableArray: ReadableArray): List<TorqueGranularDataNewtonMetersItem> {

    val data: MutableList<TorqueGranularDataNewtonMetersItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToLapGranularDataLapsNumberItem(readableArray: ReadableArray): List<LapGranularDataLapsNumberItem> {

    val data: MutableList<LapGranularDataLapsNumberItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToPowerGranularDataWattsNumberItem(readableArray: ReadableArray): List<PowerGranularDataWattsNumberItem> {

    val data: MutableList<PowerGranularDataWattsNumberItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }

  private fun fromReadableArrayToPositionGranularDataLatLngDegItem(readableArray: ReadableArray): List<PositionGranularDataLatLngDegItem> {

    val data: MutableList<PositionGranularDataLatLngDegItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }

  fun fromReadableArrayToTssGranularData1To500ScoreNumberItem(readableArray: ReadableArray): List<TssGranularData1To500ScoreNumberItem> {

    val data: MutableList<TssGranularData1To500ScoreNumberItem> = mutableListOf()

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

      val rawItem = readableArray.getMap(i);

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

      data.add(bpmItem)
    }

    return data
  }
}