package com.google.chip.chiptool.clusterclient

import android.app.Activity
import android.app.AlertDialog
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.provider.OpenableColumns
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.AdapterView
import android.widget.ArrayAdapter
import android.widget.Button
import android.widget.EditText
import android.widget.Spinner
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import chip.devicecontroller.ChipClusters
import chip.devicecontroller.ChipClusters.DefaultClusterCallback
import chip.devicecontroller.ChipDeviceController
import chip.devicecontroller.ClusterIDMapping
import chip.devicecontroller.OTAProviderDelegate
import chip.devicecontroller.OTAProviderDelegate.QueryImageResponseStatusEnum
import chip.devicecontroller.ReportCallback
import chip.devicecontroller.WriteAttributesCallback
import chip.devicecontroller.cluster.structs.AccessControlClusterAccessControlEntryStruct
import chip.devicecontroller.cluster.structs.OtaSoftwareUpdateRequestorClusterProviderLocation
import chip.devicecontroller.model.AttributeWriteRequest
import chip.devicecontroller.model.ChipAttributePath
import chip.devicecontroller.model.ChipEventPath
import chip.devicecontroller.model.NodeState
import chip.devicecontroller.model.Status
import com.google.chip.chiptool.ChipClient
import com.google.chip.chiptool.GenericChipDeviceListener
import com.google.chip.chiptool.R
import com.google.chip.chiptool.databinding.OtaProviderClientFragmentBinding
import com.google.chip.chiptool.util.toAny
import java.io.BufferedInputStream
import java.io.IOException
import java.io.InputStream
import java.util.Optional
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import matter.tlv.AnonymousTag
import matter.tlv.TlvReader
import matter.tlv.TlvWriter

class OtaProviderClientFragment : Fragment() {
  private val deviceController: ChipDeviceController
    get() = ChipClient.getDeviceController(requireContext())

  private lateinit var scope: CoroutineScope

  private lateinit var addressUpdateFragment: AddressUpdateFragment

  private var _binding: OtaProviderClientFragmentBinding? = null

  private var fileUri: Uri? = null

  private val vendorId: Int
    get() = binding.vendorIdEd.text.toString().toInt()

  private val otaProviderCallback = OtaProviderCallback()
  private val binding
    get() = _binding!!

  private val attributeList = ClusterIDMapping.OtaSoftwareUpdateRequestor.Attribute.values()

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

    deviceController.setCompletionListener(ChipControllerCallback())

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

    binding.selectFirmwareFileBtn.setOnClickListener { selectFirmwareFileBtnClick() }
    binding.updateOTAStatusBtn.setOnClickListener { updateOTAStatusBtnClick() }
    binding.announceOTAProviderBtn.setOnClickListener {
      scope.launch { sendAnnounceOTAProviderBtnClick() }
    }

    binding.writeAclBtn.setOnClickListener { scope.launch { sendAclBtnClick() } }

    binding.readAttributeBtn.setOnClickListener { scope.launch { readAttributeBtnClick() } }

    binding.writeAttributeBtn.setOnClickListener { scope.launch { writeAttributeBtnClick() } }

    setQueryImageSpinnerListener()

    val attributeNames = attributeList.map { it.name }

    binding.attributeSp.adapter =
      ArrayAdapter(requireContext(), android.R.layout.simple_spinner_dropdown_item, attributeNames)

    binding.vendorIdEd.setText(ChipClient.VENDOR_ID.toString())
    binding.delayActionTimeEd.setText("0")

