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.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.ext.setClickListeners
import com.sw.platecabinet.utils.PermissionHelper
import com.sw.platecabinet.view.CustomDialog
import com.sw.platecabinet.viewmodel.SettingViewModel
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.drop
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: CustomDialog? = null
    private val permissionHelpers = mutableMapOf<Int, PermissionHelper>()
    protected var keyEventHelper: ScanGunKeyEventHelper? = null
    private val viewModel by viewModels<SettingViewModel>()

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

        binding = inflateViewBinding()
        headerBinding = inflateTitleBinding()
        setContentView(binding.root)
        updateTime()
        registerDataChange()
        initialize()
        registerKeyEvent()
    }

    /**
     * 监听扫描枪扫描事件
     */
    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) {
        viewModel.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()
    }

    private fun 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() {
        // 持续强制隐藏系统栏（防止手势触发）
        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 = CustomDialog(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() {
        lifecycleScope.launch {
            viewModel.showLoading.collect {
                if (it) {
                    showWaitingDialog("")
                } else {
                    hideWaitingDialog()
                }
            }
        }
        lifecycleScope.launch {
            viewModel.currentUserInfo.drop(1).collect {
                if (it == null) return@collect
                if (it.equipmentBoxCode?.isNotEmpty() == true) {
                    SerialApi.openPlate(
                        it.equipmentBoxCode.toInt(),
                        object : SerialPortManager.SendCallback {
                            override fun onSuccess() {
                                MainActivity.start(context, pageType = PageType.PLATE_OPEN)
                            }

                            override fun onFail(e: Exception?) {
                                ToastUtils.showToast("柜门打开失败")
                            }
                        })
                } else {
                    viewModel.getEquipmentList()
                }
            }
        }
        lifecycleScope.launch {
            viewModel.equipmentList.drop(1).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 = viewModel.currentUserInfo.value
                    firstInfo.plateNumber = currentUserInfo?.plateNumber ?: ""
                    MainActivity.start(
                        context = context,
                        pageType = PageType.BIND_PLATE,
                        equipmentUserInfo = firstInfo
                    )
                }
            }
        }
    }

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