package com.xw.common.utils

import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.content.pm.PackageManager
import android.location.LocationManager
import android.os.Build
import android.os.Bundle
import android.provider.Settings
import androidx.core.net.toUri
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
import com.amap.api.location.AMapLocation
import com.amap.api.location.AMapLocationClient
import com.amap.api.location.AMapLocationClientOption
import com.amap.api.location.AMapLocationListener
import com.amap.api.maps.model.LatLng
import com.blankj.utilcode.util.ToastUtils
import com.hjq.permissions.OnPermissionCallback
import com.hjq.permissions.Permission
import com.hjq.permissions.XXPermissions
import com.xw.common.CommonDialog
import com.xw.common.Constants

/**
 * GPS
 *
 */
class GpsHelper(
    var context: Context,
    var listener: OnMapLocation,
    var isOnceLocation: Boolean, // 是否定位一次
    var isAutomatic: Boolean = true,// isAutomatic 是否自动开启定位
    var savedInstanceState: Bundle?,
    var interval: Long = 2000L,//默认定位间隔
) : AMapLocationListener, LifecycleObserver {
    val TAG = "zmc-GpsHelper"

    // 声明AMapLocationClient类对象
    private var mLocationClient: AMapLocationClient? = null

    // 声明mLocationOption对象
    private lateinit var mLocationOption: AMapLocationClientOption

    // GPS 状态广播接收器
    private var gpsStatusReceiver: GpsStatusReceiver? = null

    // 标记是否正在监听 GPS 状态（用于避免重复注册）
    private var isWatchingGpsStatus = false

    // 是否已经发起过位置权限申请（避免每次 onResume 都重复 request 导致权限 Activity 反复拉起、onResume 死循环）
    private var hasRequestedPermission = false

    // 是否已经弹过"权限被拒绝"提示框（避免多次弹出）
    private var hasShownDeniedDialog = false

    // 定位权限组
    private val locationPermissions =
        arrayOf(Permission.ACCESS_FINE_LOCATION, Permission.ACCESS_COARSE_LOCATION)

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {
        LogUtils.i(TAG, "onResume isAutomatic = $isAutomatic")
        if (savedInstanceState == null && isAutomatic)
            checkAndStartLocation()
    }

    /**
     * 检查定位状态并决定是否开始定位或监听 GPS 状态
     */
    private fun checkAndStartLocation() {
        if (isLocationEnabledModern()) {
            // 定位已开启，停止监听（如果正在监听），直接开始定位
            stopWatchingGpsStatus()
            startLocation()
        } else {
            // 定位未开启，先回调 null 通知外部，然后开始监听 GPS 状态变化
            LogUtils.w(TAG, "定位未开启，开始监听 GPS 状态变化")
            listener.location(null)
            startWatchingGpsStatus()
        }
    }

    fun startLocation() {
        // 已授权：直接定位，绝不再调 request()。
        // request() 在 XXPermissions 18+ 会拉起一个透明的权限 Activity，
        // 权限被永久拒绝时该 Activity 会立即返回并 finish，从而再次触发宿主 onResume，
        // 若每次 onResume 都无条件 request 就会形成 onResume <-> 权限 Activity 的死循环。
        if (XXPermissions.isGranted(context, locationPermissions)) {
            hasShownDeniedDialog = false // 已授权，重置提示状态，便于下次被撤销时能再次提醒
            initLocation()
            return
        }

        // 之前已经申请过且现在仍未授权 => 已被拒绝：不再 request，避免死循环，只提示一次
        if (hasRequestedPermission) {
            listener.location(null)
            showDeniedDialogOnce()
            return
        }

        // 首次申请，最多触发一次
        hasRequestedPermission = true
        XXPermissions.with(context).permission(locationPermissions)
            .request(object : OnPermissionCallback {
                override fun onGranted(permissions: MutableList<String>, allGranted: Boolean) { // 权限同意
                    hasShownDeniedDialog = false
                    initLocation()
                }

                override fun onDenied(permissions: MutableList<String>, doNotAskAgain: Boolean) {
                    super.onDenied(permissions, doNotAskAgain)
                    //权限禁止
                    listener.location(null)
                    showDeniedDialogOnce()
                }
            })
    }

    /**
     * 位置权限被拒绝后，弹框告知用户（同一生命周期内只弹一次，避免重复打扰）
     */
    private fun showDeniedDialogOnce() {
        if (hasShownDeniedDialog) return
        hasShownDeniedDialog = true
        CommonDialog.showLocationNotGrantedTipsDialog(context)
    }

    private fun initLocation() {
        if (mLocationClient == null) {
            mLocationClient = AMapLocationClient(context)
            mLocationClient?.let { mLocationClient ->
                // 设置定位回调监听
                mLocationClient.setLocationListener(this)
                // 初始化定位参数
                mLocationOption = AMapLocationClientOption()
                // 设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
                mLocationOption.locationMode =
                    AMapLocationClientOption.AMapLocationMode.Hight_Accuracy
                // 设置是否返回地址信息（默认返回地址信息）
                mLocationOption.isNeedAddress = true
                // 设置是否只定位一次,默认为false
                mLocationOption.isOnceLocation = isOnceLocation
                // 设置是否强制刷新WIFI，默认为强制刷新
//                mLocationOption.isWifiActiveScan = true
                // 设置是否允许模拟位置,默认为false，不允许模拟位置
                mLocationOption.isMockEnable = false
                // 设置定位间隔,单位毫秒,默认为2000ms
                mLocationOption.interval = interval
                //返回方位角
                mLocationOption.isSensorEnable = false
                // 给定位客户端对象设置定位参数
                mLocationClient.setLocationOption(mLocationOption)
            }
        }
        // 启动定位
        mLocationClient?.startLocation()
        LogUtils.w(TAG, "mLocationClient?.startLocation")

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() {
        mLocationClient?.let { mLocationClient ->
            mLocationClient.stopLocation()
            LogUtils.d(TAG, "onPause")
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun destroy() {
        // 停止监听 GPS 状态
        stopWatchingGpsStatus()

        mLocationClient?.let { mLocationClient ->
            mLocationClient.onDestroy()
            LogUtils.e(TAG, "onDestroy")
        }
    }

    /**
     * 开始监听 GPS 状态变化
     */
    private fun startWatchingGpsStatus() {
        if (isWatchingGpsStatus) {
            LogUtils.d(TAG, "已经在监听 GPS 状态，无需重复注册")
            return
        }

        gpsStatusReceiver = GpsStatusReceiver { isEnabled ->
            LogUtils.i(TAG, "GPS 状态变化: isEnabled = $isEnabled")
            if (isEnabled) {
                // GPS 已开启，停止监听并开始定位
                LogUtils.i(TAG, "检测到 GPS 已开启，自动开始定位")
                stopWatchingGpsStatus()
                startLocation()
            }
        }

        gpsStatusReceiver?.let { receiver ->
            val filter = IntentFilter(LocationManager.PROVIDERS_CHANGED_ACTION)
            context.registerReceiver(receiver, filter, Context.RECEIVER_EXPORTED)
            isWatchingGpsStatus = true
            LogUtils.i(TAG, "已注册 GPS 状态监听")
        }
    }

    /**
     * 停止监听 GPS 状态变化
     */
    private fun stopWatchingGpsStatus() {
        if (!isWatchingGpsStatus) return

        gpsStatusReceiver?.let { receiver ->
            try {
                context.unregisterReceiver(receiver)
                LogUtils.i(TAG, "已注销 GPS 状态监听")
            } catch (e: IllegalArgumentException) {
                // 接收器可能已经被注销
                LogUtils.e(TAG, "注销 GPS 监听失败: ${e.message}")
            }
        }
        gpsStatusReceiver = null
        isWatchingGpsStatus = false
    }

    fun isLocationEnabledModern(): Boolean {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            // Android 9.0 (API 28) 及以上
            val locationManager =
                context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
            locationManager.isLocationEnabled
        } else {
            // 兼容旧版本
            val mode = Settings.Secure.getInt(
                context.contentResolver,
                Settings.Secure.LOCATION_MODE,
                Settings.Secure.LOCATION_MODE_OFF
            )
            mode != Settings.Secure.LOCATION_MODE_OFF
        }
    }


    override fun onLocationChanged(location: AMapLocation?) {
        location?.let {
            if (it.longitude != 0.0 && it.latitude != 0.0) {
                Constants.longitude = it.longitude
                Constants.latitude = it.latitude
            }
            LogUtils.e(TAG, "----------------------------------")
            LogUtils.w(TAG, "onLocationChanged: ${location.errorCode} ${location.errorInfo}")
            // 定位成功，详细打印地址信息
            LogUtils.w(TAG, "经度: ${it.longitude}")
            LogUtils.w(TAG, "维度: ${it.latitude}")
            LogUtils.w(TAG, "国家: ${it.country}")
            LogUtils.w(TAG, "省份: ${it.province}")
            LogUtils.w(TAG, "城市: ${it.city}")
            LogUtils.w(TAG, "区县: ${it.district}")
            LogUtils.w(TAG, "街道: ${it.street}")
            LogUtils.w(TAG, "门牌号: ${it.streetNum}")
            LogUtils.w(TAG, "完整地址: ${it.address}")
            LogUtils.w(TAG, "城市编码: ${it.cityCode}")
            LogUtils.w(TAG, "区域编码: ${it.adCode}")
            LogUtils.w(TAG, "POI名称: ${it.poiName}")
            LogUtils.w(TAG, "AOI名称: ${it.aoiName}")
            LogUtils.w(TAG, "海拔: ${it.altitude} 米")
            LogUtils.w(TAG, "定位精度: ${it.accuracy} 米")
            LogUtils.w(TAG, "卫星数: ${it.satellites}")
            LogUtils.w(TAG, "定位提供者: ${it.provider}")
            LogUtils.w(TAG, "定位类型: ${it.locationType}")
        }
        listener.location(location)
    }

    interface OnMapLocation {
        fun location(pLocation: AMapLocation?)
    }

    companion object {
        val gaodePackageName = "com.autonavi.minimap" // 高德地图包名
        fun navigate(start: LatLng? = null, end: LatLng, context: Context) {
            if (!isInstallPackage(gaodePackageName)) {
                ToastUtils.showLong("请安装导航应用")
            } else {
                val builder = StringBuilder("amapuri://route/plan?sourceApplication=maxuslife")

                start?.let {
                    builder.append("&sname=").append("起点")
                        .append("&slat=").append(start.latitude)
                        .append("&slon=").append(start.longitude)
                }

                builder.append("&dlat=").append(end.latitude)
                    .append("&dlon=").append(end.longitude)
                    .append("&dname=").append("终点")
                    .append("&dev=0")
                    .append("&t=0")

                val uriString = builder.toString()
                val intent = Intent(Intent.ACTION_VIEW)
                intent.setPackage(gaodePackageName)
                intent.data = uriString.toUri()
                context.startActivity(intent)
            }
        }

        private fun isInstallPackage(packageName: String): Boolean {
            return try {
                AppGlobals.getApplication().packageManager.getPackageInfo(packageName, 0)
                true
            } catch (e: PackageManager.NameNotFoundException) {
                try {
                    val intent =
                        AppGlobals.getApplication().packageManager.getLaunchIntentForPackage(
                            packageName
                        )
                    intent != null
                } catch (ex: Exception) {
                    false
                }
            }
        }
    }
}