package com.google.chip.chiptool.clusterclient

import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import android.widget.AdapterView
import android.widget.ArrayAdapter
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import chip.devicecontroller.ChipClusters
import com.google.chip.chiptool.ChipClient
import com.google.chip.chiptool.R
import com.google.chip.chiptool.databinding.AttestationTestFragmentBinding
import com.google.chip.chiptool.databinding.SensorClientFragmentBinding
import com.google.chip.chiptool.util.DeviceIdUtil
import com.jjoe64.graphview.LabelFormatter
import com.jjoe64.graphview.Viewport
import com.jjoe64.graphview.series.DataPoint
import com.jjoe64.graphview.series.LineGraphSeries
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Date
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch

private typealias ReadCallback = ChipClusters.IntegerAttributeCallback
private typealias TemperatureReadCallback =
    ChipClusters.TemperatureMeasurementCluster.MeasuredValueAttributeCallback

private typealias PressureReadCallback =
    ChipClusters.PressureMeasurementCluster.MeasuredValueAttributeCallback

private typealias RelativeHumidityReadCallback =
    ChipClusters.RelativeHumidityMeasurementCluster.MeasuredValueAttributeCallback

class SensorClientFragment : Fragment() {
  private lateinit var scope: CoroutineScope

  // History of sensor values
  private val sensorData = LineGraphSeries<DataPoint>()

  // Device whose attribute is subscribed
  private var subscribedDevicePtr = 0L

  private var _binding: SensorClientFragmentBinding? = null
  private val binding get() = _binding!!

  override fun onCreateView(
      inflater: LayoutInflater,
      container: ViewGroup?,
      savedInstanceState: Bundle?
  ): View {
    _binding = SensorClientFragmentBinding.inflate(inflater, container, false)
    scope = viewLifecycleOwner.lifecycleScope

    return binding.root
  }

  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

    ChipClient.getDeviceController(requireContext()).setCompletionListener(null)
    binding.deviceIdEd.setOnEditorActionListener { textView, actionId, _ ->
      if (actionId == EditorInfo.IME_ACTION_DONE) {
        resetSensorGraph() // reset the graph on device change
      }
      actionId == EditorInfo.IME_ACTION_DONE
    }

    binding.endpointIdEd.setOnEditorActionListener { textView, actionId, _ ->
      if (actionId == EditorInfo.IME_ACTION_DONE)
        resetSensorGraph() // reset the graph on endpoint change
      actionId == EditorInfo.IME_ACTION_DONE
    }

