package com.grkj.iscs.modbus

import android.content.Context
import com.grkj.iscs.util.Executor
import com.grkj.iscs.util.log.LogUtil
import java.util.concurrent.Executors


/**
 * ModBus 主控板控制器
 */
object ModBusController {

    /**
     * 所有的设备列表
     */
    var deviceList: MutableList<DeviceBean> = mutableListOf()

    private const val LISTENER_TYPE_STATUS = 3

    // 主控板管理器
    private var modBusManager: ModBusManager? = null
    private var slaveCount: Int = 0

    private val threadPool = Executors.newScheduledThreadPool(4)

    private val listeners = ArrayList<StatusListener>()

    // 是否中断读取状态
    private var interruptReadStatus: ArrayList<Boolean> = ArrayList()

    var shouldStopUpgrade = false

    fun setSlaveCount(count: Int) {
        modBusManager?.slaveCount = count
        slaveCount = count
    }

    class StatusListener(
        val key: Any,
        val listener: (Any) -> Unit,
        val type: Int
    )

    fun interruptReadTrashBinStatus(interrupt: Boolean) {
        interruptReadStatus.clear()
        interruptReadStatus.add(interrupt)
    }

    @ExperimentalUnsignedTypes
    fun start(ctx: Context) {
        modBusManager?.stop()
        PortManager.openCtrlBord(ctx)
            ?.let { pm ->
                return@let ModBusManager(slaveCount, pm, true)
            }
            // 间隔 1 秒读一遍桶的状态
            ?.repeatSendToAll(MBFrame.READ_STATUS, {
                interruptReadStatus
            }, { res ->
//                // Logger.d("ModbusController", "res: ${res.map { it.toHexString() }}")
                LogUtil.i("****************************************************************************")
                for (l in listeners) {
                    if (l.type == LISTENER_TYPE_STATUS) {
                        l.listener(res)
                    }
                }
                // TODO 临时改成5s
//            }, 1000)
            }, 5000)
            ?.also {
                modBusManager = it
                Executor.runOnIO {
//                    refreshAllowOpenDoorUnidentified(ctx, it)
                }
            }
            ?.start()
    }

    fun registerStatusListener(key: Any, listener: (Any) -> Unit) {
        listeners.add(StatusListener(key, listener, LISTENER_TYPE_STATUS))
    }

    fun unregisterListener(key: Any) {
        val it = listeners.iterator()
        while (it.hasNext()) {
            if (it.next().key == key) {
                it.remove()
            }
        }
    }

    fun stop() {
        modBusManager?.stop()
    }


    /*****************************************************************************************/

    fun checkStatus(byteArray: ByteArray): Any? {
        if (byteArray.isEmpty()) {
            return null
        }
        return deviceList.find { it.idx == byteArray[0] }?.parseStatus(byteArray)
    }

    /**
     * 读取设备类型
     */
    fun readDeviceType(done: ((res: List<ByteArray>) -> Unit)? = null) {
        modBusManager?.sendToAll(MBFrame.READ_DEVICE_TYPE) { res ->
            done?.invoke(res)
        }
    }

    /**
     * 读取卡扣状态
     */
    fun readBuckleStatus(index: Int?, doneSingle: ((res: ByteArray) -> Unit)? = null, doneAll: ((res: List<ByteArray>) -> Unit)? = null) {
        index?.let {
            modBusManager?.sendTo(it, MBFrame.READ_BUCKLE_STATUS) { res ->
                doneSingle?.invoke(res)
            }
        } ?: let {
            modBusManager?.sendToAll(MBFrame.READ_BUCKLE_STATUS) { res ->
                doneAll?.invoke(res)
            }
        }
    }

    fun openLockBuckle(slaveIdx: Int?, lockIdx: Int, done: ((res: ByteArray) -> Unit)? = null)  {
        slaveIdx?.let {
            modBusManager?.generateLockBuckleCmd(true, lockIdx)?.let { cmd ->
                modBusManager?.sendTo(it, cmd) { res ->
                    done?.invoke(res)
                }
            }
        }
    }
    
    fun closeLockBuckle(slaveIdx: Int?, lockIdx: Int, done: ((res: ByteArray) -> Unit)? = null)  {
        slaveIdx?.let {
            modBusManager?.generateLockBuckleCmd(false, lockIdx)?.let { cmd ->
                modBusManager?.sendTo(it, cmd) { res ->
                    done?.invoke(res)
                }
            }
        }
    }

    fun readLockRfid(slaveIdx: Int?, lockIdx: Int, done: ((res: ByteArray) -> Unit)? = null) {
        slaveIdx?.let {
            modBusManager?.generateLockRfidCmd(lockIdx)?.let { cmd ->
                modBusManager?.sendTo(it, cmd) { res ->
                    done?.invoke(res)
                }
            }
        }
    }

    /**
     * 更新锁具RFID
     */
    fun updateLockRfid(slaveIdx: Int, lockIdx: Int, rfid: String) {
        deviceList.find { it.idx?.toInt() == slaveIdx }?.lockList?.find { it.idx == lockIdx }?.rfid = rfid
    }
}