using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;

namespace HardWareInteface.Common
{
    /// <summary>
    /// 车辆道闸帮助类
    /// </summary>
    public class CarBarrierGateHelp
    {

        /// <summary>
        /// 车辆开门返回信息
        /// </summary>
        /// <param name="carNum"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string GetOpenCarControlStr(string carNum, string msg)
        {
            try
            {
                var showStr = GetCarOperateStr(EnumCarOperateType.下发临显, msg).ToUpper();
                var carStr = GetCarOperateStr(EnumCarOperateType.下发语音, carNum).ToUpper();
                string retStr = "{\"error_num\":0,\"error_str\":\"noerror\",\"gpio_data\":[{\"ionum\":\"io1\",\"action\":\"on\"}]," +
                    "\"rs485_data\":[" +
                    "{\"encodetype\":\"hex2string\",\"data\":\"" + showStr + "\"}" +
                    ",{\"encodetype\":\"hex2string\",\"data\":\"" + carStr + "\"}" +
                    "]}";

                string str = "车辆开门：" + carNum + "    提示信息：" + msg + "   返回字符串：" + retStr;
                FangYar.Common.MyLogHelper.WriteMsg(new FangYar.Common.LogInfoMo()
                {
                    message = str,
                    msgType = FangYar.Common.EnumLogMsgTypeEnum.Info,
                    path = "CarControlLog"
                });

                return retStr;
            }
            catch (Exception ex)
            {
                string str = "回去开门字符串异常：" + ex;
                FangYar.Common.MyLogHelper.WriteMsg(new FangYar.Common.LogInfoMo()
                {
                    message = str,
                    msgType = FangYar.Common.EnumLogMsgTypeEnum.Error,
                    path = "CarControlLog"
                });

                //异常情况下，直接返回开门，并显示祝您一路平安
                return "{\"error_num\":0,\"error_str\":\"noerror\",\"gpio_data\":[{\"ionum\":\"io1\",\"action\":\"on\"}]," +
                "\"rs485_data\":[{\"encodetype\":\"hex2string\",\"data\":\"AA551F640027001001050300D7A3C4FAD2BBC2B7C6BDB0B25D1DAF\"}]}";
            }

        }

        /// <summary>
        /// 车辆未授权返回信息
        /// </summary>
        /// <param name="carNum"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string GetCloseCarControlStr(string carNum, string msg)
        {
            try
            {
                var showStr = GetCarOperateStr(EnumCarOperateType.下发临显, msg).ToUpper();
                string retStr = "{\"error_num\":0,\"error_str\":\"noerror\",\"gpio_data\":[{\"action\":\"off\"}]," +
                "\"rs485_data\":[{\"encodetype\":\"hex2string\",\"data\":\"" + showStr + "\"}]}";

                string str = "车辆未授权：" + carNum + "    提示信息：" + msg + "   返回字符串：" + retStr;
                FangYar.Common.MyLogHelper.WriteMsg(new FangYar.Common.LogInfoMo()
                {
                    message = str,
                    msgType = FangYar.Common.EnumLogMsgTypeEnum.Info,
                    path = "CarControlLog"
                });

                return retStr;
            }
            catch (Exception ex)
            {
                string str = "车牌未授权返回信息异常：" + ex;
                FangYar.Common.MyLogHelper.WriteMsg(new FangYar.Common.LogInfoMo()
                {
                    message = str,
                    msgType = FangYar.Common.EnumLogMsgTypeEnum.Error,
                    path = "CarControlLog"
                });

                //异常情况下，直接返回开门，并显示祝您一路平安
                return "{\"error_num\":0,\"error_str\":\"noerror\",\"gpio_data\":[{\"ionum\":\"io1\",\"action\":\"on\"}]," +
                "\"rs485_data\":[{\"encodetype\":\"hex2string\",\"data\":\"AA551F640027001001050300D7A3C4FAD2BBC2B7C6BDB0B25D1DAF\"}]}";
            }
        }

        public static string GetCarOperateStr(EnumCarOperateType carOperateType, string valStr = "")
        {
            //返回命令字符串（默认返回取消第一行临时显示）
            string retStr = "AA551F6400";
            //命令字符串加密字符串
            string CRC16Str = "1F6400";

            switch (carOperateType)
            {
                case EnumCarOperateType.取消临显:
                    //retStr += "2100010196D7AF";
                    //添加命令信息
                    retStr += "21";
                    CRC16Str += "21";
                    //添加长度信息
                    retStr += "0001";
                    CRC16Str += "0001";
                    //添加行数信息
                    retStr += "01";
                    CRC16Str += "01";
                    break;
                case EnumCarOperateType.下发语音:
                    //添加命令信息
                    retStr += "22";
                    CRC16Str += "22";
                    //加密串
                    var pwdStr = StringToHexString(valStr);
                    ////添加长度信息
                    retStr += GetStrLength(pwdStr.Length / 2 + 1);
                    CRC16Str += GetStrLength(pwdStr.Length / 2 + 1);
                    //retStr += "0009";
                    //CRC16Str += "0009";
                    //添加内容信息
                    retStr += pwdStr + "01";
                    CRC16Str += pwdStr + "01";
                    break;
                case EnumCarOperateType.下发临显:
                    //添加命令信息
                    retStr += "27";
                    CRC16Str += "27";
                    //添加长度信息
                    retStr += GetStrLengthShow(valStr);
                    CRC16Str += GetStrLengthShow(valStr);
                    //添加控制字 1：定义下发内容显示的行号，行号示意及说明如下图信息
                    retStr += "01";
                    CRC16Str += "01";
                    //添加控制字 2：定义该临显内容显示的时长，单位 秒，该参数为 0 时，表示长期显示信息
                    retStr += "35";
                    CRC16Str += "35";
                    //添加控制字 3：定义临显的显示颜色，1-3 有效，1=红色，2=绿色，3=黄色，其他默认为 1信息
                    retStr += "03";
                    CRC16Str += "03";
                    //添加控制字 4：行号为 6 和 7 的时候，生效。用于控制关键数字的颜色信息
                    retStr += "00";
                    CRC16Str += "00";
                    //添加内容信息
                    retStr += StringToHexString(valStr);
                    CRC16Str += StringToHexString(valStr);
                    break;
                case EnumCarOperateType.设置音量:
                    //添加命令信息
                    retStr += "F0";
                    CRC16Str += "F0";
                    //添加长度信息
                    retStr += "0001";
                    CRC16Str += "0001";
                    break;
            }
            //CRC16Str += "X1X2";
            //添加校验码
            retStr += GetCrc16Modbus(CRC16Str);
            //添加结束字符
            retStr += "AF";
            return retStr;
        }

