package mx.trackermap.TrackerMap.android.map

import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.mousebird.maply.*
import java.io.File
import kotlinx.coroutines.DelicateCoroutinesApi
import mx.trackermap.TrackerMap.android.R
import mx.trackermap.TrackerMap.utils.MarkerType

typealias MarkerCallback = (Int?) -> Unit

@DelicateCoroutinesApi
class MapFragment : GlobeMapFragment() {

    data class Marker(
        val id: Int,
        val latitude: Double,
        val longitude: Double,
        val type: MarkerType = MarkerType.DEFAULT
    )

    var markerCallback: MarkerCallback? = null

    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(
            getString(R.string.maps_tile_url),
            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
        val longitude = -100.36
        focusOn(latitude, longitude, zoom = 0.4, animated = false)
    }

    override fun userDidSelect(
        mapControl: MapController?,
        selObjs: Array<out SelectedObject>?,
        loc: Point2d?,
        screenLoc: Point2d?
    ) {
        super.userDidSelect(mapControl, selObjs, loc, screenLoc)

        selObjs?.forEach { selectedObject ->
            if (selectedObject.selObj is ScreenMarker) {
                val screenMarker = selectedObject.selObj as ScreenMarker
                val markerId = screenMarker.userObject as Int
                Log.d("MapFragment", "Selected marker with id: $markerId")

                markerCallback?.let { it(markerId) }
            }
        }
    }

    override fun userDidTap(mapControl: MapController?, loc: Point2d?, screenLoc: Point2d?) {
        super.userDidTap(mapControl, loc, screenLoc)

        markerCallback?.let { it(null) }
    }

    fun clear() {
        mapControl.removeObjects(
            markers.map { it.second },
            ThreadMode.ThreadAny
        )
    }

    fun display(markers: Array<Marker>) {
        Log.d("MapFragment", "Displaying markers")

        clear()

        val screenMarkers = markers.map { marker ->
            val screenMarker = ScreenMarker()
            val markerSize = Point2d(144.0, 144.0)

            screenMarker.loc = Point2d.FromDegrees(marker.longitude, marker.latitude)
            screenMarker.image = getIcon(marker.type)
            screenMarker.size = markerSize
            screenMarker.userObject = marker.id
            screenMarker.selectable = true

            screenMarker
        }
        mapControl.addScreenMarkers(
            screenMarkers,
            MarkerInfo(),
            ThreadMode.ThreadAny
        )
    }

    fun focusOn(latitude: Double, longitude: Double, zoom: Double = 0.0000144, animated: Boolean = true) {
        val lat = latitude * Math.PI / 180
        val lon = longitude * Math.PI / 180
        if (animated) {
            mapControl.animatePositionGeo(lon, lat, zoom, 0.5)
        } else {
            mapControl.setPositionGeo(lon, lat, zoom)
        }
    }

    private fun getIcon(markerType: MarkerType): Bitmap {
        return BitmapFactory.decodeResource(
            activity!!.resources,
            when (markerType) {
                MarkerType.ANIMAL -> R.drawable.map_animal
                MarkerType.BICYCLE -> R.drawable.map_bicycle
                MarkerType.BOAT -> R.drawable.map_boat
                MarkerType.BUS -> R.drawable.map_bus
                MarkerType.CAR -> R.drawable.map_car
                MarkerType.CRANE -> R.drawable.map_crane
                MarkerType.DEFAULT -> R.drawable.map_default
                MarkerType.HELICOPTER -> R.drawable.map_helicopter
                MarkerType.MOTORCYCLE -> R.drawable.map_motorcycle
                MarkerType.OFFROAD -> R.drawable.map_offroad
                MarkerType.PERSON -> R.drawable.map_person
                MarkerType.PICKUP -> R.drawable.map_pickup
                MarkerType.PLANE -> R.drawable.map_plane
                MarkerType.SCOOTER -> R.drawable.map_scooter
                MarkerType.SHIP -> R.drawable.map_ship
                MarkerType.TRACTOR -> R.drawable.map_tractor
                MarkerType.TRAIN -> R.drawable.map_train
                MarkerType.TRAM -> R.drawable.map_tram
                MarkerType.TROLLEYBUS -> R.drawable.map_trolleybus
                MarkerType.TRUCK -> R.drawable.map_truck
                MarkerType.VAN -> R.drawable.map_van
            }
        )
    }
}