package com.sw.platecabinet.activity

import android.app.Dialog
import android.content.Context
import android.os.Build
import android.os.Bundle
import android.text.TextUtils
import android.view.KeyEvent
import android.view.View
import android.view.WindowInsetsController
import android.view.WindowManager
import android.widget.TextView
import androidx.activity.enableEdgeToEdge
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.WindowCompat
import androidx.lifecycle.lifecycleScope
import androidx.viewbinding.ViewBinding
import com.sw.inbound.utils.DateTimeUtils
import com.sw.plate.utils.ScanGunKeyEventHelper
import com.sw.plate.utils.ToastUtils
import com.sw.plate.utils.comn.SerialApi
import com.sw.plate.utils.comn.SerialPortManager
import com.sw.platecabinet.R
import com.sw.platecabinet.databinding.ItemTitleTimeBinding
import com.sw.platecabinet.dialog.BalanceNotEnoughDialog
import com.sw.platecabinet.ext.setClickListeners
import com.sw.platecabinet.model.response.EquipmentUserInfo
import com.sw.platecabinet.utils.PermissionHelper
import com.sw.platecabinet.view.CustomLoadingDialog
import com.sw.platecabinet.viewmodel.SettingViewModel
import com.sw.platecabinet.viewmodel.UserViewModel
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch
import timber.log.Timber

/**
 * activity 基类
 */
abstract class BaseActivity<VB : ViewBinding> : AppCompatActivity() {
    protected lateinit var binding: VB
    private var headerBinding: ItemTitleTimeBinding? = null
    protected lateinit var context: Context
    private var timeJob: Job? = null
    private var mDialogWaiting: CustomLoadingDialog? = null
    private val permissionHelpers = mutableMapOf<Int, PermissionHelper>()
    protected var keyEventHelper: ScanGunKeyEventHelper? = null

    // 管理员对应的viewmodel
    private val settingViewModel by viewModels<SettingViewModel>()

    // 用户对应的viewModel
    protected val viewModel by viewModels<UserViewModel>()

    private var startTime: Long = 0

    override fun onCreate(savedInstanceState: Bundle?) {
        startTime = System.currentTimeMillis()
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        context = this
        disableSystemUICompletely()
        //   确保内容延伸到导航栏区域
        WindowCompat.setDecorFitsSystemWindows(window, false)

        //保持亮屏
        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)

