package mx.trackermap.TrackerMap.android.map

import android.graphics.BitmapFactory
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.mousebird.maply.*
import kotlinx.coroutines.DelicateCoroutinesApi
import mx.trackermap.TrackerMap.android.R
import mx.trackermap.TrackerMap.android.units.UnitsViewModel
import org.koin.androidx.viewmodel.ext.android.viewModel
import java.io.File

@DelicateCoroutinesApi
class MapFragment: GlobeMapFragment() {

    private val unitsViewModel: UnitsViewModel by viewModel()

    private val markers = mutableListOf<Pair<ScreenMarker, ComponentObject>>()

    override fun chooseDisplayType(): MapDisplayType {
        return MapDisplayType.Map
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        super.onCreateView(inflater, container, savedInstanceState)
        return baseControl.contentView!!
    }

    override fun controlHasStarted() {
        val cacheDirName = "stamen_watercolor6"
        val cacheDir = File(activity!!.cacheDir, cacheDirName)
        cacheDir.mkdir()

        val tileInfo = RemoteTileInfoNew("https://mt0.google.com/vt/lyrs=m&hl=en&x={x}&y={y}&z={z}&s=Ga", 0, 21)
        tileInfo.cacheDir = cacheDir

        val params = SamplingParams()
        params.coordSystem = SphericalMercatorCoordSystem()
        params.coverPoles = true
        params.edgeMatching = true
        params.minZoom = tileInfo.minZoom
        params.maxZoom = tileInfo.maxZoom
        params.singleLevel = true

        val loader = QuadImageLoader(params, tileInfo, baseControl)
        loader.setImageFormat(RenderController.ImageFormat.MaplyImageUShort565)

        val latitude = 23.191 * Math.PI / 180
        val longitude = -100.36 * Math.PI / 180
        val zoom = 0.4
        mapControl.setPositionGeo(longitude, latitude, zoom)
    }

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

        setupObservers()
    }

    @DelicateCoroutinesApi
    private fun setupObservers() {
        unitsViewModel.units.observe(viewLifecycleOwner) { units ->
            /* Remove all markers */
            markers.forEach {
                mapControl.removeObject(it.second, ThreadMode.ThreadAny)
            }
            markers.clear()

            /* Reinsert markers from units */
            units.forEach { unit ->
                unit.position?.let { position ->
                    if (position.longitude != null && position.longitude != null) {
                        val icon =
                            BitmapFactory.decodeResource(
                                activity!!.resources,
                                when (unit.device.category?.lowercase()) {
                                    "animal" -> R.drawable.map_animal
                                    "bicycle" -> R.drawable.map_bicycle
                                    "boat" -> R.drawable.map_boat
                                    "bus" -> R.drawable.map_bus
                                    "car" -> R.drawable.map_car
                                    "crane" -> R.drawable.map_crane
                                    "default" -> R.drawable.map_default
                                    "helicopter" -> R.drawable.map_helicopter
                                    "motorcycle" -> R.drawable.map_motorcycle
                                    "offroad" -> R.drawable.map_offroad
                                    "person" -> R.drawable.map_person
                                    "pickup" -> R.drawable.map_pickup
                                    "plane" -> R.drawable.map_plane
                                    "scooter" -> R.drawable.map_scooter
                                    "ship" -> R.drawable.map_ship
                                    "tractor" -> R.drawable.map_tractor
                                    "train" -> R.drawable.map_train
                                    "tram" -> R.drawable.map_tram
                                    "trolleybus" -> R.drawable.map_trolleybus
                                    "truck" -> R.drawable.map_truck
                                    "van" -> R.drawable.map_van
                                    else -> R.drawable.map_default
                                }
                            )

                        val marker = ScreenMarker()
                        val markerSize = Point2d(144.0, 144.0)

                        marker.loc = Point2d.FromDegrees(position.longitude!!, position.latitude!!)
                        marker.image = icon
                        marker.size = markerSize
                        marker.userObject = unit

                        /* Add marker to map */
                        val markerInfo = MarkerInfo()
                        val componentObject = mapControl.addScreenMarker(marker, markerInfo, ThreadMode.ThreadAny)
                        markers.add(marker to componentObject)
                    }
                }
            }
        }
        unitsViewModel.selectedUnit.observe(viewLifecycleOwner) {
            it?.let { unit ->
                unit.position?.let { position ->
                    val latitude = position.latitude!! * Math.PI / 180
                    val longitude = position.longitude!! * Math.PI / 180
                    val zoom = 0.000008
                    mapControl.setPositionGeo(longitude, latitude, zoom)
                }
            }
        }
    }
}