class SerialPortProxy {

    companion object {
        private const val TAG = "SerialPortProxy"
    }

    private lateinit var serialPortManager: SerialPortManager

    private var isInitSuccess = false

    private val isInit
        get() = isInitSuccess

    private fun initSdk() {
        searchAllDevices()

        serialPortManager = SerialPortKit.newBuilder(ContextProvider.appContext)
            // 设备地址
            .path("/dev/ttyS0")
            // 波特率
            .baudRate(115200)
            // Byte数组最大接收内存
            .maxSize(1024)
            // 发送失败重试次数
            .retryCount(2)
            // 发送一次指令，最多接收几次设备发送的数据，局部接收次数优先级高
            .receiveMaxCount(1)
            // 是否按照 maxSize 内存进行接收
            .isReceiveMaxSize(false)
            // 是否显示吐司
            .isShowToast(true)
            // 是否Debug模式，Debug模式会输出Log
            .debug(BuildConfig.DEBUG)
            // 是否自定义校验下位机发送的数据正确性，把校验好的Byte数组装入WrapReceiverData
            .isCustom(true, DataConvertUtil.customProtocol())
            // 阻塞式接收数据
            .isBlockingReadData(true)
            // 提权 `su shell` 切换
            .setCmdSuShell(SerialPort.CMD_BIN_SU_SHELL)
            // 校验发送指令与接收指令的地址位，相同则为一次正常的通讯
            .addressCheckCall(DataConvertUtil.addressCheckCall())
            .build()
            .get()

        isInitSuccess = true
    }

    private fun reInitSdk() {
        if (!isInit) {
            initSdk()
        }
    }

    fun searchAllDevices() {
        try {
            val serialPortFinder = SerialPortFinder()
            serialPortFinder.allDevices.forEach {
                Log.d(TAG, "搜索到的串口信息为: $it")
            }
        } catch (e: Exception) {
            Log.d(TAG, "initSerialPort: ", e)
        }
    }

    val portManager: SerialPortManager
        get() {
            reInitSdk()
            return serialPortManager
        }
}

object SerialPortHelper {
    private val mProxy = SerialPortProxy()

    /**
     * 暴露SDK
     */
    val portManager: SerialPortManager
        get() = mProxy.portManager

    /**
     * 内部使用，默认开启串口
     */
    private val serialPortManager: SerialPortManager
        get() {
            // 默认开启串口
            if (!mProxy.portManager.isOpenDevice) {
                mProxy.portManager.open()
            }
            return portManager
        }
}

if (!SerialPortHelper.portManager.isOpenDevice) {
    val open = SerialPortHelper.portManager.open()
    Log.d(TAG, "串口打开${if (open) "成功" else "失败"}")
}

val close = SerialPortHelper.portManager.close()
Log.d(TAG, "串口关闭${if (close) "成功" else "失败"}")

data class WrapSendData
@JvmOverloads constructor(
    var sendData: ByteArray,
    var sendOutTime: Int = 3000,
    var waitOutTime: Int = 300,
    @IntRange(from = 0, to = 3)
    var receiveMaxCount: Int = 0
) {
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as WrapSendData

        if (!sendData.contentEquals(other.sendData)) return false
        if (sendOutTime != other.sendOutTime) return false
        if (waitOutTime != other.waitOutTime) return false
        if (receiveMaxCount != other.receiveMaxCount) return false

        return true
    }

    override fun hashCode(): Int {
        var result = sendData.contentHashCode()
        result = 31 * result + sendOutTime
        result = 31 * result + waitOutTime
        result = 31 * result + receiveMaxCount
        return result
    }
}

SerialPortHelper.portManager.send(WrapSendData(
    SenderManager.getSender().sendStartDetect()
),
    object : OnDataReceiverListener {
        override fun onSuccess(data: WrapReceiverData) {
            Log.d(TAG, "响应数据：${TypeConversion.bytes2HexString(data.data)}")
        }

        override fun onFailed(wrapSendData: WrapSendData, msg: String) {
            Log.e(
                TAG,
                "发送数据: ${TypeConversion.bytes2HexString(wrapSendData.sendData)}, $msg"
            )
        }

        override fun onTimeOut() {
            Log.e(TAG, "发送或者接收超时")
        }
    })

class SimpleSerialPortTask(
    private val wrapSendData: WrapSendData,
    private val onDataReceiverListener: OnDataReceiverListener
) : BaseSerialPortTask() {
    override fun sendWrapData(): WrapSendData = wrapSendData

    override fun onDataReceiverListener(): OnDataReceiverListener = onDataReceiverListener

    override fun onTaskStart() {

    }

    override fun onTaskCompleted() {

    }

    override fun mainThread(): Boolean {
        return false
    }
}

SerialPortHelper.portManager.send(
    SimpleSerialPortTask(
        WrapSendData(
            SenderManager.getSender().sendStartDetect()
        ), object : OnDataReceiverListener {
            override fun onSuccess(data: WrapReceiverData) {
                Log.d(TAG, "响应数据：${TypeConversion.bytes2HexString(data.data)}")
            }

            override fun onFailed(wrapSendData: WrapSendData, msg: String) {
                Log.e(
                    TAG,
                    "发送数据: ${TypeConversion.bytes2HexString(wrapSendData.sendData)}, $msg"
                )
            }

            override fun onTimeOut() {
                Log.e(TAG, "发送或者接收超时")
            }
        })
)

val switchDevice = SerialPortHelper.portManager.switchDevice(path = "/dev/ttyS1")
Log.d(TAG, "串口切换${if (switchDevice) "成功" else "失败"}")

val switchDevice = SerialPortHelper.portManager.switchDevice(baudRate = 9600)
Log.d(TAG, "波特率切换${if (switchDevice) "成功" else "失败"}")

override fun onResume() {
    super.onResume()
    // 增加统一监听回调
    SerialPortHelper.portManager.addDataPickListener(onDataPickListener)
}

override fun onPause() {
    super.onPause()
    // 移除统一监听回调
    SerialPortHelper.portManager.removeDataPickListener(onDataPickListener)
}

private val onDataPickListener: OnDataPickListener = object : OnDataPickListener {
    override fun onSuccess(data: WrapReceiverData) {
        Log.d(TAG, "统一响应数据：${TypeConversion.bytes2HexString(data.data)}")
    }
}

object SerialCommandProtocol : BaseProtocol() {
    // TODO: Something
}

class AdapterSender : Sender {
    // TODO: Something
}

object SenderManager {
    private var senderMap = hashMapOf<Int, Sender>()

    /**
     * 获取发送者
     */
    @JvmOverloads
    fun getSender(type: Int = 0): Sender {
        if (senderMap[type] == null) {
            senderMap[type] = createSender(type)
        }
        return senderMap[type]!!
    }

    /**
     * 创建发送者
     *
     * @param type
     * @return
     */
    private fun createSender(type: Int): Sender {
        return when (type) {
            0, 1 -> AdapterSender()
            else -> AdapterSender()
        }
    }
}