package com.img.rabbit.viewmodel

import android.annotation.SuppressLint
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Context.RECEIVER_EXPORTED
import android.content.Intent
import android.content.IntentFilter
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import android.os.Build
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.navigation.NavHostController
import androidx.navigation.compose.rememberNavController
import com.img.rabbit.bean.response.UniVersionEntity
import com.img.rabbit.config.Constants
import com.img.rabbit.provider.api.ApiManager
import com.img.rabbit.provider.storage.PreferenceUtil
import com.img.rabbit.provider.utils.HeadParamUtils
import com.img.rabbit.provider.utils.NetworkUtils.globalNetworkStatus
import com.tencent.mm.opensdk.constants.ConstantsAPI
import com.tencent.mm.opensdk.openapi.IWXAPI
import com.tencent.mm.opensdk.openapi.WXAPIFactory
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.asSharedFlow

@SuppressLint("ObsoleteSdkInt")
class GeneralViewModel: BaseViewModel(){
    lateinit var api: IWXAPI
    lateinit var receiver: BroadcastReceiver
    lateinit var navController: NavHostController
    private val _networkStatus = MutableLiveData<Boolean>()
    val networkStatus: LiveData<Boolean> = _networkStatus

    private val _serverTime = mutableStateOf<Long?>(null)
    val serverTime: State<Long?> = _serverTime

    private val _isNavigationBarVisible = MutableLiveData<Boolean>()
    val isNavigationBarVisible: LiveData<Boolean> = _isNavigationBarVisible

    private val connectivityManager =
        HeadParamUtils.applicationContext?.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
            _networkStatus.postValue(true)
            globalNetworkStatus = true
        }

        override fun onLost(network: Network) {
            _networkStatus.postValue(false)
            globalNetworkStatus = false
        }
    }

    private val _agreementStatus = MutableLiveData(PreferenceUtil.getAgreement())
    val agreementStatus: LiveData<Boolean> = _agreementStatus
    fun setIsAgreement(agreement: Boolean){
        PreferenceUtil.saveAgreement(agreement)
        _agreementStatus.value = agreement
    }

    init {
        // 注册网络监听
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.registerDefaultNetworkCallback(networkCallback)
        } else {
            val request = NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                .build()
            connectivityManager.registerNetworkCallback(request, networkCallback)
        }
        // 初始化状态
        _networkStatus.value = isNetworkAvailable()
        // 初始化微信API
        HeadParamUtils.applicationContext?.let { initWXApi(it) }
        // 隐私政策状态
        _agreementStatus.value = PreferenceUtil.getAgreement()
    }

    private fun isNetworkAvailable(): Boolean {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val network = connectivityManager.activeNetwork
            val capabilities = connectivityManager.getNetworkCapabilities(network)
            capabilities != null && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
        } else {
            @Suppress("DEPRECATION")
            val networkInfo = connectivityManager.activeNetworkInfo
            networkInfo != null && networkInfo.isConnected
        }
    }

    fun setNavigationBarVisible(visible: Boolean){
        _isNavigationBarVisible.value = visible
    }

    private fun initWXApi(context: Context) {
        api = WXAPIFactory.createWXAPI(context, Constants.WxAppId, true)
        api.registerApp(Constants.WxAppId)

        //建议动态监听微信启动广播进行注册到微信
        receiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                // 将该app注册到微信
                api.registerApp(Constants.WxAppId)
            }
        }

        //建议动态监听微信启动广播进行注册到微信
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            context.registerReceiver(receiver,
                IntentFilter(ConstantsAPI.ACTION_REFRESH_WXAPP), RECEIVER_EXPORTED)
        }
    }

    override fun onCleared() {
        super.onCleared()
        connectivityManager.unregisterNetworkCallback(networkCallback)
    }

    @OptIn(DelicateCoroutinesApi::class)
    fun getServerTime() {
        mLaunch {
            val response =  ApiManager.serviceVo.getServerTime()
            if (response.status) {
                _serverTime.value = response.data
                PreferenceUtil.setTimeDiff(response.data - System.currentTimeMillis() / 1000)
            }
        }
    }
}