using System;
using System.Runtime.InteropServices;
using System.Text;

namespace SlnMesnac.RfidUpload.Common
{
    /// <summary>
    /// 工具类
    /// </summary>
    public sealed class MsgUtil
    {

        private static readonly Lazy<MsgUtil> lazy = new Lazy<MsgUtil>(() => new MsgUtil());

        public static MsgUtil Instance
        {
            get
            {
                return lazy.Value;
            }
        }

        private MsgUtil() { }

        #region 数据解析公共方法
        /// <summary>
        /// 字节数组转换成结构体
        /// </summary>
        /// <param name="buf"></param>
        /// <param name="len"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static object BytesToStruct(byte[] buf, int len, Type type)
        {
            object rtn;
            IntPtr buffer = Marshal.AllocHGlobal(len);
            Marshal.Copy(buf, 0, buffer, len);
            try
            {
                rtn = Marshal.PtrToStructure(buffer, type);
                Marshal.FreeHGlobal(buffer);
            }
            catch (Exception)
            {
                return null;
            }
            return rtn;
        }

        public string StringToHexString(string s, Encoding encode)
        {

            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;
        }

        //// <summary>
        /// 结构体转byte数组
        /// </summary>
        /// <param name="structObj">要转换的结构体</param>
        /// <returns>转换后的byte数组</returns>
        public static byte[] StructToBytes(object structObj)
        {
            //得到结构体的大小
            int size = Marshal.SizeOf(structObj);
            //创建byte数组
            byte[] bytes = new byte[size];
            //分配结构体大小的内存空间
            IntPtr structPtr = Marshal.AllocHGlobal(size);
            //将结构体拷到分配好的内存空间
            Marshal.StructureToPtr(structObj, structPtr, false);
            //从内存空间拷到byte数组
            Marshal.Copy(structPtr, bytes, 0, size);
            //释放内存空间
            Marshal.FreeHGlobal(structPtr);
            //返回byte数组
            return bytes;
        }


        #endregion
        #region 消息验证方法

        /// <summary>
        /// CS和校验
        /// </summary>
        /// <param name="Abyte"></param>
        /// <returns></returns>
        public byte Check_CS(byte[] Abyte)
        {
            byte result = new byte();
            try
            {
                int num = 0;
                for (int i = 0; i < Abyte.Length; i++)
                {
                    num = (num + Abyte[i]) % 256;
                }
                result = (byte)num;
            }
            catch
            {
                result = 0;
            }
            return result;
        }

        /// <summary>
        /// BCC异或取反校验
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public string getBCC(byte[] data)
        {
            String ret = "";
            byte[] BCC = new byte[1];
            for (int i = 0; i < data.Length; i++)
            {
                BCC[0] = (byte)(BCC[0] ^ data[i]);
            }
            String hex = ((~BCC[0]) & 0xFF).ToString("X");//取反操作
            if (hex.Length == 1)
            {
                hex = '0' + hex;
            }
            ret += hex.ToUpper();
            return ret;
        }

        static int BytesToInt(byte[] b, int length)
        {
            int temp = 0;
            for (int i = 0; i <= length - 1 && i < 4; i++)
            {
                temp += (int)(b[i] << (i * 8));
            }
            return temp;
        }

        public static byte[] CalculateVerify(byte[] pMessage, int iLength)
        {
            UInt16 i;
            int iVerify = 0;

            iVerify = pMessage[0];
            for (i = 0; i < iLength - 1; i++)
            {
                iVerify = iVerify + pMessage[i + 1];
            }
            return BitConverter.GetBytes(Convert.ToUInt16(iVerify));
        }
        #endregion
        public byte[] HexStrTorbytes(string strHex)//e.g. " 01 01" ---> { 0x01, 0x01}
        {
            strHex = strHex.Replace(" ", "");
            if ((strHex.Length % 2) != 0)
                strHex += " ";
            byte[] returnBytes = new byte[strHex.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(strHex.Substring(i * 2, 2), 16);
            return returnBytes;
        }

        /// <summary>
        /// 将字符串强制转换成int，转换失败则返回0
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public int ParseToInt(string str)
        {
            int returnInt = 0;

            if (str == null || str.Trim().Length < 1)
            {
                return returnInt;
            }

            if (int.TryParse(str, out returnInt))
            {
                return returnInt;
            }
            else
            {
                return 0;
            }
        }

        public byte[] HexToString(string Str)
        {
            byte[] str = new byte[Str.Length / 2];
            for (int i = 0; i < str.Length; i++)
            {
                int temp = Convert.ToInt32(Str.Substring(i * 2, 2), 16);
                str[i] = (byte)temp;
            }
            return str;
        }
        public string ConverToString(byte[] data)
        {
            string str;
            StringBuilder stb = new StringBuilder();
            for (int i = 0; i < data.Length; i++)
            {
                if ((int)data[i] > 15)
                {
                    stb.Append(Convert.ToString(data[i], 16).ToUpper()); //添加字符串
                }
                else  //如果是小于0F需要加个零
                {
                    stb.Append("0" + Convert.ToString(data[i], 16).ToUpper());
                }
            }
            str = stb.ToString();
            return str;
        }

        public string bytesToHexStr(byte[] bytes, int iLen)
        {
            StringBuilder sb = new StringBuilder();
            if (bytes != null)
            {
                for (int i = 0; i < iLen; i++)
                {
                    sb.Append(bytes[i].ToString("X2"));
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// 从十进制转换到十六进制
        /// </summary>
        /// <param name="ten"></param>
        /// <returns></returns>
        public string Ten2Hex(string ten)
        {
            ulong tenValue = Convert.ToUInt64(ten);
            ulong divValue, resValue;
            string hex = "";
            do
            {
                //divValue = (ulong)Math.Floor(tenValue / 16);

                divValue = (ulong)Math.Floor((decimal)(tenValue / 16));

                resValue = tenValue % 16;
                hex = tenValue2Char(resValue) + hex;
                tenValue = divValue;
            }
            while (tenValue >= 16);
            if (tenValue != 0)
                hex = tenValue2Char(tenValue) + hex;
            return hex;
        }

        /// <summary>
        /// 异或和校验
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public string CalculateXORChecksum(byte[] bytes)
        {
            byte checksum = bytes[0];
            foreach (byte b in bytes)
            {
                checksum ^= b;
            }

            return checksum.ToString("X2");
        }

        public string tenValue2Char(ulong ten)
        {
            switch (ten)
            {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:
                    return ten.ToString();
                case 10:
                    return "A";
                case 11:
                    return "B";
                case 12:
                    return "C";
                case 13:
                    return "D";
                case 14:
                    return "E";
                case 15:
                    return "F";
                default:
                    return "";
            }
        }
    }
}