package com.dlc.chemical.print

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.hardware.usb.UsbManager
import android.util.Log
import com.rc.core.log.RcLog
import java.text.DecimalFormat
import java.util.*

/**
 * info
 *
 * @author ReiChin_
 */
class PrinterStateReceiver(private val printerListener: PrinterListener? = null) : BroadcastReceiver() {

    companion object {
        private const val TAG = "ReiChin_PSReceiver"

        const val ACTION_PRINTER_STATE = "PrinterState"
    }

    override fun onReceive(context: Context?, intent: Intent?) {
        val byteResult = intent?.getByteArrayExtra(ACTION_PRINTER_STATE)
        val stringState = bytesToHexString(byteResult) ?: ""
        RcLog.info("print receive:${stringState}")
        when {
            stringState.indexOf("FC4F4B") != -1 -> {
                // 打印完成（FC 4F 4B）
                Log.i(TAG, "onReceive() 打印完成")
                printerListener?.onPrintResult(true, "打印完成")
            }
            stringState.indexOf("FC6E6F") != -1 -> {
                // 打印未完成（FC 6E 6F）
                Log.i(TAG, "onReceive() 打印未完成")
                printerListener?.onPrintResult(false, "打印未完成")
            }
            stringState.indexOf("EF231A") != -1 -> {
                // 缺纸（EF 23 1A）
                Log.i(TAG, "onReceive() 打印机缺纸")
                printerListener?.onPrintResult(false, "打印机缺纸")
            }
            stringState.indexOf("FE2312") != -1 -> {
                // 有纸（FE 23 12）
                Log.i(TAG, "onReceive() 打印机有纸")
            }
            stringState.indexOf("FE2410") != -1 -> {
                // 纸将尽（FE 24 10）
                Log.i(TAG, "onReceive() 打印机纸将尽")
            }
            stringState.indexOf("FE2411") != -1 -> {
                // 纸还有（FE 24 11）
                Log.i(TAG, "onReceive() 打印机纸充足")
            }
            stringState.indexOf("FE2510") != -1 -> {
                // 温度正常（FE 25 10）
                Log.i(TAG, "onReceive() 温度正常")
            }
            stringState.indexOf("FE2511") != -1 -> {
                // 温度不正常（FE 25 11）
                Log.i(TAG, "onReceive() 温度不正常")
            }
            stringState.indexOf("FE2610") != -1 -> {
                // 切刀复位（FE 26 10）
                Log.i(TAG, "onReceive() 切刀复位")
            }
            stringState.indexOf("FE2611") != -1 -> {
                // 切刀未复位（FE 26 11）
                Log.i(TAG, "onReceive() 切刀未复位")
            }
            stringState.indexOf("FE2710") != -1 -> {
                // 胶辊合上（FE 27 10）
                Log.i(TAG, "onReceive() 胶辊合上")
            }
            stringState.indexOf("FE2711") != -1 -> {
                // 胶辊开着（FE 27 11）
                Log.i(TAG, "onReceive() 胶辊开着")
            }
            stringState.indexOf("FE2810") != -1 -> {
                // 纸张正常（FE 28 10）
                Log.i(TAG, "onReceive() 纸张正常")
            }
            stringState.indexOf("FE2811") != -1 -> {
                // 卡纸（FE 28 11）
                Log.i(TAG, "onReceive() 卡纸")
                printerListener?.onPrintResult(false, "卡纸")
            }
            stringState.indexOf("FE2B10") != -1 -> {
                // 电压正常（FE 2B 10）
                Log.i(TAG, "onReceive() 电压正常")
            }
            stringState.indexOf("FE2B11") != -1 -> {
                // 电压异常（FE 2B 11）
                Log.i(TAG, "onReceive() 电压异常")
            }
            stringState.indexOf("FE2B10") != -1 -> {
                // 蓝牙连接（FE 2C 10）
                Log.i(TAG, "onReceive() 蓝牙连接")
            }
            stringState.indexOf("FE2B11") != -1 -> {
                // 蓝牙已断开（FE 2C 11）
                Log.i(TAG, "onReceive() 蓝牙已断开")
            }
            stringState.indexOf("FE29") != -1 -> {
                // 温度值：FE 29 xx xx (xx xx 温度值放大 100 倍 如返回25.2度 FE 29 D8 09  xx xx 低位在前高位在后)
                if (null != byteResult && byteResult.size >= 4) {
                    val low = byteResult[2].toInt() and 0xFF
                    val high: Int = byteResult[3].toInt() and 0xFF
                    val result = high shl 8 or low //先将高位左移，在与低位相与
                    val value = result / 100.00
                    val decimalFormat = DecimalFormat(".00") //构造方法的字符格式这里如果小数不足2位,会以0补足.
                    Log.i(TAG, "onReceive() 温度:${decimalFormat.format(value)}°C")
                } else {
                    Log.i(TAG, "onReceive() 温度:未知")
                }
            }
            stringState.indexOf("FE2A") != -1 -> {
                // 电压值：FE 2A xx xx (xx xx 电压值放大 100 倍 如返回24.5V  FE 2A 92 09  xx xx 低位在前高位在后)
                if (null != byteResult && byteResult.size >= 4) {
                    val low = byteResult[2].toInt() and 0xFF
                    val high = byteResult[3].toInt() and 0xFF
                    val result = high shl 8 or low //先将高位左移，在与低位相与
                    val value = result / 100.00
                    val decimalFormat = DecimalFormat(".00")//构造方法的字符格式这里如果小数不足2位,会以0补足.
                    Log.i(TAG, "onReceive() 电压:${decimalFormat.format(value)}V")
                } else {
                    Log.i(TAG, "onReceive() 电压:未知")
                }
            }
            stringState.indexOf("FEAA") != -1 -> {
                // 纸张数：FE AA 01 00 (十六进制，低位在前，高位在后)
                // 标签模式下连续打印，自动返回打印纸张的第几张数值
                if (null != byteResult && byteResult.size >= 4) {
                    val low = byteResult[2].toInt() and 0xFF
                    val high = byteResult[3].toInt() and 0xFF
                    val result = high shl 8 or low //先将高位左移，在与低位相与

                    Log.i(TAG, "onReceive() 打印张数:${result}")

                    //返回了，size
                    if (byteResult.size == 7) {
                        val intentResult = Intent()
                        val bytes = ByteArray(3)
                        System.arraycopy(byteResult, 4, bytes, 0, bytes.size)
                        intentResult.action = ACTION_PRINTER_STATE
                        intentResult.putExtra(ACTION_PRINTER_STATE, bytes)
                        this.onReceive(context, intentResult)
                    }
                } else {
                    Log.i(TAG, "onReceive() 打印张数:-")
                }
            }
            UsbManager.ACTION_USB_DEVICE_DETACHED == intent?.action -> {
                // 有设备拔出了
                Log.i(TAG, "onReceive() PrinterStateReceiver检测到：usb拔出")
            }
        }
    }

