package com.google.chip.chiptool.clusterclient

import android.app.AlertDialog
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ArrayAdapter
import android.widget.Button
import android.widget.EditText
import android.widget.Spinner
import android.widget.TextView
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import chip.devicecontroller.ChipDeviceController
import chip.devicecontroller.ChipIdLookup
import chip.devicecontroller.InvokeCallback
import chip.devicecontroller.ReportCallback
import chip.devicecontroller.ResubscriptionAttemptCallback
import chip.devicecontroller.SubscriptionEstablishedCallback
import chip.devicecontroller.WriteAttributesCallback
import chip.devicecontroller.model.AttributeWriteRequest
import chip.devicecontroller.model.ChipAttributePath
import chip.devicecontroller.model.ChipEventPath
import chip.devicecontroller.model.ChipPathId
import chip.devicecontroller.model.InvokeElement
import chip.devicecontroller.model.NodeState
import chip.tlv.AnonymousTag
import chip.tlv.ContextSpecificTag
import chip.tlv.TlvReader
import chip.tlv.TlvWriter
import com.google.chip.chiptool.ChipClient
import com.google.chip.chiptool.R
import com.google.chip.chiptool.databinding.WildcardFragmentBinding
import com.google.protobuf.ByteString
import java.lang.StringBuilder
import java.util.Optional
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine

class WildcardFragment : Fragment() {
  private var _binding: WildcardFragmentBinding? = null
  private val binding get() = _binding!!

  private val deviceController: ChipDeviceController
    get() = ChipClient.getDeviceController(requireContext())

  private lateinit var scope: CoroutineScope

  private lateinit var addressUpdateFragment: AddressUpdateFragment

  private val attributePath = ArrayList<ChipAttributePath>()
  private val eventPath = ArrayList<ChipEventPath>()
  private val subscribeIdList = ArrayList<ULong>()

  private val reportCallback = object : ReportCallback {
    override fun onError(attributePath: ChipAttributePath?, eventPath: ChipEventPath?, ex: Exception) {
      if (attributePath != null)
      {
        Log.e(TAG, "Report error for $attributePath: $ex")
      }
      if (eventPath != null)
      {
        Log.e(TAG, "Report error for $eventPath: $ex")
      }
    }

    override fun onReport(nodeState: NodeState) {
      Log.i(TAG, "Received wildcard report")

      val debugString = nodeStateToDebugString(nodeState)
      Log.i(TAG, debugString)
      requireActivity().runOnUiThread { binding.outputTv.text = debugString }
    }

    override fun onDone() {
      Log.i(TAG, "wildcard report Done")
    }
  }

  private val writeAttributeCallback = object : WriteAttributesCallback {
    override fun onError(attributePath: ChipAttributePath?, ex: Exception?) {
      Log.e(TAG, "Report error for $attributePath: $ex")
    }

    override fun onResponse(attributePath: ChipAttributePath?) {
      val text = "$attributePath : Write Success"
      requireActivity().runOnUiThread { binding.outputTv.text = text }
    }

    override fun onDone() {
      Log.i(TAG, "write attribute Done")
    }
  }

  private val invokeCallback = object : InvokeCallback {
    override fun onError(e: java.lang.Exception?) {
      Log.e(TAG, "Report error", e)
    }

    override fun onResponse(invokeElement: InvokeElement?, successCode: Long) {
      val text = "Invoke Response : $invokeElement, $successCode"
      requireActivity().runOnUiThread { binding.outputTv.text = text }
    }

  }

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