    deviceController.startOTAProvider(otaProviderCallback)
    return binding.root
  }

  private suspend fun sendAclBtnClick() {
    val endpointId = 0
    val clusterId = ClusterIDMapping.AccessControl.ID
    val attributeId = ClusterIDMapping.AccessControl.Attribute.Acl.id

    val attributePath = ChipAttributePath.newInstance(endpointId, clusterId, attributeId)
    val devicePtr =
      try {
        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId)
      } catch (e: IllegalStateException) {
        Log.d(TAG, "getConnectedDevicePointer exception", e)
        showMessage("Get DevicePointer fail!")
        return
      }
    deviceController.readAttributePath(
      object : ReportCallback {
        override fun onError(
          attributePath: ChipAttributePath?,
          eventPath: ChipEventPath?,
          e: Exception
        ) {
          Log.d(TAG, "onError : ", e)
          showMessage("Error : $e")
        }

        override fun onReport(nodeState: NodeState?) {
          Log.d(TAG, "onResponse")
          val tlv =
            nodeState
              ?.getEndpointState(endpointId)
              ?.getClusterState(clusterId)
              ?.getAttributeState(attributeId)
              ?.tlv
          requireActivity().runOnUiThread { showAddAccessControlDialog(tlv) }
        }
      },
      devicePtr,
      listOf(attributePath),
      0
    )
  }

  private fun showAddAccessControlDialog(tlv: ByteArray?) {
    if (tlv == null) {
      Log.d(TAG, "Access Control read fail")
      showMessage("Access Control read fail")
      return
    }

    val dialogView =
      requireActivity().layoutInflater.inflate(R.layout.add_access_control_dialog, null)
    val groupIdEd = dialogView.findViewById<EditText>(R.id.groupIdEd)
    groupIdEd.visibility = View.GONE
    val nodeIdEd = dialogView.findViewById<EditText>(R.id.nodeIdEd)
    nodeIdEd.visibility = View.VISIBLE
    val accessControlEntrySp = dialogView.findViewById<Spinner>(R.id.accessControlEntrySp)
    accessControlEntrySp.adapter =
      ArrayAdapter(
        requireContext(),
        android.R.layout.simple_spinner_dropdown_item,
        GroupSettingFragment.Companion.AccessControlEntry.values()
      )

    val dialog = AlertDialog.Builder(requireContext()).apply { setView(dialogView) }.create()
    dialogView.findViewById<Button>(R.id.addAccessControlBtn).setOnClickListener {
      scope.launch {
        sendAccessControl(
          tlv,
          nodeIdEd.text.toString().toULong(),
          GroupSettingFragment.Companion.AccessControlEntry.valueOf(
              accessControlEntrySp.selectedItem.toString()
            )
            .id
        )
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }
    dialog.show()
  }

  private suspend fun sendAccessControl(tlv: ByteArray, nodeId: ULong, privilege: UInt) {
    val tlvWriter = TlvWriter().startArray(AnonymousTag)
    var entryStructList: List<AccessControlClusterAccessControlEntryStruct>
    TlvReader(tlv).also {
      entryStructList = buildList {
        it.enterArray(AnonymousTag)
        while (!it.isEndOfContainer()) {
          add(AccessControlClusterAccessControlEntryStruct.fromTlv(AnonymousTag, it))
        }
        it.exitContainer()
      }
    }

    // If GroupID is already added to AccessControl, do not add it.
    for (entry in entryStructList) {
      if (
        entry.authMode == 2U /* CASE */ &&
          entry.subjects != null &&
          entry.subjects!!.contains(nodeId)
      ) {
        continue
      }

      entry.toTlv(AnonymousTag, tlvWriter)
    }

    val newEntry =
      AccessControlClusterAccessControlEntryStruct(
        privilege,
        2U /* CASE */,
        listOf(nodeId),
        null,
        deviceController.fabricIndex.toUInt()
      )
    newEntry.toTlv(AnonymousTag, tlvWriter)
    tlvWriter.endArray()

    val devicePtr =
      try {
        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId)
      } catch (e: IllegalStateException) {
        Log.d(TAG, "getConnectedDevicePointer exception", e)
        showMessage("Get DevicePointer fail!")
        return
      }

    deviceController.write(
      object : WriteAttributesCallback {
        override fun onError(attributePath: ChipAttributePath?, e: Exception?) {
          Log.d(TAG, "onError : ", e)
          showMessage("Error : ${e.toString()}")
        }

        override fun onResponse(attributePath: ChipAttributePath, status: Status) {
          Log.d(TAG, "onResponse")
          showMessage("$attributePath : Write response: $status")
        }
      },
      devicePtr,
      listOf(
        AttributeWriteRequest.newInstance(
          0,
          ClusterIDMapping.AccessControl.ID,
          ClusterIDMapping.AccessControl.Attribute.Acl.id,
          tlvWriter.getEncoded()
        )
      ),
      0,
      0
    )
  }

  private suspend fun readAttributeBtnClick() {
    val attribute = attributeList[binding.attributeSp.selectedItemPosition]
    val endpointId = OTA_REQUESTER_ENDPOINT_ID
    val clusterId = ClusterIDMapping.OtaSoftwareUpdateRequestor.ID
    val attributeId = attribute.id
    val path = ChipAttributePath.newInstance(endpointId, clusterId, attributeId)
    val devicePtr =
      try {
        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId)
      } catch (e: IllegalStateException) {
        Log.d(TAG, "getConnectedDevicePointer exception", e)
        showMessage("Get DevicePointer fail!")
        return
      }
    deviceController.readAttributePath(
      object : ReportCallback {
        override fun onError(
          attributePath: ChipAttributePath?,
          eventPath: ChipEventPath?,
          e: Exception
        ) {
          requireActivity().runOnUiThread {
            Toast.makeText(
                requireActivity(),
                R.string.ota_provider_invalid_attribute,
                Toast.LENGTH_SHORT
              )
              .show()
          }
        }

        override fun onReport(nodeState: NodeState?) {
          val tlv =
            nodeState
              ?.getEndpointState(endpointId)
              ?.getClusterState(clusterId)
              ?.getAttributeState(attributeId)
              ?.tlv

          val value = tlv?.let { TlvReader(it).toAny() }
          Log.i(TAG, "OtaSoftwareUpdateRequestor ${attribute.name} value: $value")
          showMessage("OtaSoftwareUpdateRequestor ${attribute.name} value: $value")
        }
      },
      devicePtr,
      listOf<ChipAttributePath>(path),
      0
    )
  }

  private fun writeAttributeBtnClick() {
    val attribute = attributeList[binding.attributeSp.selectedItemPosition]
    if (attribute != ClusterIDMapping.OtaSoftwareUpdateRequestor.Attribute.DefaultOTAProviders) {
      requireActivity().runOnUiThread {
        Toast.makeText(
            requireActivity(),
            R.string.ota_provider_invalid_attribute,
            Toast.LENGTH_SHORT
          )
          .show()
      }
      return
    }
    val dialogView =
      requireActivity().layoutInflater.inflate(R.layout.write_default_otaproviders_dialog, null)
    val fabricIndexEd = dialogView.findViewById<EditText>(R.id.fabricIndexEd)
    val providerNodeIdEd = dialogView.findViewById<EditText>(R.id.providerNodeIdEd)
    val endpointIdEd = dialogView.findViewById<EditText>(R.id.endpointIdEd)

    fabricIndexEd.setText(deviceController.fabricIndex.toUInt().toString())
    providerNodeIdEd.setText(deviceController.controllerNodeId.toULong().toString())
    endpointIdEd.setText(OTA_PROVIDER_ENDPOINT_ID.toUInt().toString())

    val dialog = AlertDialog.Builder(requireContext()).apply { setView(dialogView) }.create()

    dialogView.findViewById<Button>(R.id.writeDefaultOtaProvidersBtn).setOnClickListener {
      scope.launch {
        sendWriteDefaultOTAProviders(
          providerNodeIdEd.text.toString().toULong(),
          endpointIdEd.text.toString().toUInt(),
          fabricIndexEd.text.toString().toUInt()
        )
        requireActivity().runOnUiThread { dialog.dismiss() }
      }
    }
    dialog.show()
  }

  private suspend fun sendWriteDefaultOTAProviders(
    providerNodeId: ULong,
    endpointId: UInt,
    fabricIndex: UInt
  ) {
    val endpoint = OTA_REQUESTER_ENDPOINT_ID
    val clusterId = ClusterIDMapping.OtaSoftwareUpdateRequestor.ID
    val attributeId = ClusterIDMapping.OtaSoftwareUpdateRequestor.Attribute.DefaultOTAProviders.id

    val tlv =
      TlvWriter()
        .apply {
          startArray(AnonymousTag)
          OtaSoftwareUpdateRequestorClusterProviderLocation(providerNodeId, endpointId, fabricIndex)
            .toTlv(AnonymousTag, this)
          endArray()
        }
        .getEncoded()

    val writeRequest = AttributeWriteRequest.newInstance(endpoint, clusterId, attributeId, tlv)

    val devicePtr =
      try {
        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId)
      } catch (e: IllegalStateException) {
        Log.d(TAG, "getConnectedDevicePointer exception", e)
        showMessage("Get DevicePointer fail!")
        return
      }

    deviceController.write(
      object : WriteAttributesCallback {
        override fun onError(attributePath: ChipAttributePath?, e: Exception?) {
          Log.d(TAG, "onError")
          showMessage("error : ${e.toString()}")
        }

        override fun onResponse(attributePath: ChipAttributePath, status: Status) {
          Log.d(TAG, "onResponse")
          showMessage("$attributePath : Write response: $status")
        }
      },
      devicePtr,
      listOf<AttributeWriteRequest>(writeRequest),
      0,
      0
    )
  }

  private fun setQueryImageSpinnerListener() {
    val statusList = QueryImageResponseStatusEnum.values()
    binding.titleStatusSp.adapter =
      ArrayAdapter(requireContext(), android.R.layout.simple_spinner_dropdown_item, statusList)
    binding.titleStatusSp.onItemSelectedListener =
      object : AdapterView.OnItemSelectedListener {
        override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
          val isBusy = statusList[position] == QueryImageResponseStatusEnum.Busy

          requireActivity().runOnUiThread {
            binding.delayActionTimeTv.visibility =
              if (isBusy) {
                View.VISIBLE
              } else {
                View.GONE
              }
            binding.delayActionTimeEd.visibility = binding.delayActionTimeTv.visibility
          }
        }

        override fun onNothingSelected(parent: AdapterView<*>?) {
          Log.d(TAG, "onNothingSelected")
        }
      }
  }

  private fun selectFirmwareFileBtnClick() {
    startActivityForResult(
      Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        type = "*/*"
      },
      REQUEST_CODE_OPEN_SAF
    )
  }

  private fun getInputStream(uri: Uri?): InputStream? {
    if (uri == null) {
      return null
    }
    return requireContext().contentResolver.openInputStream(uri)
  }

  private fun queryName(uri: Uri?): String? {
    if (uri == null) {
      return null
    }
    val cursor = requireContext().contentResolver.query(uri, null, null, null, null)
    return cursor?.let { c ->
      val nameIndex = c.getColumnIndex(OpenableColumns.DISPLAY_NAME)
      c.moveToFirst()

      val name = cursor.getString(nameIndex)
      c.close()
      name
    }
  }

  override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
    super.onActivityResult(requestCode, resultCode, intent)
    if (resultCode != Activity.RESULT_OK || intent == null) {
      return
    }
    val uri = intent.data
    if (uri == null) {
      Log.d(TAG, "onActivityResult : null")
      return
    }
    val filename = queryName(uri)
    fileUri = uri
    requireActivity().runOnUiThread { binding.firmwareFileTv.text = filename }
  }

  private fun updateOTAStatusBtnClick() {
    val version = 2L
    val versionString = "2.0"

    val filename = binding.firmwareFileTv.text.toString()
    Log.d(TAG, "updateOTAStatusBtnClick : $filename")

    when (binding.titleStatusSp.selectedItem.toString()) {
      QueryImageResponseStatusEnum.UpdateAvailable.name ->
        otaProviderCallback.setOTAFile(version, versionString, filename, fileUri)
      QueryImageResponseStatusEnum.Busy.name ->
        otaProviderCallback.setOTABusyError(
          binding.delayActionTimeEd.text.toString().toUInt(),
          binding.titleUserConsentNeededSp.selectedItem.toString().toBoolean()
        )
      QueryImageResponseStatusEnum.NotAvailable.name ->
        otaProviderCallback.setOTANotAvailableError(
          binding.titleUserConsentNeededSp.selectedItem.toString().toBoolean()
        )
    }
  }

  private suspend fun sendAnnounceOTAProviderBtnClick() {
    requireActivity().runOnUiThread { updateOTAStatusBtnClick() }

    val devicePtr =
      try {
        ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId)
      } catch (e: IllegalStateException) {
        Log.d(TAG, "getConnectedDevicePointer exception", e)
        showMessage("Get DevicePointer fail!")
        return
      }

    val otaRequestCluster =
      ChipClusters.OtaSoftwareUpdateRequestorCluster(devicePtr, OTA_REQUESTER_ENDPOINT_ID)
    otaRequestCluster.announceOTAProvider(
      object : DefaultClusterCallback {
        override fun onSuccess() {
          showMessage("announceOTAProvider command success")
          Log.e(TAG, "announceOTAProvider command success")
        }

        override fun onError(ex: java.lang.Exception?) {
          showMessage("announceOTAProvider command failure $ex")
          Log.e(TAG, "announceOTAProvider command failure", ex)
        }
      },
      deviceController.controllerNodeId.toULong().toLong(),
      vendorId,
      0 /* AnnounceReason */,
      Optional.empty(),
      OTA_PROVIDER_ENDPOINT_ID
    )
  }

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

  inner class OtaProviderCallback : OTAProviderDelegate {
    private var fileName: String? = null
    private var version: Long = 0
    private var versionString: String? = null
    private var uri: Uri? = null

    private var inputStream: InputStream? = null
    private var bufferedInputStream: BufferedInputStream? = null

    private var status: QueryImageResponseStatusEnum? = null
    private var delayedTime: UInt? = null
    private var userConsentNeeded: Boolean? = null

    fun setOTAFile(
      version: Long,
      versionString: String,
      fileName: String,
      uri: Uri?,
      userConsentNeeded: Boolean? = null
    ) {
      this.status = QueryImageResponseStatusEnum.UpdateAvailable
      this.version = version
      this.versionString = versionString
      this.fileName = fileName
      this.uri = uri
      this.delayedTime = null
      this.userConsentNeeded = userConsentNeeded
    }

    fun setOTABusyError(delayedTime: UInt, userConsentNeeded: Boolean? = null) {
      this.status = QueryImageResponseStatusEnum.Busy
      this.delayedTime = delayedTime
      this.userConsentNeeded = userConsentNeeded
    }

    fun setOTANotAvailableError(userConsentNeeded: Boolean? = null) {
      this.status = QueryImageResponseStatusEnum.NotAvailable
      this.delayedTime = null
      this.userConsentNeeded = userConsentNeeded
    }

    override fun handleQueryImage(
      vendorId: Int,
      productId: Int,
      softwareVersion: Long,
      hardwareVersion: Int?,
      location: String?,
      requestorCanConsent: Boolean?,
      metadataForProvider: ByteArray?
    ): OTAProviderDelegate.QueryImageResponse? {
      Log.d(
        TAG,
        "handleQueryImage, $vendorId, $productId, $softwareVersion, $hardwareVersion, $location"
      )

      return when (status) {
        QueryImageResponseStatusEnum.UpdateAvailable ->
          OTAProviderDelegate.QueryImageResponse(version, versionString, fileName, null)
        QueryImageResponseStatusEnum.Busy ->
          OTAProviderDelegate.QueryImageResponse(
            status,
            delayedTime?.toLong() ?: 0,
            userConsentNeeded ?: false
          )
        QueryImageResponseStatusEnum.NotAvailable ->
          OTAProviderDelegate.QueryImageResponse(status, userConsentNeeded ?: false)
        else -> null
      }
    }

    override fun handleOTAQueryFailure(error: Int) {
      Log.d(TAG, "handleOTAQueryFailure, $error")
      showMessage("handleOTAQueryFailure : $error")
    }

    override fun handleApplyUpdateRequest(
      nodeId: Long,
      newVersion: Long
    ): OTAProviderDelegate.ApplyUpdateResponse {
      Log.d(TAG, "handleApplyUpdateRequest, $nodeId, $newVersion")
      return OTAProviderDelegate.ApplyUpdateResponse(
        OTAProviderDelegate.ApplyUpdateActionEnum.Proceed,
        APPLY_WAITING_TIME
      )
    }

    override fun handleNotifyUpdateApplied(nodeId: Long) {
      Log.d(TAG, "handleNotifyUpdateApplied, $nodeId")
      showMessage("Finish Firmware Update : $nodeId")
    }

    override fun handleBDXTransferSessionBegin(
      nodeId: Long,
      fileDesignator: String?,
      offset: Long
    ) {
      Log.d(TAG, "handleBDXTransferSessionBegin, $nodeId, $fileDesignator, $offset")
      try {
        inputStream = getInputStream(uri)
        bufferedInputStream = BufferedInputStream(inputStream)
      } catch (e: IOException) {
        Log.d(TAG, "exception", e)
        inputStream?.close()
        bufferedInputStream?.close()
        inputStream = null
        bufferedInputStream = null
        return
      }
    }

    override fun handleBDXTransferSessionEnd(errorCode: Long, nodeId: Long) {
      Log.d(TAG, "handleBDXTransferSessionEnd, $errorCode, $nodeId")
      inputStream?.close()
      bufferedInputStream?.close()
      inputStream = null
      bufferedInputStream = null
    }

    override fun handleBDXQuery(
      nodeId: Long,
      blockSize: Int,
      blockIndex: Long,
      bytesToSkip: Long
    ): OTAProviderDelegate.BDXData? {
      // This code is just example code. This code doesn't check blockIndex and bytesToSkip
      // variable.
      Log.d(TAG, "handleBDXQuery, $nodeId, $blockSize, $blockIndex, $bytesToSkip")
      showMessage("sending.. $blockIndex")
      if (bufferedInputStream == null) {
        return OTAProviderDelegate.BDXData(ByteArray(0), true)
      }
      val packet = ByteArray(blockSize)
      val len = bufferedInputStream!!.read(packet)

      val sendPacket =
        if (len < blockSize) {
          packet.copyOf(len)
        } else if (len < 0) {
          ByteArray(0)
        } else {
          packet.clone()
        }

      val isEOF = len < blockSize

      return OTAProviderDelegate.BDXData(sendPacket, isEOF)
    }
  }

  inner class ChipControllerCallback : GenericChipDeviceListener() {
    override fun onCommissioningComplete(nodeId: Long, errorCode: Long) {
      Log.d(TAG, "onCommissioningComplete for nodeId $nodeId: $errorCode")
      showMessage("Address update complete for nodeId $nodeId with code $errorCode")
    }

    override fun onNotifyChipConnectionClosed() {
      Log.d(TAG, "onNotifyChipConnectionClosed")
    }

    override fun onCloseBleComplete() {
      Log.d(TAG, "onCloseBleComplete")
    }

    override fun onError(error: Throwable?) {
      Log.d(TAG, "onError: $error")
    }
  }

  private fun showMessage(msg: String) {
    requireActivity().runOnUiThread { binding.commandStatusTv.text = msg }
  }

  companion object {
    private const val TAG = "OtaProviderClientFragment"

    fun newInstance(): OtaProviderClientFragment = OtaProviderClientFragment()

    private const val REQUEST_CODE_OPEN_SAF = 100

    private const val APPLY_WAITING_TIME = 10L
    private const val OTA_PROVIDER_ENDPOINT_ID = 0
    private const val OTA_REQUESTER_ENDPOINT_ID = 0
  }
}