        /// <summary>
        /// 返回字符串长度
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string GetStrLength(int str)
        {
            var strLength = str;
            if (strLength < 10)
            {
                return "000" + strLength;
            }
            else if (strLength < 100)
            {
                return "00" + strLength;
            }
            else if (strLength < 1000)
            {
                return "0" + strLength;
            }
            else if (strLength < 10000)
            {
                return "" + strLength;
            }
            else
            {
                return "9999";
            }
        }


        /// <summary>
        /// 返回临时显示字符串长度
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string GetStrLengthShow(string str)
        {
            str = GetMaxStr(str);
            str = "aaaa" + str;
            if (str.Length < 10)
            {
                return "000" + str.Length;
            }
            else if (str.Length < 100)
            {
                return "00" + str.Length;
            }
            else if (str.Length < 1000)
            {
                return "0" + str.Length;
            }
            else if (str.Length < 10000)
            {
                return "" + str.Length;
            }
            else
            {
                return "9999";
            }
        }

        /// <summary>
        /// 返回最大字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string GetMaxStr(string str)
        {
            if (string.IsNullOrWhiteSpace(str))
            {
                return "";
            }
            else if (str.Length > 9999)
            {
                str = str.Substring(0, 9998);
            }
            return str;
        }

        /// <summary>
        /// 16进制字符转字符串
        /// </summary>
        /// <param name="hex">16进制字符</param>
        /// <param name="encode">编码格式</param>
        /// <returns></returns>
        private static string HexStringToString(string hex)
        {
            Encoding encode = Encoding.Default;
            byte[] buffer = new byte[hex.Length / 2];
            string result = string.Empty;
            for (int i = 0; i < hex.Length / 2; i++)
            {
                result = hex.Substring(i * 2, 2);
                buffer[i] = Convert.ToByte(result, 16);
            }
            //返回指定编码格式的字符串
            return encode.GetString(buffer);
        }
        /// <summary>
        /// 将字符串转为16进制字符，允许中文
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        private static string StringToHexString(string s)
        {
            Encoding encode = Encoding.Default;
            byte[] b = encode.GetBytes(s);//按照指定编码将string编程字节数组
            string result = string.Empty;
            for (int i = 0; i < b.Length; i++)//逐字节变为16进制字符
            {
                result += Convert.ToString(b[i], 16);
            }
            return result;
        }


        #region  CRC校验


        #endregion


        private static string GetCrc16Modbus(string hexString)
        {
            var arr = ByteStringConvertByteAyy(hexString);
            var crcStr = CRC16(arr);
            var retStr = ByteToHexStr(crcStr);
            return retStr;
        }


        private static byte[] ByteStringConvertByteAyy(string hex)
        {
            byte[] buffer = new byte[hex.Length / 2 + 2];
            string result = string.Empty;
            for (int i = 0; i < hex.Length / 2; i++)
            {
                result = hex.Substring(i * 2, 2);
                buffer[i] = Convert.ToByte(result, 16);
            }
            //返回指定编码格式的字符串
            return buffer;
        }


        /// <summary>
        /// CRC校验，参数data为byte数组
        /// </summary>
        /// <param name="data">校验数据，字节数组</param>
        /// <returns>字节0是高8位，字节1是低8位</returns>
        public static byte[] CRC16(byte[] data)
        {
            //crc计算赋初始值
            int crc = 0xffff;
            for (int i = 0; i < data.Length; i++)
            {
                crc = crc ^ data[i];
                for (int j = 0; j < 8; j++)
                {
                    int temp;
                    temp = crc & 1;
                    crc = crc >> 1;
                    crc = crc & 0x7fff;
                    if (temp == 1)
                    {
                        crc = crc ^ 0xa001;
                    }
                    crc = crc & 0xffff;
                }
            }
            //CRC寄存器的高低位进行互换
            byte[] crc16 = new byte[2];
            //CRC寄存器的高8位变成低8位，
            crc16[0] = (byte)((crc >> 8) & 0xff);
            //CRC寄存器的低8位变成高8位
            crc16[1] = (byte)(crc & 0xff);
            return crc16;
        }
        /// <summary>
        /// byte[]转为16进制字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string ByteToHexStr(byte[] bytes)
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < bytes.Length; i++)
                {
                    returnStr += bytes[i].ToString("X2");
                }
            }
            return returnStr;
        }

    }

    public enum EnumCarOperateType
    {

        设置音量 = 0xF0,
        取消临显 = 21,
        下发语音 = 22,
        下发临显 = 27
    }
}