package mx.trackermap.TrackerMap.android.map

import android.content.Intent
import android.graphics.Color
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import kotlinx.coroutines.DelicateCoroutinesApi
import mx.trackermap.TrackerMap.android.R
import mx.trackermap.TrackerMap.android.databinding.UnitMapFragmentBinding
import mx.trackermap.TrackerMap.android.details.DetailsActivity
import mx.trackermap.TrackerMap.android.devices.Action
import mx.trackermap.TrackerMap.android.units.UnitsViewModel
import mx.trackermap.TrackerMap.client.models.UnitInformation
import mx.trackermap.TrackerMap.utils.Formatter
import mx.trackermap.TrackerMap.utils.MarkerType
import mx.trackermap.TrackerMap.utils.SpeedUnit
import org.koin.androidx.viewmodel.ext.android.viewModel

@DelicateCoroutinesApi
class UnitMapFragment : Fragment() {

    private val unitsViewModel: UnitsViewModel by viewModel()

    private var _binding: UnitMapFragmentBinding? = null
    private val binding get() = _binding!!
    private lateinit var unitsMapFragment: MapFragment

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = UnitMapFragmentBinding.inflate(inflater)
        return binding.root
    }

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

        initializeMap()
        setupObservers()
    }

    private fun initializeMap() {
        unitsMapFragment = childFragmentManager.findFragmentById(R.id.unitsMap) as MapFragment
        unitsMapFragment.markerCallback = unitsViewModel::selectUnitWith
    }

    private fun setupObservers() {
        Log.d("MapFragment", "setupObservers()")

        unitsViewModel.units.observe(viewLifecycleOwner) { units ->
            Log.d("UnitMapFragment", "Available units: $units")

            unitsMapFragment.display(units.mapNotNull(this::unitToMarker).toTypedArray())
        }

        unitsViewModel.selectedUnit.observe(viewLifecycleOwner) { selectedUnit ->
            Log.d("UnitMapFragment", "Selected Unit: $selectedUnit")

            binding.mapUnitCard.visibility = if (selectedUnit == null) View.GONE else View.VISIBLE

            selectedUnit?.let { unit ->
                if (unit.position == null || unit.position!!.latitude == null || unit.position!!.longitude == null) {
                    return@let
                }

                binding.apply {
                    context?.let { context ->
                        unit.position?.let { position ->
                            /* Status icon */
                            position.speed?.let { speed ->
                                if (speed >= 2) {
                                    statusIcon.setColorFilter(Color.GREEN)
                                } else {
                                    statusIcon.setColorFilter(Color.RED)
                                }
                            } ?: run {
                                statusIcon.setColorFilter(Color.GRAY)
                            }

                            /* Engine stop */
                            val attributes = position.attributes
                            if (attributes["out1"].toString() == "null") {
                                engineStopIcon.visibility = View.GONE
                            } else {
                                engineStopIcon.visibility = View.VISIBLE
                                engineStopIcon.setImageResource(
                                    when (attributes["out1"].toString()) {
                                        "true" -> R.drawable.ic_baseline_lock_24
                                        "false" -> R.drawable.ic_baseline_lock_open_24
                                        else -> R.drawable.ic_baseline_lock_open_24
                                    }
                                )
                                engineStopIcon.contentDescription =
                                    when (attributes["out1"].toString()) {
                                        "true" -> context.getString(R.string.unit_lock_on)
                                        "false" -> context.getString(R.string.unit_lock_off)
                                        else -> context.getString(R.string.unit_lock_on)
                                    }
                            }
                        }

                        unitName.text = unit.device.name
                        driverName.text = unit.device.contact
                        unitSpeed.text = Formatter.formatSpeed(unit.position?.speed ?: 0.0, SpeedUnit.KMH)
                        lastAddress.text = unit.position?.address
                        unit.position?.fixTime?.let {
                            lastDate.text = Formatter.formatDate(it)
                        }
                        detailsButton.setOnClickListener { itemAction(unit, Action.DETAILS) }
                        reportsButton.setOnClickListener { itemAction(unit, Action.REPORTS) }
                        commandsButton.setOnClickListener { itemAction(unit, Action.COMMANDS) }
                    }
                }

                unitsMapFragment.focusOn(unit.position!!.latitude!!, unit.position!!.longitude!!)
            }
        }
    }

    private fun unitToMarker(unit: UnitInformation): MapFragment.Marker? {
        if (unit.position == null || unit.position!!.latitude == null || unit.position!!.longitude == null) {
            return null
        }

        return MapFragment.Marker(
            unit.position!!.id!!,
            unit.position!!.latitude!!,
            unit.position!!.longitude!!,
            when (unit.device.category?.lowercase()) {
                "animal" -> MarkerType.ANIMAL
                "bicycle" -> MarkerType.BICYCLE
                "boat" -> MarkerType.BOAT
                "bus" -> MarkerType.BUS
                "car" -> MarkerType.CAR
                "crane" -> MarkerType.CRANE
                "helicopter" -> MarkerType.HELICOPTER
                "motorcycle" -> MarkerType.MOTORCYCLE
                "offroad" -> MarkerType.OFFROAD
                "person" -> MarkerType.PERSON
                "pickup" -> MarkerType.PICKUP
                "plane" -> MarkerType.PLANE
                "scooter" -> MarkerType.SCOOTER
                "ship" -> MarkerType.SHIP
                "tractor" -> MarkerType.TRACTOR
                "train" -> MarkerType.TRAIN
                "tram" -> MarkerType.TRAM
                "trolleybus" -> MarkerType.TROLLEYBUS
                "truck" -> MarkerType.TRUCK
                "van" -> MarkerType.VAN
                else -> MarkerType.DEFAULT
            }
        )
    }

    private fun itemAction(unit: UnitInformation, action: Action) {
        when (action) {
            Action.DETAILS, Action.REPORTS, Action.COMMANDS -> {
                Log.d("DevicesFragment", "Action: $action - Unit: $unit")
                val activity = requireActivity()
                val intent = Intent(activity.applicationContext, DetailsActivity::class.java)
                intent.putExtra(DetailsActivity.DEVICE_ID_EXTRA, unit.device.id)
                intent.putExtra(DetailsActivity.ACTION_EXTRA, action)
                startActivity(intent)
            }
            Action.CLICK -> {
                unitsViewModel.selectUnit(unit)
            }
        }
    }

}