    binding.selectTypeRadioGroup.setOnCheckedChangeListener { _, i ->
      val readBtnOn = (i == R.id.readRadioBtn)
      val subscribeBtnOn = (i == R.id.subscribeRadioBtn)
      val writeBtnOn = (i == R.id.writeRadioBtn)
      val invokeBtnOn = (i == R.id.invokeRadioBtn)

      binding.addLayout.visibility = getVisibility(readBtnOn || subscribeBtnOn)
      binding.attributeIdLabel.visibility = getVisibility(readBtnOn || subscribeBtnOn || writeBtnOn)
      binding.attributeIdEd.visibility = getVisibility(readBtnOn || subscribeBtnOn || writeBtnOn)
      binding.eventIdLabel.visibility = getVisibility(readBtnOn || subscribeBtnOn)
      binding.eventIdEd.visibility = getVisibility(readBtnOn || subscribeBtnOn)
      binding.commandIdLabel.visibility = getVisibility(invokeBtnOn)
      binding.commandIdEd.visibility = getVisibility(invokeBtnOn)
      binding.isUrgentLabel.visibility = getVisibility(subscribeBtnOn)
      binding.isUrgentSp.visibility = getVisibility(subscribeBtnOn)
      binding.shutdownSubscriptionBtn.visibility = getVisibility(subscribeBtnOn)
    }

    binding.sendBtn.setOnClickListener {
      if (binding.readRadioBtn.isChecked) {
        showReadDialog()
      } else if (binding.subscribeRadioBtn.isChecked) {
        showSubscribeDialog()
      } else if (binding.writeRadioBtn.isChecked) {
        showWriteDialog()
      } else if (binding.invokeRadioBtn.isChecked) {
        showInvokeDialog()
      }
    }

    binding.shutdownSubscriptionBtn.setOnClickListener { showShutdownSubscriptionDialog() }

    binding.addAttributeBtn.setOnClickListener { addPathList(ATTRIBUTE) }
    binding.addEventBtn.setOnClickListener { addPathList(EVENT) }
    binding.resetBtn.setOnClickListener { resetPath() }

    addressUpdateFragment =
      childFragmentManager.findFragmentById(R.id.addressUpdateFragment) as AddressUpdateFragment