        binding = inflateViewBinding()
        headerBinding = inflateTitleBinding()
        setContentView(binding.root)
        updateTime()
        registerDataChange()
        initialize()
        registerKeyEvent()
        val durationTime = System.currentTimeMillis() - startTime
        Timber.d("启动时间：$durationTime")
    }

    /**
     * 监听扫描枪扫描事件
     */
    protected fun registerKeyEvent() {
        keyEventHelper =
            ScanGunKeyEventHelper(context, object : ScanGunKeyEventHelper.OnScanSuccessListener {
                override fun onScanSuccess(barcode: String?) {
                    Timber.d("onScanSuccess barcode = $barcode")
                    if (barcode == null) return
                    handleScanKeyInfo(barcode)
                }
            })
    }

    /**
     * 处理扫描枪数据
     */
    protected open fun handleScanKeyInfo(scanInfo: String) {
        settingViewModel.findByPlateNumber(plateNumber = scanInfo)
    }

    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
        if (keyEventHelper != null) {
            if (keyEventHelper!!.isScanGunEvent(event)) {
                keyEventHelper!!.analysisKeyEvent(event)
                return true
            }
        }
        return super.dispatchKeyEvent(event)
    }

    fun updateTime() {
        headerBinding?.let {
            it.tvLeftDate.setClickListeners(
                onDoubleClick = {
                    onLeftDoubleClick()
                }
            )
            it.tvRightTime.setClickListeners(
                onDoubleClick = {
                    onRightDoubleClick()
                }
            )
            val scope = CoroutineScope(Dispatchers.Main)
            timeJob = scope.launch {
                DateTimeUtils.realTimeChineseDateFlow()
                    .collect { (date, time) ->
                        it.tvLeftDate.text = date
                        it.tvRightTime.text = time
                    }
            }
        }
    }

    /**
     * 左侧日期双击
     */
    open fun onLeftDoubleClick() {

    }

    /**
     * 右侧时间双击
     */
    open fun onRightDoubleClick() {
        MainActivity.start(context, pageType = PageType.SETTING_LIST)
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)

        val helper = permissionHelpers[requestCode]
        val allGranted = PermissionHelper.handlePermissionResult(
            this,
            requestCode,
            permissions,
            grantResults,
            permissionHelper = helper
        )

        if (allGranted) {
            permissionHelpers.remove(requestCode)
        }
    }

    /**
     * 注册PermissionHelper以便处理结果
     */
    fun registerPermissionHelper(helper: PermissionHelper) {
        permissionHelpers[helper.requestCode] = helper
    }

    override fun onResume() {
        super.onResume()
        // 关键点2：防止某些场景下系统栏恢复
        enforceImmersiveMode()
    }

    override fun onWindowFocusChanged(hasFocus: Boolean) {
        super.onWindowFocusChanged(hasFocus)
        if (hasFocus) {
            disableSystemUICompletely()
        }
    }

    private fun disableSystemUICompletely() {
        Timber.d("disableSystemUICompletely")
        // 禁用系统手势（Android 10+）
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            window.insetsController?.systemBarsBehavior =
                WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
        }


        // 全屏+隐藏导航栏（所有版本通用）
        window.decorView.systemUiVisibility = (
                View.SYSTEM_UI_FLAG_FULLSCREEN
                        or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                        or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
                        or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                )

        // 禁止窗口扩展至系统栏区域（彻底锁定）
        window.addFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS)
        window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
    }


    private fun enforceImmersiveMode() {
        Timber.d("enforceImmersiveMode")
        // 持续强制隐藏系统栏（防止手势触发）
        window.decorView.postDelayed({
            window.decorView.systemUiVisibility = (
                    View.SYSTEM_UI_FLAG_FULLSCREEN
                            or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                            or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
                    )
        }, 100) // 延迟100ms确保覆盖手势触发
    }

    /**
     * 显示等待提示框
     */
    fun showWaitingDialog(tip: String?): Dialog? {
        hideWaitingDialog()
        val view = View.inflate(this, R.layout.dialog_waiting, null)
        if (!TextUtils.isEmpty(tip)) (view.findViewById<View?>(R.id.tvTip) as TextView).setText(tip)
        mDialogWaiting = CustomLoadingDialog(this, view, R.style.MyDialog)
        mDialogWaiting!!.show()
        mDialogWaiting!!.setCancelable(true)
        return mDialogWaiting
    }

    /**
     * 隐藏等待提示框
     */
    fun hideWaitingDialog() {
        mDialogWaiting?.dismiss()
        mDialogWaiting = null
    }

    protected abstract fun inflateViewBinding(): VB

    protected abstract fun inflateTitleBinding(): ItemTitleTimeBinding?

    protected abstract fun initialize()

    /**
     * 注册数据监听
     */
    protected open fun registerDataChange() {
        Timber.d("registerDataChange")
        lifecycleScope.launch {
            viewModel.showLoading.collect {
                Timber.d("registerDataChange 用户 showLoading = $it")
                if (it) {
                    showWaitingDialog("")
                } else {
                    hideWaitingDialog()
                }
            }
        }
        lifecycleScope.launch {
            viewModel.currentUserInfo.collect {
                if (it == null) return@collect
                handleLoginSuccess(it, false)
            }
        }
        lifecycleScope.launch {
            settingViewModel.showLoading.collect {
                Timber.d("registerDataChange 管理员 showLoading = $it")
                if (it) {
                    showWaitingDialog("")
                } else {
                    hideWaitingDialog()
                }
            }
        }
        lifecycleScope.launch {
            settingViewModel.searchUserInfo.collect {
                Timber.d("registerDataChange 管理员 currentUserInfo = $it")
                if (it == null) return@collect
                handleLoginSuccess(it, true)
            }
        }
        lifecycleScope.launch {
            settingViewModel.equipmentList.collect {
                if (it.isEmpty()) return@collect
                val unbindList = it.filter { !it.isBound() }
                if (unbindList.isEmpty()) {
                    MainActivity.start(context = context, pageType = PageType.PLATE_CABINET_FULL)
                } else {
                    val firstInfo = unbindList[0]
                    val currentUserInfo = settingViewModel.searchUserInfo.value
                    firstInfo.plateNumber = currentUserInfo?.plateNumber ?: ""
                    MainActivity.start(
                        context = context,
                        pageType = PageType.BIND_PLATE,
                        equipmentUserInfo = firstInfo
                    )
                }
            }
        }
    }

    /**
     * 处理登录成功操作
     * @param isAdmin  true 管理员 执行绑盘此操作   false 用户，提示错误
     */
    open fun handleLoginSuccess(equipmentUserInfo: EquipmentUserInfo, isAdmin: Boolean) {
        Timber.d("handleLoginSuccess isAdmin = $isAdmin")
        val cardBalance = equipmentUserInfo.cardBalance?:0.toDouble()
        equipmentUserInfo.balanceIsNotEnough = cardBalance <= 0.toDouble()
        if (equipmentUserInfo.balanceIsNotEnough) {
            //提示余额不足弹窗
            BalanceNotEnoughDialog(this).show()
            return
        }
        viewModel.resetUserInfo()
        if (equipmentUserInfo.isOtherEquipment()) {
            MainActivity.start(
                context,
                pageType = PageType.PLATE_TIP,
                equipmentUserInfo = equipmentUserInfo,
                isAdmin
            )
            return
        }
        if (equipmentUserInfo.equipmentBoxCode?.isNotEmpty() == true) {
            SerialApi.openPlate(
                equipmentUserInfo.equipmentBoxCode!!.toInt(),
                object : SerialPortManager.SendCallback {
                    override fun onSuccess() {
                        MainActivity.start(
                            context,
                            pageType = PageType.PLATE_TIP,
                            isAdmin = isAdmin
                        )
                    }

                    override fun onFail(e: Exception?) {
                        ToastUtils.showToast("柜门打开失败")
                    }
                })
        } else {
            if (isAdmin) {
                settingViewModel.getEquipmentList()
            } else {
                Timber.d("无餐盘信息")
                MainActivity.start(
                    context,
                    pageType = PageType.PLATE_TIP,
                    equipmentUserInfo = equipmentUserInfo,
                    isAdmin = isAdmin
                )
            }
        }
    }

    override fun onDestroy() {
        timeJob?.cancel()
        keyEventHelper?.onDestroy()
        super.onDestroy()
    }
}