huaxuepin/app/src/main/java/com/example/chemical/ui/newly/AddedChemicalsActivity.kt

package com.example.chemical.ui.newly


import android.app.Activity
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.graphics.Rect
import android.hardware.usb.UsbManager
import android.os.Bundle
import android.os.CountDownTimer
import android.os.Handler
import android.os.Looper
import android.view.*
import android.view.inputmethod.InputMethodManager
import android.widget.ArrayAdapter
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import com.bumptech.glide.Glide
import com.bumptech.glide.load.engine.DiskCacheStrategy
import com.bumptech.glide.request.RequestOptions
import com.caysn.autoreplyprint.AutoReplyPrint
import com.example.chemical.ChemicalApp
import com.example.chemical.R
import com.example.chemical.blu.BluetoothConnectionManager
import com.example.chemical.comm.Constants
import com.example.chemical.databinding.ActivityAddedChemicalsBinding
import com.example.chemical.receiver.OnSerialScanListener
import com.example.chemical.receiver.PortScanHelper
import com.example.chemical.receiver.UsbReceiver
import com.example.chemical.ui.PrintBean
import com.example.chemical.ui.SplashActivity
import com.example.chemical.ui.adapter.ChemicalsAdapter
import com.example.chemical.ui.common.BaseCountDownActivity
import com.example.chemical.ui.verify.TwoVerificationActivity
import com.example.chemical.utils.*
import com.example.chemical.weidith.*
import com.rc.core.log.RcLog
import com.rc.httpcore.HttpConfig
import com.rc.httpcore.bean.*
import com.rc.httpcore.client.ApiRepository
import com.rc.httpcore.exception.NetException
import com.sun.jna.Pointer
import kotlinx.coroutines.*
import org.greenrobot.eventbus.EventBus
import org.greenrobot.eventbus.Subscribe
import org.greenrobot.eventbus.ThreadMode
import retrofit2.HttpException
import java.lang.Runnable
import java.math.BigDecimal
import java.net.ConnectException
import java.net.SocketTimeoutException
import java.nio.charset.StandardCharsets
import java.util.*
import kotlin.collections.ArrayList

/**
 * 新增入库 全新  包装0  已开封  可输入包装值
 * AutoCompleteTextView
 */
class AddedChemicalsActivity : BaseCountDownActivity<ActivityAddedChemicalsBinding>() {

    private lateinit var timeUpdater: TimeUpdater
    private val mAdapter by lazy { ChemicalsAdapter(this) }
    private lateinit var modelA: ChemicalABean //新增-点击确定 需要的参数

    private var mLabelDialog: LabelDialog? = null
    private var mWeighDialog: WeighDialog? = null

    private var mChemicalInfoBean: ChemicalInfoBean? = null
    private var mListData: List<RuleBean>? = null  //柜子信息
    private var mPrintTag = 0  //需要打印得内容条数
    private var mStockDetailsModel: MutableList<StockDetailsModel>? = null

    //刷卡
    private var mUsbReceiver: UsbReceiver? = null  // 刷卡广播注册
    private var mHandleScanEvent = false //当前是否已经获取过 usb返回的参数
    private var mUserId: String? = null   //归属人id

    //    private val REQUEST_CODE = 6
    private var mCabinetId = ""   //柜子id
    private var mCabinetName = "" //柜子名称

    //    private var mUnlockingMethod = 1         //1无锁，2是智能锁，3是钥匙柜
    private var mLayers = 1  //柜子一共层数
    private var mLayersTow = 1  //柜子选择层数
    private var mDoorId: String = ""
    private var mDoorName = ""    //柜门名称
    private var mLockNum: String = ""
    private var mChemicalId: String? = null
    private var chemTypeIsBoo = true
    private var mWeighingValue: EditText? = null
    private var mStockModeBean = StockModeBean(mutableListOf())
    private var mStockModelList = mutableListOf<StockModel>()
    private var mCabinetLockVoList: List<LockVoListBean>? = null  //柜锁会又多个
    private var mLockStr = ArrayList<String>()  // 需要打开得柜锁数量
    private val handlerUtil = HandlerUtil.getInstance()

    private val handlerPrint = HandlerUtil.getInstance()
    private var mJoinType = 1   //称重方式 1 称重，2 录入  提交
    private lateinit var mChemicalConfsBean: ChemicalConfsBean  //获取化学品的称重超过比例or
    private var h = Pointer.NULL
    private var pritBot = false
    private var mWeighing: String? = null  //记录上次数
    private var isClisLit = false  //是否点击称重关闭按钮

    //厂家信息
    private var mOptionsList = mutableListOf<String>()

    override fun createViewBinding() =
            ActivityAddedChemicalsBinding.inflate(LayoutInflater.from(this))

    override fun initViews(savedInstanceState: Bundle?) {
        super.initViews(savedInstanceState)
        initTitle()
        inAdapter()//初始化适配器
        EventBus.getDefault().register(this)

        searchProducer()
        viewBinding.edName.setText("${ChemicalApp.userData!!.userName}-${ChemicalApp.userData!!.account}")
        viewBinding.tvReturn.text = "返回${ChemicalApp.confs!!.backTime}s"
        mUserId = ChemicalApp.userData!!.userId
        viewBinding.tvOutLogin.setOnClickListener {
            callLogoutApi {
                ChemicalApp.userData = null
//                HttpClient.token = null
                ChemicalApp.subjectId = null
                UiManager.switcherCashier(this, SplashActivity::class.java)
            }
        }
        // 责任人   校院管理员
        RcLog.info("==当前人员权限===${ChemicalApp.responsibles}  ${ChemicalApp.administrators}")
        if (!ChemicalApp.administrators) {  //不是校级院级管理员
            viewBinding.butUnregulated.isChecked = true
            viewBinding.butControl.isChecked = false   //取消默认选中
            viewBinding.butControl.isEnabled = false   //禁止点击
        }

        viewBinding.tvReturn.setOnClickListener {
            finish()
        }

        //品名搜索
        viewBinding.butPSearch.setOnClickListener {
            viewBinding.packNum.setText("")
            if (viewBinding.chemicalName.text.toString().isNotEmpty()) {
                //  chemicalLevel    //管控 1     非管控  2
                if (ChemicalApp.responsibles) {  //非管控 类型查询
                    searchChemica(viewBinding.chemicalName.text.toString(), "2")
                } else {
                    searchChemica(viewBinding.chemicalName.text.toString(), null)
                }
            } else {
                showToast("请输入化学品名称")
            }
        }

        viewBinding.imgPosition.setOnClickListener {
            //更换柜子信息
            storageDialogView()
        }

        viewBinding.butOpen.setOnClickListener {
            //再次打开柜门
            if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
                mLockStr.clear()
                mCabinetLockVoList!!.forEach { it ->
                    when (it.unlockingMethod) {
                        2 -> { //智能锁
                            mLockStr.add("${it.lockNum}")
                        }
                    }
                }
                if (mLockStr != null && mLockStr.size > 0) {
                    openLock(mLockStr)
                } else {
                    subAddData(0)
                }
            } else {
                subAddData(0)
            }
        }

        //CAS号 搜索
        viewBinding.butCSearch.setOnClickListener {
            viewBinding.packNum.setText("")
            if (viewBinding.casNum.text.toString().isNotEmpty()) {
                RcLog.info("==当前人员权限=2==${ChemicalApp.responsibles}  ${ChemicalApp.administrators}")
                if (ChemicalApp.responsibles) {
                    searchChemica(viewBinding.casNum.text.toString(), "2")
                } else {
                    searchChemica(viewBinding.casNum.text.toString(), null)
                }
            } else {
                showToast("请输入CAS号")
            }
        }

