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

package com.danilafe.fencelessgrazing

import android.app.Application
import android.graphics.Color
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.TextView
import android.widget.Toast
import com.android.volley.Request
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.CollarSummary
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.sql.Time
import java.util.*
import kotlin.collections.ArrayList
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 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)
        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()
        mapMarker.position = currentPoint
        mapPolyline.setPoints(points)
        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)
        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()
    }
}