app/app/src/main/java/com/danilafe/fencelessgrazing/CollarDetailActivity.kt

package com.danilafe.fencelessgrazing

import android.graphics.Color
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.TextView
import android.widget.Toast
import com.android.volley.RequestQueue
import com.android.volley.Response
import com.android.volley.toolbox.Volley
import com.danilafe.fencelessgrazing.model.CollarPos
import com.danilafe.fencelessgrazing.model.Polygon
import com.danilafe.fencelessgrazing.requests.CollarDetailRequest
import com.danilafe.fencelessgrazing.requests.CollarHistoryRequest
import org.osmdroid.util.GeoPoint
import org.osmdroid.views.MapView
import org.osmdroid.views.overlay.Marker
import org.osmdroid.views.overlay.Polyline
import java.util.*
import kotlin.concurrent.timerTask

class CollarDetailActivity : AppCompatActivity() {

    private lateinit var collarName: TextView
    private lateinit var collarPos: TextView

    private lateinit var token: String
    private lateinit var queue: RequestQueue
    private var collarId: Int = -1

    private var centerSet: Boolean = false
    private lateinit var map: MapView

    private var refreshTimer = Timer()

    private lateinit var mapPolygon: org.osmdroid.views.overlay.Polygon
    private var boundingBox: Polygon? = null
        set(newValue) {
            if(newValue != null) updateBoundingBox(field, newValue)
            else clearBoundingBox()
            field = newValue
        }

    private lateinit var mapMarker: Marker
    private lateinit var mapPolyline: Polyline
    private var dataPoints: List<GeoPoint> = listOf()
        set(newValue) {
            if(newValue.isNotEmpty()) updateAnimalHistory(newValue)
            else clearAnimalHistory()
            field = newValue
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_collar_detail)

        collarName = findViewById(R.id.collarName)
        collarPos = findViewById(R.id.collarPos)

        token = intent.getStringExtra("token")!!
        collarId = intent.getIntExtra("identifier", -1)
        queue = Volley.newRequestQueue(this)

        map = findViewById(R.id.detailMap)
        map.controller.setZoom(9.5)
        mapPolygon = org.osmdroid.views.overlay.Polygon(map)
        mapMarker = Marker(map)
        mapPolyline = Polyline(map)
        configureMapPolygon()

        boundingBox = Polygon(
            listOf(
                CollarPos("20", "20"),
                CollarPos("20", "21"),
                CollarPos("21", "21"),
                CollarPos("21", "20")
            )
        )
    }

    override fun onPause() {
        super.onPause()
        map.onPause()
        refreshTimer.cancel()
        refreshTimer.purge()
    }

    override fun onResume() {
        super.onResume()
        map.onResume()
        refreshTimer = Timer()
        refreshTimer.schedule(timerTask { triggerRefresh() }, 0L, 5000L)
    }

    private fun triggerRefresh() {
        val historyRequest = CollarHistoryRequest(getString(R.string.apiUrl), collarId, token,
            Response.Listener {
                dataPoints = it.map { p -> GeoPoint(p.longitude.toDouble(), p.latitude.toDouble()) }
            },
            Response.ErrorListener {
                Toast.makeText(this, "Failed to retrieve history of collar", Toast.LENGTH_SHORT).show()
            }
        )
        val detailRequest = CollarDetailRequest(getString(R.string.apiUrl), collarId, token,
            Response.Listener {
                collarName.text = it.name
            },
            Response.ErrorListener {
                Toast.makeText(this, "Failed to retrieve details of collar", Toast.LENGTH_SHORT).show()
            }
        )
        queue.add(historyRequest)
        queue.add(detailRequest)
    }

    private fun configureMapPolygon() {
        mapPolygon.fillPaint.color = Color.parseColor("#32a852")
        mapPolygon.fillPaint.alpha = 127
        mapPolygon.outlinePaint.color = Color.parseColor("#227539")
        mapPolygon.outlinePaint.strokeWidth = 0.0f
        mapPolygon.title = "Valid Grazing Area"
    }

    private fun updateAnimalHistory(points : List<GeoPoint>) {
        val currentPoint = points.first()
        collarPos.text = getString(R.string.collarSummaryLocation, currentPoint.longitude, currentPoint.latitude)
        if(!map.overlays.contains(mapMarker)) map.overlays.add(mapMarker)
        if(!map.overlays.contains(mapPolyline)) map.overlays.add(mapPolyline)
        mapMarker.position = currentPoint
        mapPolyline.setPoints(points)
        if(!centerSet) {
            centerSet = true
            map.controller.setCenter(currentPoint)
        }
        map.invalidate()
    }

    private fun clearAnimalHistory() {
        map.overlays.remove(mapMarker)
        map.overlays.remove(mapPolyline)
        map.invalidate()
    }

    private fun updateBoundingBox(oldValue: Polygon?, polygon: Polygon) {
        if(oldValue == null) map.overlays.add(mapPolygon)
        val points = polygon.dataPoints.map { GeoPoint(it.longitude.toDouble(), it.latitude.toDouble()) }
        val polygonPoints = points.toMutableList()
        polygonPoints.add(polygonPoints[0])
        mapPolygon.points = polygonPoints
        map.invalidate()
    }

    private fun clearBoundingBox() {
        map.overlays.remove(mapPolygon)
        map.invalidate()
    }
}