        //类别
        viewBinding.chemType.setOnClickListener {
            if (chemTypeIsBoo == false) {
                return@setOnClickListener
            }
            showLoading("查询中...")
            val disposable = ApiRepository.getOptions("chemicals_category")
                    .subscribe({ data ->
                        dismissLoading()
                        val chemDialog = ChemicalTypeDialog(
                                this,
                                data.toMutableList(),
                                object : ChemicalTypeDialog.IonClickListener {
                                    override fun onClick(data: ChemicalTypeBean) {
//                                showToast("${data.label}  ${data.itemId}")
                                        viewBinding.chemType.text = "${data.label}"
                                        viewBinding.chemType.tag = "${data.value}"
                                    }
                                })

                        if (!chemDialog.isShowing) {
                            chemDialog.show()
                        }
                    }, { throwable ->
                        dismissLoading()
                        showNetError(throwable)

                    })
            addDisposable(disposable)
        }

        //通过 姓名or工号 搜索 归属人信息
        viewBinding.butName.setOnClickListener {
            val edName = viewBinding.edName.text.toString()
            if (edName.isNotBlank()) {
                showLoading("查询中...")
                val disposable = ApiRepository.getSelects(edName)
                        .subscribe({ data ->
                            dismissLoading()
                            val dialogs =
                                    BelongingPersonDialog(
                                            this,
                                            data,
                                            object : BelongingPersonDialog.IClickLit {
                                                override fun onClickUserId(dataBean: BelongingPersonBean) {
                                                    //归属人 id  用于查询课题组信息
                                                    mUserId = dataBean.userId
                                                    viewBinding.edName.setText("${dataBean.userName}-${dataBean.account}")
//                                        viewBinding.topicName.tag = "${dataBean.userId}"

                                                }
                                            })
                            dialogs.show()
                        }, { throwable ->
                            dismissLoading()
                            showNetError(throwable)

                        })
                addDisposable(disposable)
            } else {
                showToast("姓名或工号不能为空")
            }
        }
        //课题组信息查询
        viewBinding.topic.setOnClickListener {

            if (mUserId == null) {
                showToast("未选择归属人")
                return@setOnClickListener
            }
            showLoading("查询中...")
            val disposable = ApiRepository.getTopicList(mUserId!!)
                    .subscribe({ data ->
                        dismissLoading()
                        var dialog =
                                SelectTopicDialog(this, data, object : SelectTopicDialog.IonItemLint {
                                    override fun onItem(topicDataBean: TopicDataBean) {
                                        viewBinding.topicName.text = "${topicDataBean.topicName}"
                                        viewBinding.topicName.tag = "${topicDataBean.topicId}"
                                    }
                                })
                        dialog.show()
                    }, { throwable ->
                        dismissLoading()
                        showNetError(throwable)

                    })
            addDisposable(disposable)
        }

        //包装类型
        viewBinding.specType.setOnClickListener {
            showLoading("查询中...")
            val disposable = ApiRepository.getOptions("chemical_pack_utils")
                    .subscribe({ data ->
                        dismissLoading()
                        val packingDialog =
                                PackingDialog(this, data, object : PackingDialog.IonClickListener {
                                    override fun onClick(model: ChemicalTypeBean) {
                                        viewBinding.packUnit.text = model.label
                                    }
                                })
                        packingDialog.show()
                    }, { throwable ->
                        dismissLoading()
                        showNetError(throwable)

                    })
            addDisposable(disposable)
        }
        viewBinding.butResetting.setOnClickListener {
            //重置
            emptyViews()
        }
        val rootView = viewBinding.contents
        // 设置全局布局监听器
        rootView.viewTreeObserver.addOnGlobalLayoutListener(object :
                ViewTreeObserver.OnGlobalLayoutListener {
            private val visibleThreshold = 100 // 软键盘显示的阈值，可以根据需要调整

            override fun onGlobalLayout() {
                val rect = Rect()
                rootView.getWindowVisibleDisplayFrame(rect)

                // 获取屏幕高度
                val screenHeight = rootView.height

                // 计算键盘高度
                val keypadHeight = screenHeight - rect.bottom

                // 如果键盘高度大于一个阈值，判断为键盘显示
                val isKeyboardVisible = keypadHeight > visibleThreshold

                if (isKeyboardVisible) {
                    // 键盘显示时，可以进一步判断焦点是否在EditText上
                    val focusedView = currentFocus
                    if (focusedView is EditText) {
                        mHandleScanEvent = true
                    }
                } else {
                    //软键盘 隐藏
                }
            }
        })


//        //选择柜子信息
//        viewBinding.cabinet.setOnClickListener {
//            storageDialogView()
//        }

        //全新
        viewBinding.tvThe.setOnClickListener {
            viewBinding.tvTwo.isChecked = false
            viewBinding.packNum.isEnabled = false
            viewBinding.packNum.setText("")
        }

        //已开封
        viewBinding.tvTwo.setOnClickListener {
            viewBinding.tvThe.isChecked = false
            viewBinding.packNum.isEnabled = true
        }

        //====规格  g
        viewBinding.bugCationsLeft.setOnClickListener {
            viewBinding.bugCationsRight.isChecked = false
            viewBinding.packUnit.text = "件"
        }
        //====规格 ml
        viewBinding.bugCationsRight.setOnClickListener {
            viewBinding.bugCationsLeft.isChecked = false
            viewBinding.packUnit.text = "瓶"
        }
        //管控
        viewBinding.butControl.setOnClickListener {
            viewBinding.butUnregulated.isChecked = false
        }

        //非管控
        viewBinding.butUnregulated.setOnClickListener {
            viewBinding.butControl.isChecked = false
        }

        //根据规格值 查询最近一个包装值
        viewBinding.packNum.setOnFocusChangeListener { view, hasFocus ->
            if (hasFocus) {
                RcLog.info("=======1")
                val checked = viewBinding.tvTwo.isChecked
                if (checked) {
                    //已开封
                    val toString = viewBinding.specNum.text.toString()
                    if (toString.isNotEmpty()) {
                        RcLog.info("=======2")
                        searchSpecView(toString)
                    }
                }
            }
        }

