package mx.trackermap.TrackerMap.android.units

import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.view.View
import android.view.inputmethod.InputMethodManager
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.PopupMenu
import androidx.appcompat.widget.TooltipCompat
import androidx.core.widget.doAfterTextChanged
import androidx.fragment.app.FragmentTransaction.TRANSIT_FRAGMENT_FADE
import androidx.fragment.app.commit
import kotlinx.coroutines.DelicateCoroutinesApi
import mx.trackermap.TrackerMap.android.R
import mx.trackermap.TrackerMap.android.databinding.UnitsActivityBinding
import mx.trackermap.TrackerMap.android.devices.DevicesFragment
import mx.trackermap.TrackerMap.android.map.UnitMapFragment
import mx.trackermap.TrackerMap.android.session.UserInformationActivity
import mx.trackermap.TrackerMap.client.models.MapLayer
import org.koin.androidx.viewmodel.ext.android.viewModel
import kotlin.time.ExperimentalTime

@DelicateCoroutinesApi
@ExperimentalTime
class UnitsActivity : AppCompatActivity() {

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

    private val unitsViewModel: UnitsViewModel by viewModel()
    private val mapFragment: UnitMapFragment by lazy {
        UnitMapFragment(unitsViewModel)
    }
    private val devicesFragment: DevicesFragment by lazy {
        DevicesFragment(unitsViewModel)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        _binding = UnitsActivityBinding.inflate(layoutInflater)
        setContentView(binding.root)

        setupViews()
        setupEvents()
    }

    override fun onResume() {
        super.onResume()

        setupObservers()
    }

    override fun onPause() {
        super.onPause()

        removeObservers()
    }

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

    private fun setupViews() {
        TooltipCompat.setTooltipText(binding.userButton, getString(R.string.open_profile))
        TooltipCompat.setTooltipText(binding.mapLayerToggle, getString(R.string.switch_layer))
    }

    private fun setupEvents() {
        binding.userButton.setOnClickListener {
            val intent = Intent(applicationContext, UserInformationActivity::class.java)
            startActivity(intent)
        }
        binding.displayModeToggle.setOnClickListener {
            unitsViewModel.toggleDisplayMode()
        }
        binding.mapLayerToggle.setOnClickListener {
            showLayersPopUp(it)
        }
        binding.searchInput.doAfterTextChanged {
            Log.d("UnitsActivity", "Search changed to ${it.toString()}")
            if (unitsViewModel.unitsDisplayMode.value == UnitsViewModel.UnitsDisplayMode.MAP) {
                unitsViewModel.setDisplayMode(UnitsViewModel.UnitsDisplayMode.LIST)
            }
            unitsViewModel.search(it.toString())
        }
        binding.searchInputLayout.setEndIconOnClickListener {
            unfocusSearch(true)
        }
    }

    private fun showLayersPopUp(view: View) {
        val popOver = PopupMenu(this, view)
        popOver.menuInflater.inflate(R.menu.map_layers, popOver.menu)
        popOver.setOnMenuItemClickListener { item ->
            val layer = when (item.itemId) {
                R.id.layerStreets -> MapLayer.Type.STREETS
                R.id.layerSatellite -> MapLayer.Type.SATELLITE
                else -> MapLayer.Type.STREETS
            }
            unitsViewModel.setMapLayerType(layer)
            true
        }
        popOver.show()
    }

    private fun unfocusSearch(clearText: Boolean = false) {
        val manager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        manager.hideSoftInputFromWindow(binding.searchInput.windowToken, 0)
        if (clearText) {
            binding.searchInput.text?.clear()
        }
        binding.searchInput.clearFocus()
    }

    private fun setupObservers() {
        unitsViewModel.units.observe(this) {
            Toast.makeText(this, getString(R.string.shared_loading), Toast.LENGTH_SHORT).show()
        }
        unitsViewModel.unitsDisplayMode.observe(this) { displayMode ->
            binding.displayModeToggle.setImageResource(
                when (displayMode) {
                    UnitsViewModel.UnitsDisplayMode.LIST -> R.drawable.icon_map
                    UnitsViewModel.UnitsDisplayMode.MAP -> R.drawable.icon_list
                    else -> R.drawable.icon_list
                }
            )
            binding.displayModeToggle.contentDescription = getString(
                when (displayMode) {
                    UnitsViewModel.UnitsDisplayMode.LIST -> R.string.toggle_map
                    UnitsViewModel.UnitsDisplayMode.MAP -> R.string.toggle_list
                    else -> R.string.toggle_list
                }
            )
            TooltipCompat.setTooltipText(binding.displayModeToggle,
                getString(when (displayMode) {
                    UnitsViewModel.UnitsDisplayMode.LIST -> R.string.toggle_map
                    UnitsViewModel.UnitsDisplayMode.MAP -> R.string.toggle_list
                    else -> R.string.toggle_list
                })
            )

            binding.mapLayerToggle.visibility =
                when (displayMode) {
                    UnitsViewModel.UnitsDisplayMode.LIST -> View.GONE
                    UnitsViewModel.UnitsDisplayMode.MAP -> View.VISIBLE
                    else -> View.VISIBLE
                }

            val newFragment =
                when (displayMode) {
                    UnitsViewModel.UnitsDisplayMode.LIST -> devicesFragment
                    UnitsViewModel.UnitsDisplayMode.MAP -> mapFragment
                    else -> mapFragment
                }
            supportFragmentManager.commit {
                replace(R.id.displayContainer, newFragment)
                setTransition(TRANSIT_FRAGMENT_FADE)
            }
        }
        unitsViewModel.selectedUnit.observe(this) {
            unfocusSearch(clearText = true)
        }
    }

    private fun removeObservers() {
        unitsViewModel.units.removeObservers(this)
        unitsViewModel.unitsDisplayMode.removeObservers(this)
        unitsViewModel.selectedUnit.removeObservers(this)
    }

    override fun onBackPressed() {
        if (unitsViewModel.unitsDisplayMode.value == UnitsViewModel.UnitsDisplayMode.LIST) {
            unitsViewModel.setDisplayMode(UnitsViewModel.UnitsDisplayMode.MAP)
        } else {
            super.onBackPressed()
        }
    }
}