using System;
using System.Collections.Generic;
using System.Text;

namespace Mesnac.DeviceAdapter.HWKC_81600
{
    public static class StringChange
    {
        //public StringChange()
        //{
        //}

        public static byte[] Swap16Bytes(byte[] OldU16)
        {
            byte[] ReturnBytes = new byte[2];
            ReturnBytes[1] = OldU16[0];
            ReturnBytes[0] = OldU16[1];
            return ReturnBytes;
        }

        public static bool CompareBytes(byte[] byteA, byte[] byteB, int iLen)
        {
            for (int i = 0; i < iLen; i++)
            {
                if (byteA[i] != byteB[i])
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// 将byte数组转换成十六进制字符串 //e.g. { 0x01, 0x01} ---> " 01 01"
        /// </summary>
        /// <param name="bytes">byte数组</param>
        /// <param name="iLen">数组长度</param>
        /// <returns>十六进制字符串</returns>
        public static string bytesToHexStr(byte[] bytes, int iLen)
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < iLen; i++)
                {
                    returnStr += bytes[i].ToString("X2");
                }
            }
            return returnStr;
        }

        public static 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;
        }
        public static 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;
        }
        public static string HexStringToString(string hs, Encoding encode)
        {
            //以%分割字符串，并去掉空字符
            string[] chars = hs.Split(new char[] { '%' }, StringSplitOptions.RemoveEmptyEntries);
            byte[] b = new byte[chars.Length];
            //逐个字符变为16进制字节数据
            for (int i = 0; i < chars.Length; i++)
            {
                b[i] = Convert.ToByte(chars[i], 16);
            }
            //按照指定编码将字节数组变为字符串
            return encode.GetString(b);
        }

        public static short SwapInt16(this short n)
        {
            return (short)(((n & 0xff) << 8) | ((n >> 8) & 0xff));
        }

        public static ushort SwapUInt16(this ushort n)
        {
            return (ushort)(((n & 0xff) << 8) | ((n >> 8) & 0xff));
        }

        public static int SwapInt32(this int n)
        {
            return (int)(((SwapInt16((short)n) & 0xffff) << 0x10) |
                          (SwapInt16((short)(n >> 0x10)) & 0xffff));
        }

        public static uint SwapUInt32(this uint n)
        {
            return (uint)(((SwapUInt16((ushort)n) & 0xffff) << 0x10) |
                           (SwapUInt16((ushort)(n >> 0x10)) & 0xffff));
        }

        public static long SwapInt64(this long n)
        {
            return (long)(((SwapInt32((int)n) & 0xffffffffL) << 0x20) |
                           (SwapInt32((int)(n >> 0x20)) & 0xffffffffL));
        }

        public static ulong SwapUInt64(this ulong n)
        {
            return (ulong)(((SwapUInt32((uint)n) & 0xffffffffL) << 0x20) |
                            (SwapUInt32((uint)(n >> 0x20)) & 0xffffffffL));
        }
        public static byte CalculateVerify(byte[] pMessage, int iLength)
        {
            UInt16 i;
            byte iVerify = 0;

            iVerify = pMessage[0];
            for (i = 1; i < iLength; i++)
            {
                iVerify = (byte)(iVerify ^ pMessage[i]);
            }
            return iVerify;
        }
        /// <summary>
        /// CRC16_Modbus效验
        /// </summary>
        /// <param name="byteData">要进行计算的字节数组</param>
        /// <param name="byteLength">长度</param>
        /// <returns>计算后的数组</returns>
        public static byte[] ToModbus(byte[] byteData, int byteLength)
        {
            byte[] CRC = new byte[2];

            UInt16 wCrc = 0xFFFF;
            for (int i = 0; i < byteLength; i++)
            {
                wCrc ^= Convert.ToUInt16(byteData[i]);
                for (int j = 0; j < 8; j++)
                {
                    if ((wCrc & 0x0001) == 1)
                    {
                        wCrc >>= 1;
                        wCrc ^= 0xA001;//异或多项式
                    }
                    else
                    {
                        wCrc >>= 1;
                    }
                }
            }

            CRC[1] = (byte)((wCrc & 0xFF00) >> 8);//高位在后
            CRC[0] = (byte)(wCrc & 0x00FF);       //低位在前
            return CRC;

        }
        public static string ArrayReverse(string text)
        {
            char[] charArray = text.ToCharArray();
            Array.Reverse(charArray);

            return new string(charArray);
        }
        public class IOInfo
        {
            public int id;
            public byte[] state;
            public DateTime time;
        }
        public class MethodFilterData
        {
            private static List<IOInfo> IOInfolist = new List<IOInfo>();
            /// <summary>
            /// 消除抖动，删除短暂时间内的
            /// </summary>
            /// <returns></returns>
            public static bool EliminatingJitter(int id, byte[] data)
            {
                var index = IOInfolist.FindIndex((x) => { return x.id == id; });
                if (index == -1 || IOInfolist[index].state != data)
                {
                    IOInfolist.Add(new IOInfo
                    {
                        id = id,
                        state = data,
                        time = DateTime.Now
                    });
                }
                else
                {
                    TimeSpan ts1 = new TimeSpan(IOInfolist[index].time.Ticks);
                    TimeSpan ts2 = new TimeSpan(DateTime.Now.Ticks);
                    TimeSpan ts3 = ts2.Subtract(ts1); //ts2-ts1
                    double sumSeconds = Convert.ToDouble(ts3.TotalSeconds.ToString()); //得到相差秒数
                    //LogInfo.Warn("方法：IsRepeat，据上次自报00数据时间差：" + sumSeconds);
                    if (sumSeconds < 5)
                    {
                        return true;
                    }
                    else
                    {
                        IOInfolist[index] = new IOInfo
                        {
                            id = id,
                            state = data,
                            time = DateTime.Now
                        };
                    }
                }
                return false;
            }
        }
    }
}