        ButtonDebouncer.setDebouncedOnClickListener(viewBinding.butDetermine, 500L) {
            var isNew = true
            val checkedB = viewBinding.tvTwo.isChecked  //已开封
            if (checkedB) {
                isNew = false
            }
            val chemicalName = viewBinding.chemicalName.text.toString().trim()
            if (chemicalName.isEmpty()) {
                showToast("化学品名称不能为空")
                return@setDebouncedOnClickListener
            }
            var casNum: String? = null
            if (viewBinding.casNum.text.toString().trim().isNotEmpty()) {
                casNum = viewBinding.casNum.text.toString().trim()
            }
            val chemicalCategory = try {
                viewBinding.chemType.tag.toString()
            } catch (e: Exception) {
                showToast("类别不能为空")
                return@setDebouncedOnClickListener
            }
            var chemicalPurity: String? = null
//            val chemicalPurity = viewBinding.chemicalPurity.text.toString().trim()  //纯度
            val chemicalDensity = viewBinding.chemicalDensity.text.toString().trim()//密度
            if (viewBinding.chemicalPurity.text.toString().trim().isNotEmpty()) {
                chemicalPurity = viewBinding.chemicalPurity.text.toString().trim()
            }
            if (chemicalDensity.isEmpty()) {
                showToast("密度不能为空")
                return@setDebouncedOnClickListener
            }
            var chemicalLevel = 1  //管控

            //非管控
            if (viewBinding.butUnregulated.isChecked) {
                chemicalLevel = 2
            }
            var belongName = viewBinding.edName.text.toString().trim() //归属人
            var belongId: String? = null

            if (belongName.isEmpty()) {
                showToast("归属人不能为空")
                return@setDebouncedOnClickListener
            }
            belongId = mUserId //归属人id
            val topicName = viewBinding.topicName.text.toString().trim() //课题组 名称

            if (topicName.isNotBlank()) {
                belongName = topicName
                belongId = viewBinding.topicName.tag.toString() //课题组id
            }

            val chemicalNumber = viewBinding.number.text.toString().trim()//数量
            if (chemicalNumber.isEmpty()) {
                showToast("数量不能为空")
                return@setDebouncedOnClickListener
            }


            val factory = viewBinding.edManufacturer.text.toString().trim() //生产厂家

            var packNum = viewBinding.packNum.text.toString().trim() //包装值
            if (viewBinding.packNum.isEnabled) {
                if (packNum.isEmpty()) {
                    showToast("包装不能为空")
                    return@setDebouncedOnClickListener
                }
            } else {
                packNum = "0"
            }

            val packUnit = viewBinding.packUnit.text.toString().trim() //包装单位
            val specNum = viewBinding.specNum.text.toString().trim() //规格值
            if (specNum.isEmpty()) {
                showToast("规格不能为空")
                return@setDebouncedOnClickListener
            }

            var specUnit = "g"
            if (viewBinding.bugCationsRight.isChecked) {
                specUnit = "ml"
            }
            modelA = ChemicalABean(
                    belongId = belongId,
                    belongName = belongName,
                    casNum = casNum,
                    chemicalCategory = chemicalCategory,
                    chemicalDensity = chemicalDensity.toDouble(),
                    chemicalLevel = chemicalLevel,
                    chemicalName = chemicalName,
                    chemicalNumber = chemicalNumber.toInt(),
                    chemicalPurity = chemicalPurity,
                    factory = factory,
                    isNew = isNew,
                    packNum = BigDecimal(packNum),
                    packUnit = packUnit,
                    specNum = BigDecimal(specNum),
                    specUnit = specUnit,
                    chemicalId = mChemicalId
            )
            getControlConfigs(chemicalNumber)
        }

