using Microsoft.CSharp.RuntimeBinder;
//using Newtonsoft.Json;
using System.Collections.ObjectModel;
using System.Drawing.Imaging;
using System.Dynamic;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;

    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>
        /// 获取一个类指定的属性值
        /// </summary>
        /// <param name="info">object对象</param>
        /// <param name="field">属性名称</param>
        /// <returns></returns>
        public static object GetPropertyValue(object info, string field)
        {
            if (info == null) return null;
            Type t = info.GetType();
            IEnumerable<System.Reflection.PropertyInfo> property = from pi in t.GetProperties() where pi.Name.ToLower() == field.ToLower() select pi;
            return property.First().GetValue(info, null);
        }

        /// <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 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();
#if NET7_0_OR_GREATER
#pragma warning disable SYSLIB0011
#endif
                bf.Serialize(ms, map);
                ms.Seek(0, SeekOrigin.Begin);
                image = (Bitmap)bf.Deserialize(ms);
#if NET7_0_OR_GREATER
#pragma warning restore SYSLIB0011
#endif
                //ms.Close();
            }

            return image;
        }

        public static Bitmap DeepClone(this Bitmap bitmap)
        {
            Bitmap dstBitmap = null;
            using (MemoryStream mStream = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
#if NET7_0_OR_GREATER
#pragma warning disable SYSLIB0011
#endif
                bf.Serialize(mStream, bitmap);
                //#pragma warning restore SYSLIB0011
                mStream.Seek(0, SeekOrigin.Begin);
                dstBitmap = (Bitmap)bf.Deserialize(mStream);
                mStream.Close();
#if NET7_0_OR_GREATER
#pragma warning restore SYSLIB0011
#endif
            }
            return dstBitmap;
        }
        //RtlMoveMemory
        [DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory", SetLastError = false)]
        public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);
        [HandleProcessCorruptedStateExceptions]
        public static Bitmap CopyBitmap(this Bitmap source)
        {
            Bitmap clone = new Bitmap(source.Width, source.Height, source.PixelFormat);
            try
            {
                int PixelSize = Bitmap.GetPixelFormatSize(source.PixelFormat) / 8;
                if (PixelSize == 1)
                {
                    ColorPalette cp = clone.Palette;
                    for (int i = 0; i < 256; i++)
                    {
                        cp.Entries[i] = Color.FromArgb(255, i, i, i);
                    }
                    clone.Palette = cp;
                }

                Rectangle rect = new Rectangle(0, 0, source.Width, source.Height);
                BitmapData sourceData = source.LockBits(rect, ImageLockMode.ReadWrite, source.PixelFormat);
                BitmapData cloneData = clone.LockBits(rect, ImageLockMode.ReadWrite, source.PixelFormat);
                if (source.Width % 4 == 0)
                {
                    unsafe
                    {
                        CopyMemory(cloneData.Scan0, sourceData.Scan0, (uint)(sourceData.Stride * sourceData.Height));
                    }
                }
                else
                {
                    Parallel.For(0, source.Height, h =>
                    {
                        unsafe
                        {
                            CopyMemory(cloneData.Scan0 + h * sourceData.Stride, sourceData.Scan0 + h * sourceData.Stride, (uint)sourceData.Width);
                        }
                    });
                }

                clone.UnlockBits(cloneData);
                source.UnlockBits(sourceData);

            }
            catch (Exception ex)
            {
                return clone;
            }

            return clone;
        }

        public static Bitmap BitmapDeepClone(Bitmap source)
        {
            Bitmap clone = new Bitmap(source.Width, source.Height, source.PixelFormat);

            try
            {
                int PixelSize = Bitmap.GetPixelFormatSize(source.PixelFormat) / 8;
                if (PixelSize == 1)
                {
                    ColorPalette cp = clone.Palette;
                    for (int i = 0; i < 256; i++)
                    {
                        cp.Entries[i] = Color.FromArgb(255, i, i, i);
                    }
                    clone.Palette = cp;
                }
                Rectangle rect = new Rectangle(0, 0, source.Width, source.Height);
                BitmapData source_bitmap = source.LockBits(rect, ImageLockMode.ReadWrite, source.PixelFormat);
                BitmapData destination_bitmap = clone.LockBits(rect, ImageLockMode.ReadWrite, clone.PixelFormat);

                int depth_width = source_bitmap.Width * PixelSize;

                unsafe
                {
                    byte* source_ptr = (byte*)source_bitmap.Scan0;
                    byte* destination_ptr = (byte*)destination_bitmap.Scan0;

                    int offset = source_bitmap.Stride - depth_width;

                    for (int i = 0; i < source_bitmap.Height; i++)
                    {
                        for (int j = 0; j < depth_width; j++, source_ptr++, destination_ptr++)
                        {
                            *destination_ptr = *source_ptr;
                        }

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

                source.UnlockBits(source_bitmap);
                clone.UnlockBits(destination_bitmap);
            }
            catch (Exception ex)
            {

            }
            return clone;
        }



        public static Bitmap HConnectBitmap(this Bitmap map1, Bitmap map2)
        {
            Bitmap connectImage = null;
            if (map1 == null || map2 == null)
                return null;
            //横向拼接
            int width = map1.Width + map2.Width;
            //高度不变
            int height = Math.Max(map1.Height, map2.Height);
            connectImage = new Bitmap(width, height);
            using (Graphics graph = Graphics.FromImage(connectImage))
            {
                graph.DrawImage(connectImage, width, height);
                graph.Clear(System.Drawing.Color.White);
                graph.DrawImage(map1, 0, 0);
                graph.DrawImage(map2, map1.Width, 0);
            }
            return connectImage;
        }

        public static IntPtr FloatToIntptr(float[] bytes)
        {
            GCHandle hObject = GCHandle.Alloc(bytes, GCHandleType.Pinned);
            return hObject.AddrOfPinnedObject();
        }

        // 将Btimap类转换为byte[]类函数
        public static byte[] GetBGRValues(Bitmap bmp, out int stride)
        {
            var rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
            var bmpData = bmp.LockBits(rect, ImageLockMode.ReadOnly, bmp.PixelFormat);
            stride = bmpData.Stride;
            var rowBytes = bmpData.Width * Image.GetPixelFormatSize(bmp.PixelFormat) / 8;
            var imgBytes = bmp.Height * rowBytes;
            byte[] rgbValues = new byte[imgBytes];
            IntPtr ptr = bmpData.Scan0;
            for (var i = 0; i < bmp.Height; i++)
            {
                Marshal.Copy(ptr, rgbValues, i * rowBytes, rowBytes);
                ptr += bmpData.Stride;
            }
            bmp.UnlockBits(bmpData);
            return rgbValues;
        }
        /// <summary>
        /// 缺陷灰度图转彩色图像函数
        /// </summary>
        /// <param name="src">灰度图</param>
        /// <returns>返回构造的伪彩色图像</returns>
        public static Bitmap GrayMapToColorMap(this Bitmap src, Dictionary<int, Color> indexColorDict = null)
        {
            try
            {
                //Stopwatch sw = new Stopwatch();
                //sw.Start();

                Bitmap dest = new Bitmap(src.Width, src.Height, PixelFormat.Format32bppArgb);

                int destHeight = dest.Height;
                int destWidth = dest.Width;

                Rectangle rect = new Rectangle(0, 0, destWidth, destHeight);
                BitmapData bmpDataDest = dest.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
                BitmapData bmpDataSrc = src.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);
                int strideDest = bmpDataDest.Stride;

                int strideSrc = bmpDataSrc.Stride;
                unsafe
                {
                    byte* pDest = (byte*)bmpDataDest.Scan0.ToPointer();
                    byte* pSrc = (byte*)bmpDataSrc.Scan0.ToPointer();

                    Parallel.For(0, destHeight, y =>
                    {
                        Parallel.For(0, destWidth, x =>
                        {
                            int pixel = pSrc[y * strideSrc + x];
                            int startIndex = y * strideDest + x * 4;
                            if (pixel >= 0 && pixel <= 63)
                            {
                                Color color = Color.Red;
                                if (indexColorDict != null && indexColorDict.ContainsKey(pixel))
                                {
                                    color = indexColorDict[pixel];
                                }

                                byte R = color.R;
                                byte G = color.G;
                                byte B = color.B;

                                pDest[startIndex] = B;
                                pDest[startIndex + 1] = G;
                                pDest[startIndex + 2] = R;
                                pDest[startIndex + 3] = 100;
                            }
                            else
                            {
                                pDest[startIndex] = 255;
                                pDest[startIndex + 1] = 255;
                                pDest[startIndex + 2] = 255;
                                pDest[startIndex + 3] = 0;
                            }
                        });
                    });
                }
                dest.UnlockBits(bmpDataDest);
                src.UnlockBits(bmpDataSrc);

                //sw.Stop();
                //Console.WriteLine($"转换耗时：{sw.ElapsedMilliseconds}");

                return dest;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

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

        /// <summary>
        /// 获得字符串中开始和结束字符串中间的值
        /// </summary>
        /// <param name="sourse"></param>
        /// <param name="startstr"></param>
        /// <param name="endstr"></param>
        /// <returns></returns>
        public static string GetMidString(string sourse, string startstr, string endstr)
        {
            string result = string.Empty;
            int startindex, endindex;
            try
            {
                startindex = sourse.IndexOf(startstr);
                if (startindex == -1)
                    return result;
                string tmpstr = sourse.Substring(startindex + startstr.Length);
                endindex = tmpstr.IndexOf(endstr);
                if (endindex == -1)
                    return result;
                result = tmpstr.Remove(endindex);
            }
            catch (Exception ex)
            {
                return "";
            }
            return result;
        }

        /// <summary>
        /// 获得字符串中开始和结束字符串中间的值
        /// </summary>
        /// <param name="t">字符串</param>
        /// <param name="k">开始</param>
        /// <param name="j">结束</param>
        /// <returns></returns> 
        private static string GetMidString2(string sourse, string startstr, string endstr) //截取指定文本，和易语言的取文本中间差不多
        {
            try //异常捕捉
            {
                var kn = sourse.IndexOf(startstr, StringComparison.Ordinal) + startstr.Length;
                var jn = sourse.IndexOf(endstr, kn, StringComparison.Ordinal);
                return sourse.Substring(kn, jn - kn);
            }
            catch //如果发现未知的错误，比如上面的代码出错了，就执行下面这句代码
            {
                return ""; //返回空
            }

        }

        // 布尔类型转换为整型
        public static int ToInt(this object obj)
        {
            if (Convert.ToBoolean(obj) == true)
                return 1;
            else
                return 0;
        }

        // 整型转换为布尔类型
        public static bool ToBool(this object obj)
        {
            if (Convert.ToInt32(obj) == 1)
                return true;
            else
                return false;
        }

        public static object GetProperty(this object o, string member)
        {
            if (o == null) throw new ArgumentNullException("o");
            if (member == null) throw new ArgumentNullException("member");
            Type scope = o.GetType();
            IDynamicMetaObjectProvider provider = o as IDynamicMetaObjectProvider;
            if (provider != null)
            {
                ParameterExpression param = Expression.Parameter(typeof(object));
                DynamicMetaObject mobj = provider.GetMetaObject(param);
                GetMemberBinder binder = (GetMemberBinder)Microsoft.CSharp.RuntimeBinder.Binder.GetMember(0, member, scope, new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(0, null) });
                DynamicMetaObject ret = mobj.BindGetMember(binder);
                BlockExpression final = Expression.Block(
                    Expression.Label(CallSiteBinder.UpdateLabel),
                    ret.Expression
                );
                LambdaExpression lambda = Expression.Lambda(final, param);
                Delegate del = lambda.Compile();
                return del.DynamicInvoke(o);
            }
            else
            {
                return o.GetType().GetProperty(member, BindingFlags.Public | BindingFlags.Instance).GetValue(o, null);
            }
        }

        #region 检测文件状态及操作方式选择
        [DllImport("kernel32.dll")]
        private static extern IntPtr _lopen(string lpPathName, int iReadWrite);
        [DllImport("kernel32.dll")]
        private static extern bool CloseHandle(IntPtr hObject);
        private const int OF_READWRITE = 2;
        private const int OF_SHARE_DENY_NONE = 0x40;
        private static readonly IntPtr HFILE_ERROR = new IntPtr(-1);
        /// <summary>
        /// 检测文件是否只读或被使用
        /// </summary>
        /// <param name="FileNames">要检测的文件</param>
        /// <returns>true可用，false在用或只读</returns>
        public static bool CheckFilesCanUse(string fileName)
        {
            if (!File.Exists(fileName))
                return true;//文件不存在
            if ((File.GetAttributes(fileName) & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                return false;       //文件只读
            IntPtr vHandle = _lopen(fileName, OF_READWRITE | OF_SHARE_DENY_NONE);
            if (vHandle == HFILE_ERROR)
            {
                CloseHandle(vHandle);
                return false;       //文件被占用
            }

            CloseHandle(vHandle);   //文件没被占用
            return true;
        }
        #endregion

        /// <summary>
        /// 获取指定文件夹下所有的文件名称
        /// </summary>
        /// <param name="folderName">指定文件夹名称,绝对路径</param>
        /// <param name="fileFilter">文件类型过滤,根据文件后缀名,如:*,*.txt,*.xls</param>
        /// <param name="isContainSubFolder">是否包含子文件夹</param>
        /// <returns>ArrayList数组,为所有需要的文件路径名称</returns>
        public static List<FileInfo> GetAllFilesByFolder(string folderName, string fileFilter, bool isContainSubFolder = false)
        {
            List<FileInfo> resList = new List<FileInfo>();
            try
            {
                DirectoryInfo currDir = new DirectoryInfo(folderName);//当前目录
                FileInfo[] currFiles = currDir.GetFiles(fileFilter);//当前目录文件
                foreach (FileInfo file in currFiles)
                {
                    if (fileFilter.ToLower().IndexOf(file.Extension.ToLower()) >= 0)
                    {
                        resList.Add(file);
                    }
                }
                if (isContainSubFolder)
                {
                    string[] subFolders = Directory.GetDirectories(folderName);
                    foreach (string subFolder in subFolders)
                    {
                        resList.AddRange(GetAllFilesByFolder(subFolder, fileFilter));//递归   
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return resList;
        }

        /// <summary>
        /// 获取指定文件夹下所有的文件名称,不过滤文件类型
        /// </summary>
        /// <param name="folderName">指定文件夹名称,绝对路径</param>
        /// <param name="isContainSubFolder">是否包含子文件夹</param>
        /// <returns>ArrayList数组,为所有需要的文件路径名称</returns>
        public static List<FileInfo> GetAllFilesByFolder(string folderName, bool isContainSubFolder)
        {
            return GetAllFilesByFolder(folderName, "*", isContainSubFolder);
        }
    }

    public class Compare<T, C> : IEqualityComparer<T>
    {
        private Func<T, C> _getField;
        public Compare(Func<T, C> getfield)
        {
            _getField = getfield;
        }
        public bool Equals(T x, T y)
        {
            return EqualityComparer<C>.Default.Equals(_getField(x), _getField(y));
        }
        public int GetHashCode(T obj)
        {
            return EqualityComparer<C>.Default.GetHashCode(_getField(obj));
        }
    }

    public static class ObjectExtensions
    {
        public static IEnumerable<T> DistinctBy<T, C>(this IEnumerable<T> source, Func<T, C> getfield)
        {
            return source.Distinct(new Compare<T, C>(getfield));
        }

        public static IQueryable<T> DistinctBy<T, C>(this IQueryable<T> source, Func<T, C> getfield)
        {
            return source.Distinct(new Compare<T, C>(getfield));
        }
    }