package com.base.locationsharewhite.ui.main

import android.annotation.SuppressLint
import android.app.Activity
import android.location.Location
import android.os.Looper
import androidx.lifecycle.LifecycleCoroutineScope
import com.base.locationsharewhite.map.MapUtils.getLatLngByLocationManager
import com.base.locationsharewhite.utils.LogEx
import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationCallback
import com.google.android.gms.location.LocationRequest
import com.google.android.gms.location.LocationResult
import com.google.android.gms.location.LocationServices
import com.google.android.gms.maps.model.LatLng
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch


class MainPresenter(
    val activity: Activity
) {

    private val TAG = "MainPresenter"

    //google的地理位置服务
    private var fusedLocationClient: FusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(activity)
    private var googleLocation: LatLng? = null

    @SuppressLint("MissingPermission")
    private fun getGoogleServiceLocation() {
        fusedLocationClient.lastLocation
            .addOnSuccessListener { location: Location? ->
                LogEx.logDebug(TAG, "getGoogleServiceLocation location=$location")
                if (location != null) {
                    val latLng = LatLng(location.latitude, location.longitude)
                    googleLocation = latLng
                    LogEx.logDebug(TAG, "getGoogleServiceLocation latLng=$latLng")
                }
            }
    }

    /**
     * 获取自身位置,
     */
    private fun getMyLocation(): LatLng? {
        var latLng = activity.getLatLngByLocationManager()
        LogEx.logDebug(TAG, "getMyLocation latLng=$latLng")
        if (latLng == null) {
            latLng = googleLocation
        }
        return latLng
    }


    private var locationCallback: LocationCallback? = null

    /**
     * 请求google service地理位置跟新
     */
    @SuppressLint("MissingPermission")
    fun requestLocationUpdates() {

        // 创建LocationRequest对象，并设置参数
        val locationRequest: LocationRequest = LocationRequest.create()
        locationRequest.setInterval(10000) // 设置更新间隔为10秒
        locationRequest.setFastestInterval(5000) // 设置最快更新间隔为5秒
        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY) // 设置位置请求的优先级

        locationCallback = object : LocationCallback() {
            override fun onLocationResult(locationResult: LocationResult) {
                for (location in locationResult.locations) {
                    // 在这里获取最新的经纬度
                    val latitude = location.latitude
                    val longitude = location.longitude
                }
            }
        }

        locationCallback?.let {
            // 请求位置更新
            fusedLocationClient.requestLocationUpdates(locationRequest, it, Looper.getMainLooper())
        }

    }

    /**
     * 取消google service地理位置更新
     */
    fun cancelLocationUpdates() {
        locationCallback?.let {
            fusedLocationClient.removeLocationUpdates(it)
        }
    }

    var uiLocationCallback: ((latLng: LatLng) -> Unit)? = null

    private var locationJob: Job? = null

    fun startLocationJob(lifecycleCoroutineScope: LifecycleCoroutineScope) {
        if (locationJob == null) {
            locationJob = lifecycleCoroutineScope.launch(Dispatchers.IO) {

                while (isActive) {
                    getGoogleServiceLocation()
                    val latLng = getMyLocation()

                    launch(Dispatchers.Main) {
                        latLng?.let { uiLocationCallback?.invoke(it) }
                    }

                    delay(10 * 1000L)
                }

            }
        }
    }

    fun cancelLocationJob() {
        locationJob?.cancel()
        locationJob = null
    }
}