        ButtonDebouncer.setDebouncedOnClickListener(viewBinding.subAdd, 500L) {
            // 处理按钮点击事件的逻辑代码

            if (mAdapter.data.size > 0) {
                if (modelA.status == 2) {
                    //不需要双人认证
                    if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
                        mLockStr.clear()
                        mCabinetLockVoList!!.forEach { it ->
                            when (it.unlockingMethod) {
                                2 -> { //智能锁
                                    mLockStr.add("${it.lockNum}")
                                }
                            }
                        }
                        if (mLockStr != null && mLockStr.size > 0) {
                            openLock(mLockStr)
                        } else {
                            subAddData(0)
                        }
                    } else {
                        subAddData(0)
                    }
                } else {
                    //需要双人认证   1人脸 2刷卡 3扫码
                    if (ChemicalApp.confs!!.verifyType.length == 1) {
                        val map = mutableMapOf<String, Any>()
                        //当前 管控类型
                        map["chemicalLevel"] = modelA.chemicalLevel  //管控类型
                        map["doorId"] = "${viewBinding.cabinet.tag}"  //柜子id
                        map["mTag"] = 0
                        when (ChemicalApp.confs!!.verifyType) {
                            "1" -> {//人脸
                                map["mVerTyps"] = 1

                            }

                            "2" -> {//刷卡
                                map["mVerTyps"] = 2


                            }
                            "3" -> {//扫码
                                map["mVerTyps"] = 3

                            }
                        }

                        UiManager.switcher(
                                this,
                                map,
                                TwoVerificationActivity::class.java
                        )
//                        map["hides"] = 4   //隐藏扫码
//                        when (ChemicalApp.confs!!.verifyType) {
//                            "1" -> {//人脸
//                                UiManager.switcher(
//                                    this,
//                                    map,
//                                    TwoPersonActivity::class.java,
//                                    Constants.REQUEST_CODE
//                                )
//                            }
//                            "2" -> {//刷卡
//                                UiManager.switcher(
//                                    this,
//                                    map,
//                                    SwipeCodeTwoActivity::class.java,
//                                    Constants.REQUEST_CODE
//                                )
//                            }
//                            "3" -> {//扫码
//                                UiManager.switcher(
//                                    this,
//                                    map,
//                                    ScanCodeTwoActivity::class.java,
//                                    Constants.REQUEST_CODE
//                                )
//                            }
//                        }
                    } else {
                        verifyChecking()
                    }
                }
            } else {
                showToast("缺少录入信息")
            }
        }
    }

    private fun getControlConfigs(chemicalNumber: String) {

        showLoading("提交中...")
        val disposable = ApiRepository.controlConfigs(modelA.chemicalLevel)
                .subscribe({ data ->
                    dismissLoading()
                    mChemicalConfsBean = data
                    //                searchProducer()
                    certitude(chemicalNumber)
                }, { throwable ->
                    showNetError(throwable)
                    dismissLoading()
                })
        addDisposable(disposable)

    }

    private fun getCheckRfids(rfid: String, tagCode: String, wxCode: String, position: Int) {
        showLoading("查询标签...")
        val disposable = ApiRepository.checkRfids(rfid)
                .subscribe({ data ->
                    dismissLoading()
                    if (data) {
                        customDialogView(2, "rfid标签不能重复,请重新扫描")
                        mLabelDialog!!.getRfidTag(position)
                    } else {
                        if (mChemicalConfsBean.qrCodePrint) {
                            //需要打印
                            val print = PrintBean()
                            print.tag = tagCode  //化学品编码
                            print.wxCode = wxCode
                            print.name = modelA.chemicalName!! //化学品名称
                            if (modelA.casNum != null) {
                                print.casNo = modelA.casNum!!  //cas号
                            } else {
                                print.casNo = ""
                            }
                            print.person = modelA.belongName!! //归属人
                            //管控 1     非管控  2
                            if (modelA.chemicalLevel == 1) {
                                print.level = "管控"
                            } else {
                                print.level = "非管控"
                            }
                            print.types = "${viewBinding.chemType.text}"
                            labelPrint(print)
                        }
                    }
                }, { throwable ->
                    showNetError(throwable)
                    mLabelDialog!!.getRfidTag(position)
                    dismissLoading()
                })
        addDisposable(disposable)
    }

    private fun storageDialogView() {
        val storageDialog =
                StorageDialog(
                        ct = this,
                        listData = mListData!!,
                        lint = object : StorageDialog.IonClickListener {
                            override fun onClick(
                                    cabinetId: String,
                                    cabinetName: String,
                                    doorName: String,
                                    doorId: String,
                                    cabinetLockVoList: List<LockVoListBean>,
                                    layers: Int,
                                    lockNum: String,
                            ) {
                                mCabinetId = cabinetId
                                mCabinetName = cabinetName
                                mDoorId = doorId
                                mDoorName = doorName
                                mLockNum = lockNum
                                mCabinetLockVoList = cabinetLockVoList
                                viewBinding.cabinet.text = "存储位置:${cabinetName}-${doorName}"
                                viewBinding.cabinet.tag = "$doorId"
                                mLayers = layers  //当前需要显示得层数

                                if (mStockModelList != null && mStockModelList.size > 0) {
                                    mStockModelList.forEach {
                                        it.cabinetId = mCabinetId
                                        it.cabinetName = mCabinetName
                                        it.doorId = mDoorId
                                        it.doorName = mDoorName
                                        it.layers = mLayers
                                    }
                                }
                                mAdapter.updateData(mLayers)
                            }

                            override fun onClose() {

                            }
                        })
        storageDialog.show()
    }

    //验证方式
    private fun verifyChecking() {
        val map = mutableMapOf<String, Any>()
        map["chemicalLevel"] = modelA.chemicalLevel  //管控类型
        map["doorId"] = "${viewBinding.cabinet.tag}"  //柜子id
        map["mTag"] = 0
        map["mVerTyps"] = 0
        if (ChemicalApp.confs!!.verifyType == "1,2" || ChemicalApp.confs!!.verifyType == "2,1") {
            //人脸+刷卡
            map["hides"] = 1   //隐藏扫码
//            UiManager.switcher(this, map, TwoPersonActivity::class.java, Constants.REQUEST_CODE)
        } else if (ChemicalApp.confs!!.verifyType == "1,3" || ChemicalApp.confs!!.verifyType == "3,1") {
            //人脸+扫码
            map["hides"] = 2   //隐藏刷卡
//            UiManager.switcher(this, map, TwoPersonActivity::class.java, Constants.REQUEST_CODE)
        } else if (ChemicalApp.confs!!.verifyType == "2,3" || ChemicalApp.confs!!.verifyType == "3,2") {
            map["hides"] = 3   //隐藏扫码
//            UiManager.switcher(
//                this,
//                map,
//                SwipeCodeTwoActivity::class.java,
//                Constants.REQUEST_CODE
//            )
        } else {
            //人脸+刷卡+扫码
            map["hides"] = 4
//            UiManager.switcher(this, map, TwoPersonActivity::class.java, Constants.REQUEST_CODE)
        }
        UiManager.switcher(
                this,
                map,
                TwoVerificationActivity::class.java,
                Constants.REQUEST_CODE
        )

    }


    private fun initTitle() {
        viewBinding.tvName.text = ChemicalApp.userData!!.userName
        val imageView = viewBinding.imageName
        // 使用 Glide 加载网络图片
        Glide.with(this)
                .load("${HttpConfig.API_BASE_IMG_URL}${ChemicalApp.userData!!.avatar}")
                .apply(RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.AUTOMATIC))
                .into(imageView)
        // 使用 Glide 加载网络图片

        viewBinding.deptName.text = "${ChemicalApp.confs!!.deptName}-${ChemicalApp.confs!!.roomNum}"

        Glide.with(this)
                .load("${HttpConfig.API_BASE_IMG_URL}${ChemicalApp.confs!!.circularLogo}")
                .apply(RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.AUTOMATIC))
                .into(viewBinding.image)

    }

    //确定提交的信息
    private fun certitude(number: String) {
        showLoading("提交中...")
        val disposable = ApiRepository.certitude(modelA)
                .subscribe({ data ->
                    dismissLoading()
                    modelA.chemicalId = data.chemicalId  //化学品id
                    modelA.status = data.status  //是否需要认证
//                val netContent = modelA.chemicalDensity * modelA.specNum  // 净量 = 密度*规格
                    var density = "${modelA.specNum}${modelA.specUnit}/${modelA.packUnit}"
                    mLabelDialog = LabelDialog(this, number, mLayers, density,
                            modelA.chemicalName!!, object : LabelDialog.IRfidClick {

                        override fun onItemClick(
                                modelList: MutableList<StockDetailsModel>?,
                                layer: Int
                        ) {
                            RcLog.info("=======当前7选择 $layer")
                            if (modelList == null) {
                                //取消
                            } else {
                                mStockDetailsModel = modelList
                                mLayersTow = layer
                                RcLog.info("====选择层数的回显 $mLayers")
                                //确定  链接蓝牙
                                mWeighDialog = WeighDialog(
                                        this@AddedChemicalsActivity,
                                        density,
                                        object : WeighDialog.IViewLint {
                                            override fun weighingView(weighingValue: EditText) {
//                                        showLoading("蓝牙连接中...")
                                                mWeighingValue = weighingValue
                                                if (mWeighingValue!!.isEnabled) {
                                                    // EditText允许输入
                                                    // 在这里执行相应的操作
                                                    showToast("请手动输入")
                                                    weiView()
                                                } else {
                                                    // EditText禁止输入
                                                    // 在这里执行相应的操作
                                                    isClisLit = false
                                                    lifecycleScope.launch {
                                                        connectToDeviceWithTimeout()
                                                    }
                                                }

                                                mWeighingValue!!.setOnEditorActionListener { v, actionId, event ->
                                                    if (event?.action == KeyEvent.ACTION_DOWN && event.keyCode == KeyEvent.KEYCODE_ENTER) {
                                                        // 确认是否触发了"actionDone"
                                                        RcLog.info("====键盘测试==1")
                                                        true
                                                    } else {
                                                        RcLog.info("====键盘测试==2  ${mWeighingValue!!.text.toString()}")
                                                        closEnd()
                                                        false
                                                    }
                                                }

                                            }

                                            //确定 关闭  获取文本值 跳转新的页面
                                            override fun viewCloses() {
                                                mHandleScanEvent = false
                                                isClisLit = true
                                                closEndTwo()

                                            }

                                            override fun onMovement() {
                                                showToast("请手动输入")
                                                weiView()
                                            }

                                            override fun onTimerReply() {
                                                stopCountDown()
                                            }
                                        })
                                mWeighDialog!!.show()
                            }
                        }

                        override fun onPrint(
                                tagCode: String,
                                wxCode: String,
                                rfidCode: String,
                                position: Int
                        ) {
                            getCheckRfids(rfidCode, tagCode, wxCode, position)
                        }

                        //根据后台配置进行打印
                        override fun opTageCode(
                                modelList: MutableList<StockDetailsModel>,
                                layer: Int
                        ) {
                            RcLog.info("=======当前6选择 $layer")
                            if (mChemicalConfsBean.qrCodePrint) {
                                showLoading("打印中，请稍等")
                                mStockDetailsModel = modelList
                                mLayersTow = layer
                                mPrintTag = mStockDetailsModel!!.size
                                handlerPrint.startTask(taskPrint, 3000)
                            } else {
                                //打印完成
                                mLabelDialog!!.printingCom()
                            }
                        }
                    })
                    mLabelDialog!!.show()
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)

    }

    private fun weiView() {
        mJoinType = 2
//        try {
//            jobTow?.cancel()
//        } catch (e: Exception) {
//        }
        mWeighingValue!!.isEnabled = true
        mWeighingValue!!.requestFocus()
    }

    private val taskPrint = Runnable {

        if (mPrintTag == 0) {
            //全部打印完成  关闭 并且调用下一步业务
            dismissLoading()
            handlerPrint.stopAllTasks()
            //打印完成
            mLabelDialog!!.printingCom()
        } else {
            // 输出当前循环的值
            val print = PrintBean()
            print.tag = mStockDetailsModel!![mPrintTag - 1].tagCode!!  //化学品编码
            print.wxCode = mStockDetailsModel!![mPrintTag - 1].wxCode!!  //化学品编码
            print.name = modelA.chemicalName!! //化学品名称
            if (modelA.casNum != null) {
                print.casNo = modelA.casNum!!  //cas号
            } else {
                print.casNo = ""
            }

            print.person = modelA.belongName!! //归属人
            //管控 1     非管控  2
            if (modelA.chemicalLevel == 1) {
                print.level = "管控"
            } else {
                print.level = "非管控"
            }
            print.types = "${viewBinding.chemType.text}"
            labelPrint(print)
        }
        mPrintTag--

    }

    //校验当前数据是否合理
    private fun verificationData(model: StockModel) {
        showLoading("查询中...")
        val disposable = ApiRepository.addStockCheck(model)
                .subscribe({ data ->
                    dismissLoading()
                    mStockModelList.add(model)
                    mStockModeBean = StockModeBean(mStockModelList)
                    mAdapter.updateData(mLayers)
                    //创建需要提交的数据源
                    if (mAdapter.data != null && mAdapter.data.size > 0) {
                        mAdapter.setList(mStockModelList)
                    } else {
                        viewBinding.labelView.visibility = View.GONE
                        mAdapter.setNewInstance(mStockModelList.toMutableList())
                    }
                    viewBinding.imgPosition.visibility = View.GONE
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }

    //types 0  请将化学品放入化学品柜    1 柜门已开，请将化学品放入化学品柜
    private fun subAddData(types: Int) {
        try {// 从 SharedPreferences 中取出集合
            val retrievedList =
                    SharedPreferencesHelper.getList(this@AddedChemicalsActivity)
            if (retrievedList != null && retrievedList.size > 0) {
                SharedPreferencesHelper.clearList(this@AddedChemicalsActivity)
            }
        } catch (e: Exception) {

        }
        showLoading("入库中...")
        val disposable = ApiRepository.stockWaitAdd(mStockModeBean)
                .subscribe({ data ->
                    dismissLoading()
                    mStockModelList.clear()
                    mAdapter.data.clear()
                    mAdapter.notifyDataSetChanged()
                    viewBinding.imgPosition.visibility = View.VISIBLE
                    viewBinding.labelView.visibility = View.VISIBLE
                    if (types == 0) {
                        MediaPlayerHelper.playRawMp3(
                                this,
                                R.raw.qingjianghuaxuekaimen
                        )
                        customDialogView(1, "请将化学品放入化学品柜")
                    } else {
                        MediaPlayerHelper.playRawMp3(this, R.raw.guimenyikai)
                        customDialogView(1, "柜门已开，请将化学品放入化学品柜")
                    }
                    mHandleScanEvent = false
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)

                })
        addDisposable(disposable)
    }


    /**
     * 标签打印
     * 化学品信息
     */
    private fun labelPrint(printDate: PrintBean) {
        if (!pritBot) {
            h = try {//关闭打印
                AutoReplyPrint.INSTANCE.CP_Port_OpenUsb(
                        "VID:0x0FE6,PID:0x811E",
                        1
                )
            } catch (e: Exception) {
                AutoReplyPrint.INSTANCE.CP_Port_OpenUsb(
                        "VID:0x0FE6,PID:0x811E",
                        1
                )
            }
        }

        pritBot = true
        val bitmap = BitmapUtils.generateBitmap(printDate)  //图片信息
        AutoReplyPrint.INSTANCE.CP_Label_BackPaperToPrintPosition(h)
        AutoReplyPrint.CP_Pos_PrintRasterImageFromData_Helper.PrintRasterImageFromBitmap(
                h,
                bitmap!!.width,
                bitmap.height,
                bitmap,
                AutoReplyPrint.CP_ImageBinarizationMethod_Thresholding,
                AutoReplyPrint.CP_ImageCompressionMethod_None
        )
        AutoReplyPrint.INSTANCE.CP_Label_PagePrint(h, 1)
        val result = AutoReplyPrint.INSTANCE.CP_Pos_HalfCutPaper(h) //全切
        if (result) {
            //打印成功
            MediaPlayerHelper.playRawMp3(this, R.raw.huaxuepinbiaoqian)
        }


    }

    private fun closePort() {
        if (h !== Pointer.NULL) {
            AutoReplyPrint.INSTANCE.CP_Port_Close(h)
            h = Pointer.NULL
        }
    }

    var taskStarted = false

    // 声明一个全局的 Handler 变量
    private var mHandlerTime: Handler? = null

    // 在需要执行任务的地方调用这个函数
    private fun delayedTaskToUpdateUI() {
        // 初始化 Handler，并关联到主线程 Looper
        if (isClisLit == false) {
            mHandlerTime = Handler(Looper.getMainLooper())

            // 定义一个延迟执行的任务
            val updateUITask = Runnable {
                RcLog.info("=====执行了")
                // 在这里执行更新 UI 的操作
                // 例如，更新 TextView 的文本
                // textView.text = "Updated text"
                closEnd()
                taskStarted = false
                // 执行完更新操作后，可以关闭 Handler
                mHandlerTime?.removeCallbacksAndMessages(null)
                mHandlerTime = null

            }

            // 延迟 3 秒执行任务
            mHandlerTime?.postDelayed(updateUITask, 3300)
        }
    }


    private suspend fun connectToDeviceWithTimeout() {
        showToast("连接中...", Toast.LENGTH_SHORT)
//        lifecycleScope.launch {

        val deviceAddress = withContext(Dispatchers.IO) {
            BluetoothConnectionManager.getDeviceAddress()
        }
        if (deviceAddress != null) {
            val socket = withContext(Dispatchers.IO) {
                BluetoothConnectionManager.connectToDevice(deviceAddress)
            }
            if (socket != null) {
                // 连接成功后的处理逻辑
                // 在这里使用返回的 BluetoothSocket 对象进行后续操作
                MediaPlayerHelper.playRawMp3(
                        this@AddedChemicalsActivity,
                        R.raw.qing_zheng_zhong
                )
//                    showToast("连接成功", Toast.LENGTH_SHORT)
                // 连接成功后的处理逻辑
                // 切换回主线程更新 UI
                withContext(Dispatchers.Main) {
                    do {
                        val inputStream = socket!!.inputStream
                        val bt = ByteArray(1024)
                        val content = inputStream!!.read(bt)
                        if (content != null && content > 0) {
                            val contents = String(
                                    bt,
                                    0,
                                    content,
                                    StandardCharsets.UTF_8
                            )
                            val split = contents.split("\n")
                            val weight = split[0].trim()
                            RcLog.info("===================称重未处理之前=======$contents")
                            RcLog.info("===================weight=======$weight")
                            RcLog.info("=====称重数据$weight $taskStarted  ${mWeighingValue!!.text.toString()}")
                            if (weight.toDouble() > 2999) {
                                turnOffWeighing()
                            } else {
                                if (weight.toDouble() > 0) {
                                    if (mWeighingValue!!.text.toString().trim()
                                                    .isNotEmpty()
                                    ) {
                                        if (weight.toDouble() == mWeighingValue!!.text.toString()
                                                        .trim().toDouble()
                                        ) {
                                            if (taskStarted == false) {
                                                taskStarted = true
                                                RcLog.info("=====执行了")
                                                socket.close()
                                                delayedTaskToUpdateUI()
                                                break
                                            }
                                        }
                                    }
                                    mWeighingValue!!.setText("$weight")
                                } else {
                                    mWeighingValue!!.setText("")
                                }
                            }
                            RcLog.info("==========蓝牙称 内存测试")
                            delay(200)
                        } else {
                            showToast("请手动输入")
                            weiView()
                            break
                        }
                    } while (true)
                }

            } else {
                // 连接失败的处理逻辑
                showToast("连接失败或超时", Toast.LENGTH_SHORT)
                weiView()
            }
        } else {
            // 根据设备名称获取的设备地址为空，处理无法找到设备的情况
            showToast("找不到设备", Toast.LENGTH_SHORT)
            weiView()
        }
//        }

    }

    private fun showToast(message: String, duration: Int) {
        Toast.makeText(this, message, duration).show()
    }

    //超过量程
    private fun turnOffWeighing() {
        showToast("超过量程,手动输入")
        mJoinType = 2
        mWeighingValue!!.isEnabled = true
//        jobTow?.cancel()
    }

    private fun closEndTwo() {
//        jobTow?.cancel()
        mWeighDialog!!.dismiss()
        emptyViewsTwo()
    }

    private fun closEnd() {
        dismissLoading()
//        jobTow?.cancel()
        mWeighDialog!!.dismiss()
        emptyViewsTwo()
        taskStarted = false
        val weigh =
                mWeighingValue!!.text.toString().trim()  //称重后的重量
        if (weigh.isEmpty()) {
            showToast("未称重")
            return
        }
        if (weigh.toDouble() <= 0) {
            showToast("当前重量有误")
            return
        }
        val topicName = viewBinding.topicName.text.toString()
                .trim() //课题组 名称
        var belongType = 2
        if (topicName.isNotBlank()) {
            belongType = 1
        }

//        val netContent =
//            modelA.chemicalDensity * modelA.specNum  // 净含量 = 密度*规格

        var netContent = BigDecimal(0.0)
        when {
            modelA.specUnit.equals("g") -> {
                netContent = BigDecimal(weigh).subtract(modelA.packNum)
            }
            modelA.specUnit.equals("ml") -> {
                val subtract = BigDecimal(weigh).subtract(modelA.packNum)
                netContent =
                        ConversionUtils.gramsToMilliliters(
                                subtract,
                                BigDecimal(modelA!!.chemicalDensity)
                        )
            }
        }

        RcLog.info("=======当前3选择 $mLayers")
        var model = StockModel(
                "${modelA.belongId}",
                "${modelA.belongName}",
                belongType,
                mChemicalInfoBean!!.buildId,
                mChemicalInfoBean!!.buildName,
                mCabinetId,
                mCabinetName,
                modelA.casNum,
                modelA.chemicalCategory!!.toInt(),
                modelA.chemicalId!!,
                modelA.chemicalLevel,
                modelA.chemicalName!!,
                "${mStockDetailsModel!!.size}",
                modelA.chemicalPurity,
                mChemicalInfoBean!!.deptId,
                mChemicalInfoBean!!.deptName,
                viewBinding.cabinet.tag.toString(),
                mDoorName,
                modelA.factory!!,
                mChemicalInfoBean!!.floorId,
                mChemicalInfoBean!!.floorName,
                modelA.isNew,
                mJoinType,   //入库方式1 称重，2 录入
                "", //视频地址
                mLayersTow,     //当前选择得
                mLayers,     //一共几层
                modelA.packNum,
                modelA.packUnit!!,
                modelA.specNum.toDouble(),
                modelA.specUnit!!,
                mStockDetailsModel,
                6,
                mChemicalInfoBean!!.subId,
                mChemicalInfoBean!!.subName,
                mChemicalInfoBean!!.roomNum,
                null,
                mWeighingValue!!.text.toString().toDouble(),
                netContent.toDouble(),
                expireTime = null
        )
        verificationData(model)
    }


    private fun inAdapter() {
        viewBinding.recyclerViewList?.layoutManager =
                LinearLayoutManager(this)
        viewBinding.recyclerViewList?.adapter = mAdapter
        mAdapter.setOnItemChildClickListener { adapter, view, position ->
            // 在这里处理子View的点击事件
            when (view.id) {
                R.id.imgDelete -> {
                    mAdapter.data.removeAt(position)
                    mStockModelList = mAdapter.data
                    mAdapter.notifyItemRemoved(position)
                    RcLog.info("=======当前条数 ${mStockModelList!!.size}")
                    if (mStockModelList!!.size == 0) {
                        RcLog.info("=======当前条数 ${mStockModelList!!.size}")
                        viewBinding.imgPosition.visibility = View.VISIBLE
                    }
                }
            }
        }
    }

    override fun initData() {
        super.initData()
        val handler = Handler(Looper.getMainLooper())
        timeUpdater = TimeUpdater(handler) { currentTime ->
            viewBinding.nowTime.text = "$currentTime"
        }
        // 启动定时更新
        timeUpdater.startUpdating()

        getRelList(ChemicalApp.subjectId!!)

    }


    //查询存储位置  默认第一个
    private fun getCabinet(subId: String) {
        showLoading("查询中...")
        val disposable = ApiRepository.getCabinetList(subId)
                .subscribe({ data ->
                    dismissLoading()
                    mListData = data
                    viewBinding.cabinet.text =
                            "存储位置:${mListData!![0].cabinetName}-${mListData!![0].cabinetDoorVoList[0].doorName}"
                    viewBinding.cabinet.tag =
                            "${mListData!![0].cabinetDoorVoList[0].doorUniqueId}"
                    mCabinetLockVoList =
                            mListData!![0].cabinetDoorVoList[0].cabinetLockVoList  //柜锁几条
                    mLayers =
                            mListData!![0].cabinetDoorVoList[0].doorLayers//当前几层

                    mCabinetId = mListData!![0].cabinetId
                    mCabinetName = mListData!![0].cabinetName
                    mDoorId = mListData!![0].cabinetDoorVoList[0].doorUniqueId
                    mDoorName = mListData!![0].cabinetDoorVoList[0].doorName
                    mLockNum = mListData!![0].lockNum

                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)

                })
        addDisposable(disposable)
    }

    // 获取实验室基本信息
    private fun getRelList(subjectId: String) {
        showLoading("加载中...")
        val disposable = ApiRepository.getRelList(subjectId)
                .subscribe({ data ->
                    dismissLoading()
                    mChemicalInfoBean = data

                    getCabinet(mChemicalInfoBean!!.subId)
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)

                })
        addDisposable(disposable)
    }

    //化学品/cas搜索
    private fun searchChemica(
            searchValue: String,
            chemicalLevel: String?
    ) {
//        val chemicalName = viewBinding.chemicalName.text.toString()
//        val cas = viewBinding.casNum.text.toString()
        RcLog.info("=============管控搜索$searchValue $chemicalLevel")
        showLoading("加载中...")
        val disposable =
                ApiRepository.searchChemica(searchValue, chemicalLevel)
                        .subscribe({ data ->
                            dismissLoading()
                            val mDialog =
                                    DcaeDialog(
                                            this,
                                            data.toMutableList(),
                                            object : DcaeDialog.IonItemClick {
                                                override fun onItem(chemicalSearchBean: ChemicalSearchBean) {
                                                    upView(chemicalSearchBean)
                                                }
                                            })
                            mDialog.show()
                        }, { throwable ->
                            dismissLoading()
                            showNetError(throwable)

                        })
        addDisposable(disposable)
    }

    //查询结果  更新回显信息
    private fun upView(chemicalSearchBean: ChemicalSearchBean) {
        mChemicalId = chemicalSearchBean.chemicalId
        viewBinding.chemicalName.setText("${chemicalSearchBean.chemicalName}")
        if (chemicalSearchBean.casNum != null) {
            viewBinding.casNum.setText("${chemicalSearchBean.casNum}")
        }
        viewBinding.chemicalDensity.setText("${chemicalSearchBean.chemicalDensity}")
        if (chemicalSearchBean.chemicalPurity != null) {
            viewBinding.chemicalPurity.setText("${chemicalSearchBean.chemicalPurity}")
        }
        if (chemicalSearchBean.specNum != null) {
            viewBinding.specNum.setText("${chemicalSearchBean.specNum}")
        }
        if (chemicalSearchBean.depositUnit != null) {
            when (chemicalSearchBean.depositUnit) {
                "L" -> { //升
                    viewBinding.bugCationsRight.isChecked = true
                    viewBinding.bugCationsLeft.isChecked = false
                    viewBinding.bugCationsLeft.isEnabled = false
                    viewBinding.packUnit.text = "瓶"
                }
                "KG" -> { //千克
                    viewBinding.bugCationsLeft.isChecked = true
                    viewBinding.bugCationsRight.isChecked = false
                    viewBinding.bugCationsRight.isEnabled = false
                    viewBinding.packUnit.text = "件"
                }
                "g" -> { //克
                    viewBinding.bugCationsLeft.isChecked = true
                    viewBinding.bugCationsRight.isChecked = false
                    viewBinding.bugCationsRight.isEnabled = false
                    viewBinding.packUnit.text = "件"

                }
                "ml" -> {//毫升
                    viewBinding.bugCationsRight.isChecked = true
                    viewBinding.bugCationsLeft.isChecked = false
                    viewBinding.bugCationsLeft.isEnabled = false
                    viewBinding.packUnit.text = "瓶"
                }
            }
        }

        if (chemicalSearchBean.packNum != null) {
            viewBinding.packNum.setText("${chemicalSearchBean.packNum}")
        }

        chemTypeIsBoo = false
        if (chemicalSearchBean.chemicalCategory != null) {
            viewBinding.chemType.text = "${chemicalSearchBean.chemicalCategoryName}"
            viewBinding.chemType.tag = "${chemicalSearchBean.chemicalCategory}"
        }

        viewBinding.bugCationsLeft.isEnabled = false
        viewBinding.bugCationsRight.isEnabled = false
        if (chemicalSearchBean.chemicalLevel == 2) {
            viewBinding.butUnregulated.isChecked = true
            viewBinding.butControl.isChecked = false
        } else {
            viewBinding.butControl.isChecked = true
            viewBinding.butUnregulated.isChecked = false
        }
    }


    //厂家搜索
    private fun searchProducer() {
        val disposable = ApiRepository.searchProducer()
                .subscribe({ data ->
                    mOptionsList.clear()
                    data.forEach {
                        mOptionsList.add(it.producerName)
                    }
//                    val adapter =
//                            ArrayAdapter(this, android.R.layout.simple_dropdown_item_1line, mOptionsList)

                    // 创建 ArrayAdapter 并使用自定义布局
                    val adapter = object : ArrayAdapter<String>(this, R.layout.dropdown_item, R.id.text, mOptionsList) {
                        override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
                            val view = super.getView(position, convertView, parent)
                            val textView: TextView = view.findViewById(R.id.text)
                            // 设置字体大小
                            textView.textSize = 10f
                            // 设置行高
                            val params = textView.layoutParams
                            params.height = 30 // 设置行高为 60 像素
                            textView.layoutParams = params
                            return view
                        }
                    }

                    viewBinding.edManufacturer.setAdapter(adapter)
                }, { throwable ->
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }

    //规格值查询包装值
    private fun searchSpecView(specNum: String) {
        val disposable = ApiRepository.searchSpec(specNum)
                .subscribe({ data ->
                    if (data != null) {
                        if (data.packNum != null) {
                            viewBinding.packNum.setText("${data.packNum}")
                        }
                    }
                }, { throwable ->
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }


    override fun onDestroy() {
        super.onDestroy()
        // 停止定时更新
        timeUpdater.stopUpdating()
//        jobTow?.cancel()

        mPortScanHelper.onPause()
        // 停止定时任务
        try {
            handlerUtil.stopAllTasks()
            countdownTimer?.cancel()
//            timerLock.cancel()
            closePort()
        } catch (e: Exception) {
        }
        try {
            timeUpdater.stopUpdating()
        } catch (e: Exception) {
        }
        // 停止定时更新
        unregisterReceiver(mUsbReceiver)
        EventBus.getDefault().unregister(this) //关闭广播
    }

    //清空所有试图  进行新的录入
    private fun emptyViews() {
        viewBinding.chemicalName.setText("")
        viewBinding.casNum.setText("")
        viewBinding.edManufacturer.setText("")
        viewBinding.chemicalPurity.setText("")
        viewBinding.chemicalDensity.setText("1")
        viewBinding.specNum.setText("")
        viewBinding.packNum.setText("")
        viewBinding.number.setText("1")
        viewBinding.packUnit.text = "瓶"
        viewBinding.chemType.text = ""
        viewBinding.topic.text = "搜索"
        hideKeyboard()
        if (mStockModelList != null) {
            mStockModelList.clear()
        }
        closeKeyboard(viewBinding.number)
        closeKeyboard(viewBinding.chemicalName)
        closeKeyboard(viewBinding.casNum)
        closeKeyboard(viewBinding.edManufacturer)
        closeKeyboard(viewBinding.chemicalPurity)
        closeKeyboard(viewBinding.chemicalDensity)
        closeKeyboard(viewBinding.specNum)
        closeKeyboard(viewBinding.packNum)
        closeKeyboard(viewBinding.number)
        mHandleScanEvent = false

    }

    private fun hideKeyboard() {
        val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(currentFocus?.windowToken, 0)
    }

    //清空所有试图  进行新的录入
    private fun emptyViewsTwo() {
        viewBinding.chemicalName.setText("")
        viewBinding.casNum.setText("")
        viewBinding.edManufacturer.setText("")
        viewBinding.chemicalPurity.setText("")
        viewBinding.chemicalDensity.setText("1")
        viewBinding.specNum.setText("")
        viewBinding.packNum.setText("")
        viewBinding.number.setText("1")
        viewBinding.packUnit.text = "瓶"
        viewBinding.chemType.text = ""
        viewBinding.topic.text = "搜索"
        closeKeyboard(viewBinding.chemicalName)
        closeKeyboard(viewBinding.casNum)
        closeKeyboard(viewBinding.edManufacturer)
        closeKeyboard(viewBinding.chemicalPurity)
        closeKeyboard(viewBinding.chemicalDensity)
        closeKeyboard(viewBinding.specNum)
        closeKeyboard(viewBinding.packNum)
        closeKeyboard(viewBinding.number)
    }

    private fun closeKeyboard(editText: EditText) {
        editText.clearFocus()
    }

    //=========================刷卡start================
    //刷卡信息  调用当前化学品信息 进行归还
    private fun handleScanEvent(cont: String) {
        RcLog.info("=====刷卡信息$cont")
        showLoading("查询中...")
        val disposable =
//            ApiRepository.chemicalSearchBean("202310160919545345", ChemicalApp.subjectId!!)
                ApiRepository.chemicalSearchBean(cont, ChemicalApp.subjectId!!)
                        .subscribe({ data ->
                            dismissLoading()
                            upView(data)
                        }, { throwable ->
                            dismissLoading()
                            showNetError(throwable)
                            mHandleScanEvent = false
                        })
        addDisposable(disposable)
    }


    private val mPortScanHelper by lazy {
        PortScanHelper(this, object : OnSerialScanListener {
            override fun dispatchScanEvent(
                    type: OnSerialScanListener.ScanType,
                    content: String
            ) {
                if (!mHandleScanEvent) {
                    if (content.isNotBlank()) {
                        mHandleScanEvent = true
                        handleScanEvent(content)
                    }
                }
            }

        })
    }

    //刷卡usb链接
    private fun registerUsbBroadcast() {
        if (null == mUsbReceiver) {
            val filter = IntentFilter().apply {
                addAction(UsbReceiver.ACTION_USB_PERMISSION)
                addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED)
                addAction(UsbManager.ACTION_USB_DEVICE_DETACHED)
                addAction(UsbReceiver.ACTION_USB_STATE) // usb连接状态广播
            }
            mUsbReceiver = UsbReceiver()
            registerReceiver(mUsbReceiver, filter)
        }
    }

    override fun onResume() {
        super.onResume()
        mPortScanHelper.onResume()
        registerUsbBroadcast()
        try {
            if (Constants.AUTHENTICATION) {
                try {// 从 SharedPreferences 中取出集合
                    val retrievedList =
                            SharedPreferencesHelper.getList(this@AddedChemicalsActivity)
                    if (retrievedList != null && retrievedList.size > 0) {
                        RcLog.info("===a===${retrievedList[0].userId}")
                        if (mStockModelList != null && mStockModelList.size > 0) {
                            mStockModelList.forEach {
                                it.oneUserId = "${retrievedList[0].userId}"
                                it.oneUserName = "${retrievedList[0].name}"
                                it.twoUserId = "${retrievedList[1].userId}"
                                it.twoUserName = "${retrievedList[1].name}"
                            }
                        }
//                        // 清空 SharedPreferences 中的集合
//                        SharedPreferencesHelper.clearList(this@AddedChemicalsActivity)
                    }
                } catch (e: Exception) {

                }
                //1无锁，2是智能锁，3是钥匙柜
                if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
                    mLockStr.clear()
                    mCabinetLockVoList!!.forEach { it ->
                        when (it.unlockingMethod) {
                            2 -> { //智能锁
                                mLockStr.add("${it.lockNum}")
                            }
                        }
                    }
                    if (mLockStr != null && mLockStr.size > 0) {
                        openLock(mLockStr)
                    } else {
                        subAddData(0)
                    }
                } else {
                    subAddData(0)
                }
                Constants.AUTHENTICATION = false
            }
        } catch (e: Exception) {
            Constants.AUTHENTICATION = false

        }

    }

    //获取刷卡信息
    override fun dispatchKeyEvent(event: KeyEvent?): Boolean {
        mPortScanHelper.dispatchKeyEvent(event)
        return super.dispatchKeyEvent(event)
    }

    //停止 销毁广播传递
    override fun onPause() {
        mPortScanHelper.onPause()
        super.onPause()
    }


    //必须写这个方法  防止注册失败
    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onUpdateEventEvent(event: KeyEvent) {

    }


    //=========================刷卡end==================


    override fun onBackPressed() {
        super.onBackPressed()
        finish()
    }


    override fun onActivityResult(
            requestCode: Int,
            resultCode: Int,
            data: Intent?
    ) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == Constants.REQUEST_CODE && resultCode == Activity.RESULT_OK) {
            val value = data?.getBooleanExtra("isLogin", false) // 获取返回的参数
            if (value == true) {
//                //1无锁，2是智能锁，3是钥匙柜
//                if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
//                    mCabinetLockVoList!!.forEach { it ->
//                        when (it.unlockingMethod) {
//                            2 -> { //智能锁
//                                mLockStr.add("${it.lockNum}")
//                            }
//                        }
//                    }
//                    if (mLockStr != null && mLockStr.size > 0) {
//                        openLock(mLockStr)
//                    } else {
//                        subAddData()
//                    }
//                } else {
//                    subAddData()
//                }
            } else {
                showToast("认证失败!!")
            }
        }
    }

    //开锁
    private fun openLock(mLockStr: ArrayList<String>) {
        val map = mutableMapOf<String, Any>()
        map["subId"] = mStockModeBean.stockModelList[0].subId
        map["subName"] = mStockModeBean.stockModelList[0].subName
        map["cabinetId"] = "$mCabinetId"
        map["cabinetName"] = "$mCabinetName"
        map["doorId"] = "$mDoorId"
        map["doorName"] = "$mDoorName"
//        map["lockNum"] = "guisuo001"
        map["lockNumList"] = mLockStr
        map["operationType"] = 1
        if (ChemicalApp.subRoom != null) {
            map["subRoom"] = ChemicalApp.subRoom!!
        }
        map["type"] = true
        try {// 从 SharedPreferences 中取出集合
            val retrievedList = SharedPreferencesHelper.getList(this)
            if (retrievedList != null && retrievedList.size > 0) {
                RcLog.info("===b===${retrievedList[0].userId}")
                map["oneUserId"] = "${retrievedList[0].userId}"
                map["oneUserName"] = "${retrievedList[0].name}"
                map["twoUserId"] = "${retrievedList[1].userId}"
                map["twoUserName"] = "${retrievedList[1].name}"
                // 清空 SharedPreferences 中的集合
//                SharedPreferencesHelper.clearList(this)
            }
        } catch (e: Exception) {
        }

        showLoading("加载中...")
        val disposable = ApiRepository.lockOperate(map)
                .subscribe({ data ->
                    dismissLoading()
                    val containsFalse =
                            mCabinetLockVoList!!.any { it.isOk == false && it.unlockingMethod == 2 }
                    if (containsFalse) {
                        showLoading("查询中...")
                        // 开始执行任务，每 3 秒执行一次
                        startCountdownLock()
                        handlerUtil.startTask(task, 1000)
                    } else {
                        try {
                            countdownTimer?.cancel()
                        } catch (e: Exception) {
                        }
                        dismissLoading()
                        //开锁成功
                        subAddData(1)
                        handlerUtil.stopAllTasks()
                    }
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)

    }

    private var countdownTimer: CountDownTimer? = null
    private fun startCountdownLock() {
        val totalTime = 30 * 1000 // 30秒
        val interval = 1000 // 每秒更新一次
        countdownTimer = object : CountDownTimer(totalTime.toLong(), interval.toLong()) {
            override fun onTick(millisUntilFinished: Long) {
                val secondsLeft = millisUntilFinished / 1000
                println("剩余时间: $secondsLeft 秒")
            }

            override fun onFinish() {
                println("倒计时结束！")
                mCabinetLockVoList = null
                mLockStr.clear()
                showToast("开锁超时,可重新操作")
                dismissLoading()
                handlerUtil.stopAllTasks()
                // 在这里执行合适的操作，比如退出应用程序
            }
        }
        println("倒计时开始...")
        countdownTimer?.start()

    }


    private val task = Runnable {
        //判断所有的锁开锁成功
        val containsFalse =
                mCabinetLockVoList!!.any { it.isOk == false && it.unlockingMethod == 2 }
        if (containsFalse) {
            getLocks()
        } else {
            try {
                countdownTimer?.cancel()
            } catch (e: Exception) {
            }
            dismissLoading()
            //开锁成功
            subAddData(1)
            handlerUtil.stopAllTasks()
        }
    }


    //查询开锁信息
    private fun getLocks() {
        mCabinetLockVoList!!.forEachIndexed { index, fruit ->
            if (fruit.isOk == false && fruit.unlockingMethod == 2) {
                getLocksDate(index, fruit.lockNum)
            }
        }
    }

    //查询开锁状态
    private fun getLocksDate(index: Int, fruit: String) {
        val disposable = ApiRepository.getLocks(ChemicalApp.subjectId!!, fruit)
                .subscribe({ data ->
                    if (data) {
                        mCabinetLockVoList!![index].isOk = true
                    }
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }

    /**
     * 0  没有图标 1 绿色(成功)   2红色（失败）
     *   失败或者成功的弹框
     */
    private fun customDialogView(types: Int, msg: String) {
        val customDialog = CustomDialog(this, types, msg)
        customDialog.show()
    }

    /**
     * 异常处理
     */
    private fun throwableView(throwable: Throwable) {
        when (throwable) {
            is NetException -> {
                if (throwable.message.isNullOrEmpty()) {
                    "接口请求失败(${throwable.code})"
                } else {
                    throwable.message!!
                }
            }
            is SocketTimeoutException -> "请求超时，请稍后重试"
            is ConnectException -> "无法连接服务器，请检查网络"
            is HttpException -> "服务器繁忙，请稍后重试"
            else -> null
        }?.let { customDialogView(2, "$it") }
    }

}