    /**
     * Convert byte[] to hex string.将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
     * @param src byte[] data
     * @return hex string （大写）
     * */
    private fun bytesToHexString(src: ByteArray?): String? {
        if (null == src || src.isEmpty()) return null

        val stringBuilder = StringBuilder()

        for (i in src.indices) {
            val v: Int = src[i].toInt() and 0xFF
            val hv = Integer.toHexString(v).toUpperCase(Locale.getDefault())
            if (hv.length < 2) {
                stringBuilder.append(0)
            }
            stringBuilder.append(hv)
        }
        return stringBuilder.toString()
    }

    /**
     * Convert char to byte
     * @param c char
     * @return byte
     */
    private fun charToByte(c: Char): Byte {
        return "0123456789ABCDEF".indexOf(c).toByte()
    }

    /**
     * Convert hex string to byte[]
     * @param hexString the hex string
     * @return byte[]
     */
    private fun hexStringToBytes(hexString: String?): ByteArray? {
        if (hexString.isNullOrEmpty()) return null

        val tempHexString = hexString.toUpperCase(Locale.getDefault())
        val length = hexString.length / 2
        val hexChars = tempHexString.toCharArray()
        val byteArray = ByteArray(length)

        for (i in 0 until length) {
            val pos = i * 2
            byteArray[i] =
                (charToByte(hexChars[pos]).toInt() shl 4 or charToByte(hexChars[pos + 1]).toInt()).toByte()
        }

        return byteArray
    }

}