    binding.clusterNameSpinner.adapter = makeClusterNamesAdapter()
    binding.clusterNameSpinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
      override fun onNothingSelected(parent: AdapterView<*>?) = Unit
      override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
        resetSensorGraph() // reset the graph on cluster change
      }
    }

    binding.readSensorBtn.setOnClickListener { scope.launch { readSensorCluster() } }
    binding.watchSensorBtn.setOnCheckedChangeListener { _, isChecked ->
      if (isChecked) {
        scope.launch { subscribeSensorCluster() }
      } else {
        unsubscribeSensorCluster()
      }
    }

    val currentTime = Calendar.getInstance().time.time
    binding.sensorGraph.addSeries(sensorData)
    binding.sensorGraph.viewport.isXAxisBoundsManual = true
    binding.sensorGraph.viewport.setMinX(currentTime.toDouble())
    binding.sensorGraph.viewport.setMaxX(currentTime.toDouble() + MIN_REFRESH_PERIOD_S * 1000 * MAX_DATA_POINTS)
    binding.sensorGraph.gridLabelRenderer.padding = 30
    binding.sensorGraph.gridLabelRenderer.numHorizontalLabels = 4
    binding.sensorGraph.gridLabelRenderer.setHorizontalLabelsAngle(150)
    binding.sensorGraph.gridLabelRenderer.labelFormatter = object : LabelFormatter {
      override fun setViewport(viewport: Viewport?) = Unit
      override fun formatLabel(value: Double, isValueX: Boolean): String {
        if (isValueX)
          return SimpleDateFormat("H:mm:ss").format(Date(value.toLong())).toString()
        if (value >= 100.0)
          return "%.1f".format(value)
        return "%.2f".format(value)
      }
    }
  }

  override fun onStart() {
    super.onStart()
    binding.deviceIdEd.setText(DeviceIdUtil.getLastDeviceId(requireContext()).toString())
  }

  override fun onStop() {
    resetSensorGraph() // reset the graph on fragment exit
    super.onStop()
  }

  override fun onDestroyView() {
    super.onDestroyView()
    _binding = null
  }

  private fun resetSensorGraph() {
    binding.watchSensorBtn.isChecked = false
    binding.sensorGraph.visibility = View.INVISIBLE
    sensorData.resetData(emptyArray())
  }

  private fun makeClusterNamesAdapter(): ArrayAdapter<String> {
    return ArrayAdapter(
        requireContext(),
        android.R.layout.simple_spinner_dropdown_item,
        CLUSTERS.keys.toList()
    ).apply {
      setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
    }
  }

  private suspend fun readSensorCluster() {
    try {
      val deviceId = binding.deviceIdEd.text.toString().toULong().toLong()
      val endpointId = binding.endpointIdEd.text.toString().toInt()
      val clusterName = binding.clusterNameSpinner.selectedItem.toString()
      val clusterRead = CLUSTERS[clusterName]!!["read"] as (Long, Int, ReadCallback) -> Unit
      val device = ChipClient.getConnectedDevicePointer(requireContext(), deviceId)
      val callback = makeReadCallback(clusterName, false)

      clusterRead(device, endpointId, callback)
    } catch (ex: Exception) {
      showMessage(R.string.sensor_client_read_error_text, ex.toString())
    }
  }

  private suspend fun subscribeSensorCluster() {
    try {
      val deviceId = binding.deviceIdEd.text.toString().toULong().toLong()
      val endpointId = binding.endpointIdEd.text.toString().toInt()
      val clusterName = binding.clusterNameSpinner.selectedItem.toString()
      val clusterSubscribe = CLUSTERS[clusterName]!!["subscribe"] as (Long, Int, ReadCallback) -> Unit
      val device = ChipClient.getConnectedDevicePointer(requireContext(), deviceId)
      val callback = makeReadCallback(clusterName, true)

      clusterSubscribe(device, endpointId, callback)
      subscribedDevicePtr = device
    } catch (ex: Exception) {
      showMessage(R.string.sensor_client_subscribe_error_text, ex.toString())
    }
  }

  private fun unsubscribeSensorCluster() {
    if (subscribedDevicePtr == 0L)
      return

    try {
      ChipClient.getDeviceController(requireContext()).shutdownSubscriptions()
      subscribedDevicePtr = 0
    } catch (ex: Exception) {
      showMessage(R.string.sensor_client_unsubscribe_error_text, ex.toString())
    }
  }

  private fun makeReadCallback(clusterName: String, addToGraph: Boolean): ReadCallback {
    return object : ReadCallback {
      val clusterConfig = CLUSTERS[clusterName]!!

      override fun onSuccess(value: Int) {
        val unitValue = clusterConfig["unitValue"] as Double
        val unitSymbol = clusterConfig["unitSymbol"] as String
        consumeSensorValue(value * unitValue, unitSymbol, addToGraph)
      }

      override fun onError(ex: Exception) {
        showMessage(R.string.sensor_client_read_error_text, ex.toString())
      }
    }
  }

  private fun consumeSensorValue(value: Double, unitSymbol: String, addToGraph: Boolean) {
    requireActivity().runOnUiThread {
      binding.lastValueTv.text = requireContext().getString(
          R.string.sensor_client_last_value_text, value, unitSymbol
      )

      if (addToGraph) {
        val isFirstSample = sensorData.isEmpty
        val dataPoint = DataPoint(Calendar.getInstance().time, value)
        sensorData.appendData(dataPoint, true, MAX_DATA_POINTS)
        if (isFirstSample) {
          // Make the graph visible on the first sample. Also, workaround a bug in graphview
          // related to calculating the viewport when there is only one data point by
          // duplicating the first sample.
          sensorData.appendData(dataPoint, true, MAX_DATA_POINTS)
          binding.sensorGraph.visibility = View.VISIBLE
        }
      }
    }
  }

  private fun showMessage(msgResId: Int, stringArgs: String? = null) {
    requireActivity().runOnUiThread {
      val context = requireContext()
      val message = context.getString(msgResId, stringArgs)
      Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
      Log.i(TAG, message)
    }
  }

  companion object {
    private const val TAG = "SensorClientFragment"
    private const val MIN_REFRESH_PERIOD_S = 2
    private const val MAX_REFRESH_PERIOD_S = 10
    private const val MAX_DATA_POINTS = 60
    private val CLUSTERS = mapOf(
        "Temperature" to mapOf(
            "read" to { device: Long, endpointId: Int, callback: ReadCallback ->
              val cluster = ChipClusters.TemperatureMeasurementCluster(device, endpointId)
              cluster.readMeasuredValueAttribute(makeTemperatureReadCallback(callback))
            },
            "subscribe" to { device: Long, endpointId: Int, callback: ReadCallback ->
              val cluster = ChipClusters.TemperatureMeasurementCluster(device, endpointId)
              cluster.subscribeMeasuredValueAttribute(makeTemperatureReadCallback(callback),
                  MIN_REFRESH_PERIOD_S,
                  MAX_REFRESH_PERIOD_S)
            },
            "unitValue" to 0.01,
            "unitSymbol" to "\u00B0C"
        ),
        "Pressure" to mapOf(
            "read" to { device: Long, endpointId: Int, callback: ReadCallback ->
              val cluster = ChipClusters.PressureMeasurementCluster(device, endpointId)
              cluster.readMeasuredValueAttribute(makePressureReadCallback(callback))
            },
            "subscribe" to { device: Long, endpointId: Int, callback: ReadCallback ->
              val cluster = ChipClusters.PressureMeasurementCluster(device, endpointId)
              cluster.subscribeMeasuredValueAttribute(makePressureReadCallback(callback),
                  MIN_REFRESH_PERIOD_S,
                  MAX_REFRESH_PERIOD_S)
            },
            "unitValue" to 1.0,
            "unitSymbol" to "hPa"
        ),
        "Relative Humidity" to mapOf(
            "read" to { device: Long, endpointId: Int, callback: ReadCallback ->
              val cluster = ChipClusters.RelativeHumidityMeasurementCluster(device, endpointId)
              cluster.readMeasuredValueAttribute(makeHumidityReadCallback(callback))
            },
            "subscribe" to { device: Long, endpointId: Int, callback: ReadCallback ->
              val cluster = ChipClusters.RelativeHumidityMeasurementCluster(device, endpointId)
              cluster.subscribeMeasuredValueAttribute(makeHumidityReadCallback(callback),
                  MIN_REFRESH_PERIOD_S,
                  MAX_REFRESH_PERIOD_S)
            },
            "unitValue" to 0.01,
            "unitSymbol" to "%"
        )
    )

    private fun makeTemperatureReadCallback(callback: ReadCallback): TemperatureReadCallback {
      return object : TemperatureReadCallback {
        override fun onSuccess(value: Int?) {
          value?.let { callback.onSuccess(it) }
        }

        override fun onError(error: java.lang.Exception?) {
          callback.onError(error)
        }
      }
    }

    private fun makePressureReadCallback(callback: ReadCallback): PressureReadCallback {
      return object : PressureReadCallback {
        override fun onSuccess(value: Int?) {
          value?.let { callback.onSuccess(it) }
        }

        override fun onError(error: java.lang.Exception?) {
          callback.onError(error)
        }
      }
    }

    private fun makeHumidityReadCallback(callback: ReadCallback): RelativeHumidityReadCallback {
      return object : RelativeHumidityReadCallback {
        override fun onSuccess(value: Int?) {
          value?.let { callback.onSuccess(it) }
        }

        override fun onError(error: java.lang.Exception?) {
          callback.onError(error)
        }
      }
    }

    fun newInstance(): SensorClientFragment = SensorClientFragment()
  }
}