using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;

namespace Bro.Common.Helper
{
    public static class StaticHelper
    {
        /// <summary>
        /// 数值转换为byte数组 高位在前，低位在后
        /// </summary>
        /// <param name="number"></param>
        /// <param name="size"></param>
        /// <returns></returns>
        public static byte[] IntToBytes(this int number, int size = 2)
        {
            byte[] result = new byte[size];

            int temp = size;
            while (temp > 0)
            {
                result[size - temp] = (byte)(number >> ((temp - 1) * 8) & 0xff);

                temp--;
            }

            return result;
        }

        /// <summary>
        /// 字节数组转换为整数
        /// </summary>
        /// <param name="data">字节数组</param>
        /// <param name="HtL">true:数组序号低的在高位 false：数组序号低的在低位</param>
        /// <returns></returns>
        public static int BytesToInt(this byte[] data, bool HtL = true)
        {
            int res = 0;

            for (int i = 0; i < data.Length; i++)
            {
                int index = i;

                if (HtL)
                {
                    index = data.Length - 1 - i;
                }

                res += data[index] << (8 * i);
            }

            return res;
        }

        /// <summary>
        /// 将32位整形拆分为无符号16位整形
        /// </summary>
        /// <param name="num">需要拆分的32位整形</param>
        /// <param name="bitNum">拆分为16位整形的位数 1或者2</param>
        /// <param name="HtL">true：高位在前，低位在后；false：高位在后，低位在前</param>
        /// <returns></returns>
        public static List<ushort> ParseIntToUnsignShortList(this int num, int bitNum = 2, bool HtL = false)
        {
            if (bitNum == 2)
            {
                ushort high = (ushort)(num >> 16);
                ushort low = (ushort)num;

                if (HtL)
                {
                    return new List<ushort>() { high, low };
                }
                else
                {
                    return new List<ushort>() { low, high };
                }
            }
            else
            {
                if (num < 0)
                {
                    num = ushort.MaxValue + 1 + num;
                }

                return new List<ushort>() { (ushort)num };
            }
        }

        /// <summary>
        /// 将32位整形数组拆分为无符号16位整形数组
        /// </summary>
        /// <param name="list">需要拆分的32位整形</param>
        /// <param name="bitNum">拆分为16位整形的位数 1或者2</param>
        /// <param name="HtL">true：高位在前，低位在后；false：高位在后，低位在前</param>
        /// <returns></returns>
        public static List<ushort> ParseIntToUnsignShortList(this List<int> list, int bitNum = 2, bool HtL = false)
        {
            return list.SelectMany(u => u.ParseIntToUnsignShortList(bitNum, HtL)).ToList();
        }

        /// <summary>
        /// 将ushort的集合转换为16位带符号整形
        /// </summary>
        /// <param name="numList"></param>
        /// <param name="bitNum">合并的位数 1或者2</param>
        /// <param name="HtL">true：高位在前，低位在后；false：高位在后，低位在前</param>
        /// <returns></returns>
        public static List<int> ParseUnsignShortListToInt(this List<int> numList, int bitNum = 2, bool HtL = false)
        {
            if (bitNum == 1)
            {
                return numList.ConvertAll(n =>
                {
                    int num = n;
                    if (num > short.MaxValue)
                    {
                        num = num - ushort.MaxValue - 1;
                    }

                    return num;
                });
            }
            else
            {
                List<int> list = new List<int>();
                for (int i = 0; i < numList.Count; i += 2)
                {
                    int high = HtL ? numList[i] : numList[i + 1];
                    int low = HtL ? numList[i + 1] : numList[i];
                    list.Add((high << 16) | low);
                }

                return list;
            }
        }

        public static string GetExceptionMessage(this Exception ex)
        {
            string msg = "异常信息：" + ex.Message;
            if (ex.InnerException != null)
            {
                msg += "；\r\n内部异常信息：" + ex.InnerException.GetExceptionMessage();
            }

            msg += ("；\r\nStackTrace:" + ex.StackTrace);

            return msg;
        }

        public static T DeepSerializeClone<T>(this T t) 
        {
            return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(t));
        }

        public static void DataFrom<T1, T2>(this T1 destT, T2 sourceT, List<string> exceptionProps = null) where T1 : class where T2 : class
        {
            if (sourceT == null)
            {
                destT = null;
                return;
            }

            PropertyInfo[] propDest = destT.GetType().GetProperties();//.Where(p => !(p.GetMethod.IsVirtual && !p.GetMethod.IsFinal)).ToArray();
            PropertyInfo[] propSource = sourceT.GetType().GetProperties();

            Array.ForEach(propDest, prop =>
            {
                if (exceptionProps == null || !exceptionProps.Contains(prop.Name))
                {
                    if (prop.CanWrite)
                    {
                        PropertyInfo propS = propSource.FirstOrDefault(p => p.Name == prop.Name);
                        if (propS != null && propS.CanRead)
                        {
                            prop.SetValue(destT, propS.GetValue(sourceT));
                        }
                    }
                }
            });
        }

        public static Bitmap BitmapSerializeCopy(this Bitmap map)
        {
            Bitmap image = null;
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(ms, map);
                ms.Seek(0, SeekOrigin.Begin);
                image = (Bitmap)bf.Deserialize(ms);

                //ms.Close();
            }

            return image;

            //Bitmap image = new Bitmap(map.Width, map.Height);

            //int bitdepth_per_pixel = Bitmap.GetPixelFormatSize(map.PixelFormat) / 8;
            //BitmapData source_bitmapdata = null;
            //BitmapData destination_bitmapdata = null;

            //try
            //{
            //    source_bitmapdata = map.LockBits(new Rectangle(0, 0, map.Width, map.Height), ImageLockMode.ReadWrite, map.PixelFormat);
            //    destination_bitmapdata = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite, image.PixelFormat);

            //    int source_bitmapdata_bitdepth_width = source_bitmapdata.Width * bitdepth_per_pixel;
            //    int source_bitmapdata_height = source_bitmapdata.Height;
            //    int source_bitmapdata_bitdepth_stride = source_bitmapdata.Stride;

            //    unsafe
            //    {
            //        byte* source_ptr = (byte*)source_bitmapdata.Scan0;
            //        byte* destination_ptr = (byte*)destination_bitmapdata.Scan0;

            //        int offset = source_bitmapdata_bitdepth_stride - source_bitmapdata_bitdepth_width;

            //        for (int i = 0; i < source_bitmapdata_height; i++)
            //        {
            //            for (int j = 0; j < source_bitmapdata_bitdepth_width; j++, source_ptr++, destination_ptr++)
            //            {
            //                *destination_ptr = *source_ptr;
            //            }

            //            source_ptr += offset;
            //            destination_ptr += offset;
            //        }
            //    }

            //    map.UnlockBits(source_bitmapdata);
            //    image.UnlockBits(destination_bitmapdata);
            //}
            //catch { }

            //return image;
        }

        public static void Sort<T>(this ObservableCollection<T> collection) where T : IComparable<T>
        {
            List<T> sortedList = collection.OrderByDescending(x => x).ToList();//这里用降序 
            for (int i = 0; i < sortedList.Count(); i++)
            {
                collection.Move(collection.IndexOf(sortedList[i]), i);
            }
        }
    }
}