using DataEntity;
using DataEntity.Share;
using HxEnum;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.Linq;
using System.Net.Sockets;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Media;
using System.Xml;
using XCommon.Log;
using XImagingXhandler.XDAL;
using static HxEnum.DataTypeEnum;

namespace XCommon
{
    /// <summary>
    /// 共用类
    /// </summary>
    public class ComUtility
    {
        #region 获取配置参数
        /// <summary>
        /// 获取配置参数
        /// </summary>
        /// <returns></returns>
        public static bool GetConfigParams()
        {
            bool bIsOk = false;
            string strValue = string.Empty;
            double dValue = 0d;

            try
            {
                do
                {
                    #region 窗体显示尺寸
                    Shared.Config.DisplaySizeW = 1920d;
                    Shared.Config.DisplaySizeH = 1080d;
                    Shared.Config.DisplayMarginTop = 0d;

                    #region 窗体显示尺寸
                    if (!GetConfigValue("displaySize", out strValue))
                    {
                        break;
                    }

                    string[] displaySizes = strValue.Split('*');
                    if (displaySizes.Length == 2)
                    {
                        if (!ParseToDouble(displaySizes[0], out dValue))
                        {
                            break;
                        }
                        Shared.Config.DisplaySizeW = dValue;

                        if (!ParseToDouble(displaySizes[1], out dValue))
                        {
                            break;
                        }
                        Shared.Config.DisplaySizeH = dValue;
                    }
                    #endregion

                    #region 窗体显示距顶距离
                    if (!GetConfigValue("displayMarginTop", out strValue))
                    {
                        break;
                    }
                    if (!ParseToDouble(strValue, out dValue))
                    {
                        break;
                    }
                    Shared.Config.DisplayMarginTop = dValue;
                    #endregion

                    #endregion











                    bIsOk = true;
                }
                while (false);
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);
            }

            return bIsOk;
        }

        /// <summary>
        /// 获取Config的值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool GetConfigValue(string key, out string value)
        {
            value = ConfigurationManager.AppSettings.Get(key);
            if (value == null)
            {
                LoggerHelper.ErrorLog(string.Format("[GetConfigValue]: Key:{0}, Value:{1}", key, value));
                return false;
            }

            return true;
        }
        #endregion

        #region 获取Guid
        /// <summary>
        /// 获取Guid
        /// </summary>
        /// <returns></returns>
        public static string GetGuid()
        {
            return Guid.NewGuid().ToString("N");
        }
        #endregion