    return binding.root
  }

  private fun getVisibility(isShowing: Boolean) : Int {
    return if (isShowing) { View.VISIBLE } else { View.GONE }
  }

  private fun addPathList(type: Int) {
    val endpointId = getChipPathIdForText(binding.endpointIdEd.text.toString())
    val clusterId = getChipPathIdForText(binding.clusterIdEd.text.toString())
    val attributeId = getChipPathIdForText(binding.attributeIdEd.text.toString())
    val eventId = getChipPathIdForText(binding.eventIdEd.text.toString())
    // Only Subscribe used
    val isUrgent = (binding.subscribeRadioBtn.isChecked) && (binding.isUrgentSp.selectedItem.toString().toBoolean())

    if (type == ATTRIBUTE) {
      attributePath.add(ChipAttributePath.newInstance(endpointId, clusterId, attributeId))
    } else if (type == EVENT) {
      eventPath.add(ChipEventPath.newInstance(endpointId, clusterId, eventId, isUrgent))
    }
    updateAddListView()
  }

  private fun resetPath() {
    attributePath.clear()
    eventPath.clear()
    updateAddListView()
  }

  private fun updateAddListView() {
    val builder = StringBuilder()
    for (attribute in attributePath) {
      builder.append("attribute($attribute)\n")
    }
    for (event in eventPath) {
      builder.append("event($event)\n")
    }
    binding.sendListView.text = builder.toString()
  }

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

  private fun nodeStateToDebugString(nodeState: NodeState): String {
    val stringBuilder = StringBuilder()
    nodeState.endpointStates.forEach { (endpointId, endpointState) ->
      stringBuilder.append("Endpoint $endpointId: {\n")
      endpointState.clusterStates.forEach { (clusterId, clusterState) ->
        stringBuilder.append("\t${ChipIdLookup.clusterIdToName(clusterId)}Cluster: {\n")
        clusterState.attributeStates.forEach { (attributeId, attributeState) ->
          val attributeName = ChipIdLookup.attributeIdToName(clusterId, attributeId)
          stringBuilder.append("\t\t$attributeName: ${attributeState.value}\n")
        }
        clusterState.eventStates.forEach { (eventId, events) ->
          for (event in events)
          {
            stringBuilder.append("\t\teventNumber: ${event.eventNumber}\n")
            stringBuilder.append("\t\tpriorityLevel: ${event.priorityLevel}\n")
            stringBuilder.append("\t\tsystemTimeStamp: ${event.systemTimeStamp}\n")

            val eventName = ChipIdLookup.eventIdToName(clusterId, eventId)
            stringBuilder.append("\t\t$eventName: ${event.value}\n")
          }
        }
        stringBuilder.append("\t}\n")
      }
      stringBuilder.append("}\n")
    }
    return stringBuilder.toString()
  }

  private suspend fun subscribe(minInterval: Int, maxInterval: Int, keepSubscriptions: Boolean, isFabricFiltered: Boolean, eventMin: Long?) {
    val subscriptionEstablishedCallback =
      SubscriptionEstablishedCallback {
        subscriptionId ->
        Log.i(TAG, "Subscription to device established : ${subscriptionId.toULong()}")
        subscribeIdList.add(subscriptionId.toULong())
        requireActivity().runOnUiThread {
          Toast.makeText(requireActivity(), "${getString(R.string.wildcard_subscribe_established_toast_message)} : $subscriptionId", Toast.LENGTH_SHORT).show()
        }
      }

    val resubscriptionAttemptCallback =
      ResubscriptionAttemptCallback { terminationCause, nextResubscribeIntervalMsec
                                     -> Log.i(TAG, "ResubscriptionAttempt terminationCause:$terminationCause, nextResubscribeIntervalMsec:$nextResubscribeIntervalMsec") }

    deviceController.subscribeToPath(subscriptionEstablishedCallback,
            resubscriptionAttemptCallback,
            reportCallback,
            ChipClient.getConnectedDevicePointer(requireContext(),
                    addressUpdateFragment.deviceId),
            attributePath.ifEmpty { null },
            eventPath.ifEmpty { null },
            minInterval,
            maxInterval,
            keepSubscriptions,
            isFabricFiltered,
            /* imTimeoutMs= */ 0,
            eventMin)
  }

  private suspend fun read(isFabricFiltered: Boolean, eventMin: Long?) {
    deviceController.readPath(reportCallback,
            ChipClient.getConnectedDevicePointer(requireContext(),
                    addressUpdateFragment.deviceId),
            attributePath.ifEmpty { null },
            eventPath.ifEmpty { null },
            isFabricFiltered,
            /* imTimeoutMs= */ 0,
            eventMin)
  }

  private suspend fun write(writeValueType: String, writeValue: String, dataVersion: Int?, timedRequestTimeoutMs: Int, imTimeoutMs: Int) {
    val endpointId = getChipPathIdForText(binding.endpointIdEd.text.toString())
    val clusterId = getChipPathIdForText(binding.clusterIdEd.text.toString())
    val attributeId = getChipPathIdForText(binding.attributeIdEd.text.toString())
    val tlvWriter = TlvWriter()
    val values = writeValue.split(",")

    if (values.size > 1) tlvWriter.startArray(AnonymousTag)
    for (value in values) {
      try {
        TLV_MAP[writeValueType]?.generate(tlvWriter, value.trim())
      } catch (ex: Exception) {
        Log.e(TAG, "Invalid Data Type", ex)
        return
      }
    }
    if (values.size > 1) tlvWriter.endArray()

    val version = if (dataVersion == null) { Optional.empty() } else { Optional.of(dataVersion) }

    val writeRequest = AttributeWriteRequest.newInstance(endpointId, clusterId, attributeId, tlvWriter.getEncoded(), version)
    deviceController.write(writeAttributeCallback,
                      ChipClient.getConnectedDevicePointer(requireContext(),
                      addressUpdateFragment.deviceId),
                      listOf(writeRequest),
                      timedRequestTimeoutMs,
                      imTimeoutMs)
  }

  private suspend fun invoke(invokeField: String, timedRequestTimeoutMs: Int, imTimeoutMs: Int) {
    val endpointId = getChipPathIdForText(binding.endpointIdEd.text.toString())
    val clusterId = getChipPathIdForText(binding.clusterIdEd.text.toString())
    val commandId = getChipPathIdForText(binding.commandIdEd.text.toString())

    val tlvWriter = TlvWriter()
    val fields = if (invokeField.isEmpty()) { listOf() } else { invokeField.split(",") }
    var count = 0
    tlvWriter.startStructure(AnonymousTag)
    for (field in fields) {
      try {
        val type = field.split(":")[0]
        val value = field.split(":")[1]

        Log.d(TAG, "value : $type - $value")
        TLV_MAP[type]?.generate(tlvWriter, value.trim(), ContextSpecificTag(count++))
      } catch (ex: Exception) {
        Log.e(TAG, "Invalid value", ex)
        return
      }
    }
    tlvWriter.endStructure()
    val invokeElement = InvokeElement.newInstance(endpointId, clusterId, commandId, tlvWriter.getEncoded(), null)
    deviceController.invoke(invokeCallback,
            ChipClient.getConnectedDevicePointer(requireContext(),
                    addressUpdateFragment.deviceId),
            invokeElement,
            timedRequestTimeoutMs,
            imTimeoutMs)
  }

  private fun showReadDialog() {
    if (attributePath.isEmpty() && eventPath.isEmpty()) {
      requireActivity().runOnUiThread {
        Toast.makeText(requireActivity(), R.string.wildcard_empty_error_toast_message, Toast.LENGTH_SHORT).show()
      }
      return
    }
    val dialogView = requireActivity().layoutInflater.inflate(R.layout.read_dialog, null)
    val eventMinEd = dialogView.findViewById<EditText>(R.id.eventMinEd)
    eventMinEd.visibility = if (eventPath.isNotEmpty()) { View.VISIBLE } else { View.GONE }
    val dialog = AlertDialog.Builder(requireContext()).apply {
      setView(dialogView)
    }.create()

    val isFabricFilteredEd = dialogView.findViewById<Spinner>(R.id.isFabricFilteredSp)
    dialogView.findViewById<Button>(R.id.readBtn).setOnClickListener {
      scope.launch {
        var eventMin : Long? = null
        if (eventPath.isNotEmpty() && eventMinEd.text.isNotBlank()) {
          eventMin = eventMinEd.text.toString().toULong().toLong()
        }
        read(isFabricFilteredEd.selectedItem.toString().toBoolean(), eventMin)
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }
    dialog.show()
  }

  private fun showWriteDialog() {
    binding.outputTv.text = ""
    val dialogView = requireActivity().layoutInflater.inflate(R.layout.write_dialog, null)
    val writeValueTypeSp = dialogView.findViewById<Spinner>(R.id.writeValueTypeSp)
    val spinnerAdapter = ArrayAdapter(requireActivity(), android.R.layout.simple_spinner_dropdown_item, TLV_MAP.keys.toList())
    writeValueTypeSp.adapter = spinnerAdapter
    val dialog = AlertDialog.Builder(requireContext()).apply {
      setView(dialogView)
    }.create()

    dialogView.findViewById<Button>(R.id.writeBtn).setOnClickListener {
      val writeValue = dialogView.findViewById<EditText>(R.id.writeValueEd).text.toString()
      val dataVersion = dialogView.findViewById<EditText>(R.id.dataVersionEd).text.toString()
      val timedRequestTimeoutMs = dialogView.findViewById<EditText>(R.id.timedRequestTimeoutEd).text.toString()
      val imTimeout = dialogView.findViewById<EditText>(R.id.imTimeoutEd).text.toString()
      scope.launch {
        write(  writeValueTypeSp.selectedItem.toString(),
                writeValue,
                if (dataVersion.isEmpty()) { null } else { dataVersion.toInt() },
                if (timedRequestTimeoutMs.isEmpty()) { 0 } else { timedRequestTimeoutMs.toInt() },
                if (imTimeout.isEmpty()) { 0 } else { imTimeout.toInt() } )
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }
    dialog.show()
  }

  private fun showSubscribeDialog() {
    if (attributePath.isEmpty() && eventPath.isEmpty()) {
      requireActivity().runOnUiThread {
        Toast.makeText(requireActivity(), R.string.wildcard_empty_error_toast_message, Toast.LENGTH_SHORT).show()
      }
      return
    }
    val dialogView = requireActivity().layoutInflater.inflate(R.layout.subscribe_dialog, null)
    val eventMinEd = dialogView.findViewById<EditText>(R.id.eventMinEd)
    eventMinEd.visibility = if (eventPath.isNotEmpty()) { View.VISIBLE } else { View.GONE }
    val dialog = AlertDialog.Builder(requireContext()).apply {
      setView(dialogView)
    }.create()

    val minIntervalEd = dialogView.findViewById<EditText>(R.id.minIntervalEd)
    val maxIntervalEd = dialogView.findViewById<EditText>(R.id.maxIntervalEd)
    val keepSubscriptionsSp = dialogView.findViewById<Spinner>(R.id.keepSubscriptionsSp)
    val isFabricFilteredSp = dialogView.findViewById<Spinner>(R.id.isFabricFilteredSp)
    dialogView.findViewById<Button>(R.id.subscribeBtn).setOnClickListener {
      scope.launch {
        if(minIntervalEd.text.isNotBlank() && maxIntervalEd.text.isNotBlank()) {
          var eventMin : Long? = null
          if (eventPath.isNotEmpty() && eventMinEd.text.isNotBlank()) {
            eventMin = eventMinEd.text.toString().toULong().toLong()
          }
          subscribe(
            minIntervalEd.text.toString().toInt(),
            maxIntervalEd.text.toString().toInt(),
            keepSubscriptionsSp.selectedItem.toString().toBoolean(),
            isFabricFilteredSp.selectedItem.toString().toBoolean(),
            eventMin,
          )
        } else {
          Log.e(TAG, "minInterval or maxInterval is empty!" )
        }
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }
    dialog.show()
  }

  private fun showInvokeDialog() {
    binding.outputTv.text = ""
    val dialogView = requireActivity().layoutInflater.inflate(R.layout.invoke_dialog, null)
    val invokeValueEd = dialogView.findViewById<EditText>(R.id.invokeValueEd)
    val dialog = AlertDialog.Builder(requireContext()).apply {
      setView(dialogView)
    }.create()

    dialogView.findViewById<Button>(R.id.invokeBtn).setOnClickListener {
      val invokeValue = invokeValueEd.text.toString()
      val timedRequestTimeoutMs = dialogView.findViewById<EditText>(R.id.timedRequestTimeoutEd).text.toString()
      val imTimeout = dialogView.findViewById<EditText>(R.id.imTimeoutEd).text.toString()
      scope.launch {
        invoke(invokeValue,
                if (timedRequestTimeoutMs.isEmpty()) { 0 } else { timedRequestTimeoutMs.toInt() },
                if (imTimeout.isEmpty()) { 0 } else { imTimeout.toInt() } )
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }
    dialog.show()
  }

  private suspend fun readCurrentFabricIndex() : UInt {
    val context = requireContext()
    val endpointId = 0
    val clusterId = 62L // OperationalCredentials
    val attributeId = 5L // CurrentFabricIndex
    val deviceId = addressUpdateFragment.deviceId
    val devicePointer = ChipClient.getConnectedDevicePointer(context, deviceId)
    return suspendCoroutine { cont ->
      deviceController.readAttributePath(object : ReportCallback {
        override fun onError(attributePath: ChipAttributePath?, eventPath: ChipEventPath?, e: java.lang.Exception) {
          cont.resume(0u)
        }

        override fun onReport(nodeState: NodeState?) {
          val state = nodeState?.getEndpointState(endpointId.toInt())?.
                                  getClusterState(clusterId)?.
                                  getAttributeState(attributeId)
          if (state == null) {
            cont.resume(0u)
            return
          }
          val ret = TlvReader(state.tlv).getUInt(AnonymousTag)
          cont.resume(ret)
        }
      }, devicePointer,
         listOf(ChipAttributePath.newInstance(endpointId, clusterId, attributeId)),
         0 /* imTimeoutMs */
      )
    }
  }

  private fun shutdownSubscription(fabricIndex: UInt, subscribeId: ULong? = null) {
    val deviceId = addressUpdateFragment.deviceId
    if (subscribeId != null) {
      deviceController.shutdownSubscriptions(fabricIndex.toInt(), deviceId, subscribeId.toLong())
      subscribeIdList.remove(subscribeId)
    } else {
      deviceController.shutdownSubscriptions(fabricIndex.toInt(), deviceId)
    }
  }

  private fun showShutdownSubscriptionDialog() {
    val dialogView = requireActivity().layoutInflater.inflate(R.layout.shutdown_subscribe_dialog, null)
    val subscriptionIdSp = dialogView.findViewById<Spinner>(R.id.subscribeIdSp)
    val fabricIndexTv = dialogView.findViewById<TextView>(R.id.fabricIndexValue)
    val shutdownBtn = dialogView.findViewById<Button>(R.id.shutdownBtn)
    val shutdownAllBtn = dialogView.findViewById<Button>(R.id.shutdownAllBtn)
    val spinnerAdapter = ArrayAdapter(requireActivity(), android.R.layout.simple_spinner_dropdown_item, subscribeIdList)
    subscriptionIdSp.adapter = spinnerAdapter
    val dialog = AlertDialog.Builder(requireContext()).apply {
      setView(dialogView)
    }.create()

    shutdownBtn.setOnClickListener {
      val fabricIndex = fabricIndexTv.text.toString().toUInt()
      val subscribeId = subscriptionIdSp.selectedItem.toString().toULong()
      scope.launch {
        shutdownSubscription(fabricIndex, subscribeId)
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }

    shutdownAllBtn.setOnClickListener {
      scope.launch {
        val fabricIndex = fabricIndexTv.text.toString().toUInt()
        shutdownSubscription(fabricIndex)
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }
    dialog.show()

    scope.launch {
      val fabricIndex = readCurrentFabricIndex()
      requireActivity().runOnUiThread {
        fabricIndexTv.text = fabricIndex.toString()
        shutdownBtn.isEnabled = true
        shutdownAllBtn.isEnabled = true
      }
    }
  }

  private fun getChipPathIdForText(text: String): ChipPathId {
    return if (text.isEmpty()) ChipPathId.forWildcard() else ChipPathId.forId(text.toLong())
  }

  interface TlvWriterInterface {
    fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag = AnonymousTag)
  }

  companion object {
    private const val TAG = "WildcardFragment"
    private const val ATTRIBUTE = 1
    private const val EVENT = 2
    fun newInstance(): WildcardFragment = WildcardFragment()

    private val TLV_MAP = mapOf(
            "UnsignedInt" to object:TlvWriterInterface {
              override fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag) {
                writer.put(tag, value.toULong())
              }
            },
            "Int" to object:TlvWriterInterface {
              override fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag) {
                writer.put(tag, value.toLong())
              }
            },
            "Boolean" to object:TlvWriterInterface {
              override fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag) {
                writer.put(tag, value.toBoolean())
              }
            },
            "Float" to object:TlvWriterInterface {
              override fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag) {
                writer.put(tag, value.toFloat())
              }
            },
            "Double" to object:TlvWriterInterface {
              override fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag) {
                writer.put(tag, value.toDouble())
              }
            },
            "String" to object:TlvWriterInterface {
              override fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag) {
                writer.put(tag, value)
              }
            },
            "ByteArray(Hex)" to object:TlvWriterInterface {
              override fun generate(writer : TlvWriter, value: String, tag: chip.tlv.Tag) {
                writer.put(tag, value.chunked(2).map { it.toInt(16) and 0xFF }.map { it.toByte() }.toByteArray())
              }
            },
    )
  }
}