        #region 获取MD5值
        /// <summary>
        /// 获取MD5值
        /// </summary>
        /// <param name="strVal"></param>
        /// <returns></returns>
        public static string GetMD5(string strVal)
        {
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] bytValue, bytHash;
            bytValue = Encoding.UTF8.GetBytes(strVal);
            bytHash = md5.ComputeHash(bytValue);
            md5.Clear();
            string sTemp = "";
            for (int i = 0; i < bytHash.Length; i++)
            {
                sTemp += bytHash[i].ToString("X").PadLeft(2, '0');
            }
            return sTemp.ToLower();
        }
        #endregion

        #region 有效孔字符串转换成List
        /// <summary>
        /// 有效孔字符串转换成List
        /// </summary>
        /// <param name="strValidWells"></param>
        /// <returns></returns>
        public static List<string> GetValidWells(string strValidWells)
        {
            List<string> lstValidWells = new List<string>();

            if (!string.IsNullOrEmpty(strValidWells))
            {
                string[] validWellsArry = strValidWells.Split(',');
                lstValidWells = validWellsArry.ToList();
            }

            return lstValidWells;
        }
        #endregion

        #region 获取放盖位名称
        /// <summary>
        /// 获取放盖位名称
        /// </summary>
        /// <param name="strValidWells"></param>
        /// <returns></returns>
        public static List<string> GetPlateCoverLatticeName()
        {
            string coatingCoverLatticeId = ConfigurationManager.AppSettings["coatingCoverLatticeId"].ToString();
            // 涂布的板放盖位号：P2,P3
            List<string> listCoatingCoverLatticeId = coatingCoverLatticeId.Split(',').ToList();
            return listCoatingCoverLatticeId;
        }
        #endregion

        #region 根据输入的行数，取得对应的字符串名称
        /// <summary>
        /// 根据输入的行数，取得对应的字符串名称
        /// </summary>
        /// <param name="rowNum">当前的行号</param>
        /// <returns>该行对应的字母</returns>
        public static string GetRowChar(int rowNum)
        {
            var a = rowNum / 26;
            var b = rowNum % 26;

            if (a > 0) return GetRowChar(a - 1) + (char)(b + 65);

            return ((char)(b + 65)).ToString();
        }
        #endregion

        #region 根据输入的行字母，取得对应的行号
        /// <summary>
        /// 根据输入的行字母，取得对应的行号
        /// </summary>
        /// <param name="rowName">当前的行字母</param>
        /// <returns>该行号</returns>
        public static string GetRowIndexByRowChar(string rowName)
        {
            int currentValue = Convert.ToInt32(rowName.ToCharArray()[0]);
            return (currentValue - 65).ToString();
        }
        #endregion


        #region 根据输入的行名称，取得对应的行index
        public static int GetRowIndex(string col)
        {
            if (string.IsNullOrEmpty(col))
            {
                return -1;
            }
            return (Convert.ToChar(col) - 65);
        }
        #endregion

        #region 根据输入的行编号，取得对应的行名称
        public static string GetRowName(string rowNum)
        {
            return Convert.ToChar((Convert.ToInt32(rowNum) + 65)).ToString();
        }
        #endregion

        #region 获取列号: A11 -> 11
        /// <summary>
        /// 获取列号
        /// </summary>
        /// <param name="wellName"></param>
        /// <returns></returns>
        public static int GetColNum(string wellName)
        {
            string colNum = Regex.Replace(wellName, "[A-Za-z ]", string.Empty);
            return int.Parse(colNum);
        }
        #endregion

        #region 获取行字母: A11 -> A
        /// <summary>
        /// 获取行字母
        /// </summary>
        /// <param name="wellName"></param>
        /// <returns></returns>
        public static string GetRowChar(string wellName)
        {
            return Regex.Replace(wellName, "[0-9 ]", string.Empty);
        }
        #endregion

        #region 获取吸头盒、孔板有效孔位信息
        /// <summary>
        /// 获取吸头盒、孔板有效孔位信息
        /// </summary>
        /// <param name="rowCount"></param>
        /// <param name="columnCount"></param>
        /// <returns></returns>
        public static string GetValidWells(int rowCount, int columnCount)
        {
            string validWells = string.Empty;
            for (int i = 1; i < rowCount + 1; i++)
            {
                string rowName = ComUtility.GetRowChar(i - 1);
                for (int j = 1; j < columnCount + 1; j++)
                {
                    string wellName = rowName + j.ToString();
                    validWells += wellName + ",";
                }
            }

            if (!string.IsNullOrEmpty(validWells))
            {
                validWells = validWells.Substring(0, validWells.Length - 1);
            }

            return validWells;
        }
        #endregion

        #region 从xml中获取通道数组值
        /// <summary>
        /// 从xml中获取通道数组值
        /// </summary>
        /// <param name="xmlChs"></param>
        /// <returns></returns>
        public static int[] GetChannelsFromXml(string xmlChs)
        {
            int[] nArrayChs = new int[0];

            if (xmlChs.Contains(","))
            {
                string[] chs = xmlChs.Split(',');
                nArrayChs = Array.ConvertAll<string, int>(chs, s => int.Parse(s));
            }
            else
            {
                if (!string.IsNullOrEmpty(xmlChs))
                {
                    nArrayChs = new int[1] { Convert.ToInt32(xmlChs) };
                }
            }

            var channelList = nArrayChs.ToList();
            channelList.Sort();
            nArrayChs = channelList.ToArray();

            return nArrayChs;
        }
        #endregion

        #region 根据板位别名和台面信息xml查找到对应唯一板位节点
        /// <summary>
        /// 根据板位别名和台面信息xml查找到对应唯一板位
        /// </summary>
        /// <param name="platformList"></param>
        /// <param name="boardName"></param>
        /// <returns></returns>
        public static XmlNode GetXmlNodeByBoardName(XmlNodeList platformList, string boardName)
        {
            XmlNode result = null;

            for (int i = 0; i < platformList.Count; i++)
            {
                XmlNodeList labwareNodeList = platformList[i].SelectNodes("labware");

                var labwareSrcNode = labwareNodeList[0].SelectSingleNode("labware_sname[text()='" + boardName + "']");
                if (labwareSrcNode != null)
                {
                    result = platformList[i];
                    break;
                }
            }
            return result;
        }
        #endregion

        #region 根据枚举值获取下拉值
        public static List<DropdownName> GetDropDownList<T>()
        {
            List<DropdownName> dropdownNames = new List<DropdownName>();
            var dicCommunicateType = EnumManagement.EnumToDictionaryValue<T>();
            foreach (var dicItem in dicCommunicateType)
            {
                dropdownNames.Add(new DropdownName() { dropdown_id = dicItem.Key, dropdown_name = dicItem.Value });
            }
            return dropdownNames;
        }
        #endregion

        #region 判断Socket是否连接上，需要通过发包来确认： （这个方法也不能解决物理掉线问题，比如拔网线）
        /// <summary>
        /// 判断Socket是否连接上，需要通过发包来确认： （这个方法也不能解决物理掉线问题，比如拔网线）
        /// </summary>
        /// <param name="client"></param>
        /// <returns></returns>
        public static bool IsSocketConnected(Socket client)
        {
            if (client != null)
            {
                bool blockingState = client.Blocking;
                try
                {
                    byte[] tmp = new byte[1];
                    client.Blocking = false;
                    client.Send(tmp, 0, 0);
                    return true;
                }
                catch (SocketException e)
                {
                    // 产生 10035 == WSAEWOULDBLOCK 错误，说明被阻止了，但是还是连接的
                    if (e.NativeErrorCode.Equals(10035))
                        return true;
                    else
                        return false;
                }
                finally
                {
                    client.Blocking = blockingState;    // 恢复状态
                }
            }
            return true;
        }
        #endregion

        #region 数据转换
        #region 字符串转Image
        /// <summary>
        /// 字符串转Image
        /// </summary>
        /// <param name="base64String"></param>
        /// <returns></returns>
        public static ImageSource StringToImag(string base64String)
        {
            if (string.IsNullOrEmpty(base64String))
                return null;
            byte[] bytes = System.Convert.FromBase64String(base64String);

            System.IO.MemoryStream ms = new System.IO.MemoryStream(bytes);
            ImageSourceConverter imageSourceConverter = new ImageSourceConverter();
            ImageSource source = null;
            source = (ImageSource)imageSourceConverter.ConvertFrom(ms);

            return source;
        }
        #endregion

        #region 转成数字类型
        /// <summary>
        /// 转成数字类型
        /// </summary>
        /// <param name="valueSource"></param>
        /// <param name="valueTarget"></param>
        /// <returns></returns>
        public static bool ParseToInt(string valueSource, out int valueTarget)
        {
            if (!int.TryParse(valueSource, out valueTarget))
            {
                LoggerHelper.ErrorLog(string.Format("ParseToInt,value = {0}, 参数不是Int！！！", valueSource));
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion

        #region 转成double类型
        /// <summary>
        /// 转成double类型
        /// </summary>
        /// <param name="valueSource"></param>
        /// <param name="valueTarget"></param>
        /// <returns></returns>
        public static bool ParseToDouble(string valueSource, out double valueTarget)
        {
            if (!double.TryParse(valueSource, out valueTarget))
            {
                LoggerHelper.ErrorLog(string.Format("ParseToDouble,value = {0}, 参数不是double！！！", valueSource));
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion

        #region 转成bool类型
        /// <summary>
        /// 转成bool类型
        /// </summary>
        /// <param name="valueSource"></param>
        /// <param name="valueTarget"></param>
        /// <returns></returns>
        public static bool ParseToBool(string valueSource, ref bool valueTarget)
        {
            if (!bool.TryParse(valueSource, out valueTarget))
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion

        #region 转成DateTime类型
        /// <summary>
        /// 转成DateTime类型
        /// </summary>
        /// <param name="valueSource"></param>
        /// <param name="valueTarget"></param>
        /// <returns></returns>
        public static bool ParseToDateTime(string valueSource, out DateTime valueTarget)
        {
            if (!DateTime.TryParse(valueSource, out valueTarget))
            {
                LoggerHelper.ErrorLog(string.Format("ParseToDateTime,value = {0}, 参数不是DateTime！！！", valueSource));
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion
        #endregion

        #region 根据行/列有效数量计算列的批次信息
        /// <summary>
        /// 根据行/列有效数量计算列的批次信息
        /// </summary>
        /// <param name="wells"></param>
        /// <param name="channels"></param>
        /// <param name="dilutionDirectionValue"></param>
        /// <returns></returns>
        public static List<List<TipsTable>> GetWellBatchInfo(List<TipsTable> wells, int[] channels,
            DilutionDirectionEnum dilutionDirectionValue)
        {
            List<List<TipsTable>> lstWellBatchInfo = new List<List<TipsTable>>();

            int oneGroupCnt = 0;
            // 从左到右
            if (dilutionDirectionValue == DilutionDirectionEnum.LeftToRight)
            {
                // 一组数量先定义为枪头的数量
                oneGroupCnt = channels.Length;

                // 384孔：16行 * 24列
                for (int i = 1; i <= 24; i++)
                {
                    var selWells = wells.Where(it => ComUtility.GetColNum(it.wellname) == i);
                    if (selWells.Any())
                    {
                        List<TipsTable> colList = selWells.ToList();
                        // 一组数量取最小值
                        oneGroupCnt = Math.Min(oneGroupCnt, colList.Count);

                        var groups = Enumerable.Range(0, (colList.Count + oneGroupCnt - 1) / oneGroupCnt)
                            .Select((j, index) => colList.Skip(index * oneGroupCnt).Take(oneGroupCnt)).ToList();

                        foreach (var group in groups)
                        {
                            lstWellBatchInfo.Add(group.ToList());
                        }
                    }
                }
            }
            // 从上到下
            else if (dilutionDirectionValue == DilutionDirectionEnum.UpToDown)
            {
                // 384孔：16行 * 24列
                for (int i = 1; i <= 24; i++)
                {
                    var selWells = wells.Where(it => ComUtility.GetColNum(it.wellname) == i);
                    if (selWells.Any())
                    {
                        List<TipsTable> colList = selWells.ToList();
                        // 一组数量取最小值
                        oneGroupCnt = 1;

                        var groups = Enumerable.Range(0, (colList.Count + oneGroupCnt - 1) / oneGroupCnt)
                            .Select((j, index) => colList.Skip(index * oneGroupCnt).Take(oneGroupCnt)).ToList();

                        foreach (var group in groups)
                        {
                            lstWellBatchInfo.Add(group.ToList());
                        }
                    }
                }
            }
            // 从下到上
            else if (dilutionDirectionValue == DilutionDirectionEnum.DownToUp)
            {
                // 384孔：16行 * 24列
                for (int i = 1; i <= 24; i++)
                {
                    var selWells = wells.Where(it => ComUtility.GetColNum(it.wellname) == i);
                    if (selWells.Any())
                    {
                        List<TipsTable> colList = selWells.ToList();
                        colList.Reverse();
                        // 一组数量取最小值
                        oneGroupCnt = 1;

                        var groups = Enumerable.Range(0, (colList.Count + oneGroupCnt - 1) / oneGroupCnt)
                            .Select((j, index) => colList.Skip(index * oneGroupCnt).Take(oneGroupCnt)).ToList();

                        foreach (var group in groups)
                        {
                            lstWellBatchInfo.Add(group.ToList());
                        }
                    }
                }
            }

            return lstWellBatchInfo;
        }
        #endregion

        #region 数据类型转换 
        /// <summary>
        /// 数据类型转换
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static object ToTypeConvert(string value, string type)
        {
            var sfsd = EnumManagement.GetALLEnum<DataTypeEnum_Parameter>();

            Dictionary<string, object> dic = new Dictionary<string, object>();
            if (EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.Varchar ||
                EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.Datetime ||
                EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.JSON)
            {
                return value;
            }
            else if (EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.Int)
            {
                return Convert.ToInt32(value);
            }
            else if (EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.Bool)
            {
                return Convert.ToBoolean(value);
            }
            else if (EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.Double)
            {
                return Convert.ToDouble(value);
            }
            else if (EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.USHORT)
            {
                return Convert.ToUInt16(value);
            }
            else if (EnumManagement.ToEnum<DataTypeEnum_Parameter>(type) == DataTypeEnum_Parameter.BYTE)
            {
                return Convert.ToByte(value);
            }
            return dic;
        }
        #endregion

        #region RGB转Color
        /// <summary>
        /// RGB转Color
        /// </summary>
        /// <param name="strRGB"></param>
        /// <returns></returns>
        public static Color RGBToColor(string strRGB)
        {
            Color color = Colors.WhiteSmoke;
            if (string.IsNullOrEmpty(strRGB))
            {
                return color;
            }

            string[] strRgbArray = strRGB.Split(',');
            if (strRgbArray.Length < 3)
            {
                return color;
            }

            int[] nRgbArray = Array.ConvertAll(strRgbArray, int.Parse);

            color = Color.FromRgb((byte)nRgbArray[0], (byte)nRgbArray[1], (byte)nRgbArray[2]);
            return color;
        }
        #endregion

        #region 对相同属性名称值复制Value
        /// <summary>
        /// 对相同属性名称值复制Value
        /// </summary>
        /// <typeparam name="D">新对象</typeparam>
        /// <typeparam name="S">原始对象</typeparam>
        /// <param name="s">原始对象</param>
        /// <param name="isCopyStruct">是否只复制结构类型（包括string类型）</param>
        /// <returns></returns>
        public static D MapperStruct<D, S>(S s)
        {
            D d = Activator.CreateInstance<D>();
            try
            {
                var Types = s.GetType();// 获得类型
                var Typed = typeof(D);
                foreach (PropertyInfo sp in Types.GetProperties())
                {
                    foreach (PropertyInfo dp in Typed.GetProperties())
                    {
                        if (dp.Name.Equals(sp.Name))
                        {
                            dp.SetValue(d, sp.GetValue(s, null), null);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return d;
        }
        #endregion

        #region 根据字符串分割成下拉值
        /// <summary>
        /// 根据字符串分割成下拉值
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static ObservableCollection<DropdownName> GetDropDownList(string value)
        {
            ObservableCollection<DropdownName> dropDownList = new ObservableCollection<DropdownName>();

            string[] ChoiceModelTypes = value.Split(';');
            for (int index = 0; index < ChoiceModelTypes.Length; index++)		// 模型类型
            {
                string[] modelType = ChoiceModelTypes[index].Split('-');
                DropdownName dropdownName = new DropdownName();
                dropdownName.dropdown_id = modelType[0];
                dropdownName.dropdown_name = modelType[1];
                dropDownList.Add(dropdownName);
            }

            return dropDownList;
        }
        #endregion

        #region 根据keyId名称查找方法节点属性
        /// <summary>
        /// 根据keyId名称查找方法节点属性
        /// </summary>
        /// <param name="mEx"></param>
        /// <param name="keyId"></param>
        /// <returns></returns>
        public static MethodEx FindMethodExByKeyId(MethodEx mEx, string keyId)
        {
            if (mEx.tag != null && ((XImagingXhandler.XDAL.MethodBase)mEx.tag).keyId == keyId)
            {
                return mEx;
            }
            else
            {
                if (mEx.Children.Count > 0)
                {
                    foreach (var m in mEx.Children)
                    {
                        MethodEx find = FindMethodExByKeyId(m, keyId);
                        if (find != null)
                        {
                            return find;
                        }
                    }
                }

                if (mEx.SubMethod != null)
                {
                    MethodEx find = FindMethodExByKeyId(mEx.SubMethod, keyId);
                    if (find != null)
                    {
                        return find;
                    }
                }
                else
                {
                    return null;
                }
            }
            return null;
        }
        #endregion
    }
}