using DataEntity.Sockets.Base;
using HxEnum;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using XCommon;
using XCommon.Log;
using XImagingXhandler.XDAL;
using static HxEnum.StateEnum;

namespace HxSocketImplement.Sockets
{
    /// <summary>
    /// Socket服务
    /// </summary>
    public class HxSockServiceExecute
    {
        #region 变量  
        /// <summary>
        /// 缓存参数
        /// </summary> 
        public static Dictionary<string, SocketParameterModel> CacheSocketParameterData = new Dictionary<string, SocketParameterModel>();

        /// <summary>
        /// 监测心跳Thread
        /// </summary>
        private static Thread checkHeartbeatThread = null;
        /// <summary>
        /// 接收消息Thread
        /// </summary>
        private static Thread getReceiveThread = null;
        #endregion

        #region 获取指定设备类型缓存数据
        /// <summary>
        /// 获取指定设备类型缓存数据
        /// </summary>
        /// <param name="equipmentType">类型</param> 
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static SocketParameterModel GetSocketParameterModel(string equipmentType, string ip, int port, string equipmentId)
        {
            if (!string.IsNullOrWhiteSpace(equipmentType))
            {
                var cacheSocketParameterData = CacheSocketParameterData.Where(x => x.Key == equipmentType + ip + port + equipmentId);
                if (cacheSocketParameterData != null && cacheSocketParameterData.Count() > 0)
                {
                    return cacheSocketParameterData.FirstOrDefault().Value;
                }
            }
            return null;
        }
        #endregion

        #region 连接+断开+检查心跳
        #region 连接服务端
        /// <summary>
        /// 连接服务端
        /// </summary>
        /// <param name="equipmentType">类型</param> 
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static bool Connect(string equipmentType, string ip, int port, string equipmentId)
        {
            var socketParameterModel = GetSocketParameterModel(equipmentType, ip, port, equipmentId);
            try
            {
                if (socketParameterModel != null && socketParameterModel.Socket == null)
                {
                    #region 建立连接
                    bool isConnect = ConnectSocket(socketParameterModel);
                    #endregion

                    #region 监测心跳
                    checkHeartbeatThread = new Thread(() => CheckHeartbeat(socketParameterModel));
                    checkHeartbeatThread.IsBackground = true;
                    checkHeartbeatThread.Start();
                    #endregion

                    #region 接收消息Thread
                    getReceiveThread = new Thread(() => GetReceive(socketParameterModel));
                    getReceiveThread.IsBackground = true;
                    getReceiveThread.Start();
                    #endregion

                    if (isConnect)
                    {
                        LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "连接服务器【成功】Connect");
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    if (CheckConnected(socketParameterModel.Socket, socketParameterModel.Ip) == false)
                    {
                        bool isConnect = ConnectSocket(socketParameterModel);
                        if (isConnect)
                        {
                            LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "连接服务器【成功】Connect");
                        }
                        else
                        {
                            LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "连接服务器【失败】Connect");
                            return false;
                        }
                    }
                    else
                    {
                        LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "连接服务器【成功】Connect");
                    }
                }
            }
            catch (Exception ex)
            {
                LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "连接服务器【失败】Connect" + ex.Message);
                return false;
            }
            return true;
        }
        #endregion


        #region 建立连接 
        /// <summary>
        /// 建立连接
        /// </summary>
        /// <param name="socketParameterModel"></param>
        /// <returns></returns>
        public static bool ConnectSocket(SocketParameterModel socketParameterModel)
        {
            try
            {
                #region 建立连接
                socketParameterModel.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);   //1.0 实例化套接字(IP4寻址地址,流式传输,TCP协议)
                IPAddress address = IPAddress.Parse(socketParameterModel.Ip);   //2.0 创建IP对象
                IPEndPoint endPoint = new IPEndPoint(address, socketParameterModel.Port);   //3.0 创建网络端口包括ip和端口
                socketParameterModel.Socket.Connect(endPoint);   //4.0 建立连接
                #endregion

                return true;
            }
            catch (Exception ex)
            {
                LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "连接服务器【失败】ConnectSocket" + ex.Message);
            }
            return false;
        }
        #endregion

        #region 断开连接
        /// <summary>
        /// 断开连接
        /// </summary>
        /// <param name="equipmentType">类型</param> 
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static bool BreakConnect(string equipmentType, string ip, int port, string equipmentId)
        {
            var socketParameterModel = GetSocketParameterModel(equipmentType, ip, port, equipmentId);
            if (socketParameterModel != null && socketParameterModel.Socket != null && socketParameterModel.Socket.Connected)
            {
                // 断开与服务端的连接时，监测心跳Thread和接收消息Thread也要关闭
                if (checkHeartbeatThread != null)
                {
                    checkHeartbeatThread.Abort();
                    checkHeartbeatThread = null;
                }
                if (getReceiveThread != null)
                {
                    getReceiveThread.Abort();
                    getReceiveThread = null;
                }

                socketParameterModel.Socket.Shutdown(SocketShutdown.Both);
                socketParameterModel.Socket.Close();
                socketParameterModel.Socket.Dispose();
                LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "断开连接【成功】BreakConnect");

                socketParameterModel.Socket = null;
                socketParameterModel = null;

                //Thread.Sleep(500);
                return true;
            }
            else
            {
                LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "断开连接【失败】BreakConnect");
            }
            return false;
        }
        #endregion

        #region 检查心跳
        /// <summary>
        /// 检查心跳
        /// </summary>
        /// <returns></returns>
        public static bool CheckHeartbeat(SocketParameterModel model)
        {
            while (true)
            {
                try
                {
                    if (CheckConnected(model.Socket, model.Ip))
                    {
                        string msgId = $"{model.Ip}_{model.Port}_{model.EquipmentId}_{model.EquipmentType}_{HxSockServiceExecute.InstrunctionId()}";
                        HeartbeatMoel heartbeatMoel = new HeartbeatMoel
                        {
                            message_id = msgId,//  + "_" + HxSockServiceExecute.InstrunctionId(),
                            message_type = model.HeartMessageType,
                            equipment_id = model.HeartEquipmentId,
                            workflow_id = "workflow_id_" + msgId,
                            equipment_status = 1,
                            actual_device_status = 1,
                            connected = 1,
                            timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
                        };

                        string sendJson = JsonConvert.SerializeObject(heartbeatMoel) + model.SpecifiedDisplay;
                        byte[] buffer = new byte[2048];
                        buffer = Encoding.UTF8.GetBytes(sendJson);
                        int receive = model.Socket.Send(buffer);
                    }
                    else
                    {
                        #region 建立连接
                        model.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);   //1.0 实例化套接字(IP4寻址地址,流式传输,TCP协议)
                        IPAddress address = IPAddress.Parse(model.Ip);   //2.0 创建IP对象
                        IPEndPoint endPoint = new IPEndPoint(address, model.Port);   //3.0 创建网络端口包括ip和端口
                        model.Socket.Connect(endPoint);   //4.0 建立连接
                        #endregion
                    }
                }
                catch (Exception ex)
                {
                    LoggerSocketHelper.DebugLog(GetIpInfo(model) + "检查心跳【错误】CheckHeartbeat" + ex.Message);
                }
                Thread.Sleep(5000);
            }
        }
        #endregion
        #endregion

        #region 判断SOCKET是否连接
        #region 检查连接是否断开
        /// <summary>
        /// 检查连接是否断开
        /// </summary>
        /// <returns></returns>
        public static bool CheckConnected(Socket socket, string ip)
        {
            if (socket != null && socket.Connected && PingOC(ip) && ComUtility.IsSocketConnected(socket))
            {
                return true;
            }
            return false;
        }
        #endregion

        #region 检查一个Socket是否可连接(PING网络是否通)
        /// <summary>
        /// 检查一个Socket是否可连接(PING网络是否通)
        /// </summary>
        /// <param name="ips"></param>
        /// <returns></returns>
        public static bool PingOC(String ips)
        {
            return true;

            //bool ret;
            //Process p = new Process();
            //p.StartInfo.FileName = "cmd.exe";
            //p.StartInfo.UseShellExecute = false;
            //p.StartInfo.RedirectStandardInput = true;
            //p.StartInfo.RedirectStandardOutput = true;
            //p.StartInfo.RedirectStandardError = true;
            //p.StartInfo.CreateNoWindow = true;
            //int i = 0;
            //p.Start();
            //p.StandardInput.WriteLine("ping -n 1 " + ips);
            //p.StandardInput.WriteLine("exit");
            //string strRst = p.StandardOutput.ReadToEnd();
            //if (strRst.IndexOf("(100%") == -1)
            //{
            //    ret = true;
            //}
            //else
            //{
            //    ret = false;
            //}
            //p.Close();
            //return ret;
        }
        #endregion
        #endregion

        #region 发送和接收数据
        #region 发送数据
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="equipmentType">设备类别</param>
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <param name="data">JSON参数据</param>
        /// <param name="workflow_id">工作流ID</param>
        /// <returns></returns>
        public static Result SendData(string equipmentType, string ip, int port, string equipmentId, string data, string workflow_id)
        {
            Result result = new Result();
            var socketParameterModel = GetSocketParameterModel(equipmentType, ip, port, equipmentId);
            if (socketParameterModel != null)
            {
                if (CheckConnected(socketParameterModel.Socket, socketParameterModel.Ip))
                {
                    bool blockingState = socketParameterModel.Socket.Blocking;
                    try
                    {
                        #region 数据分割 
                        //int strLength = data.Length;
                        //int byteLength = 10;

                        //if (strLength > byteLength)
                        //{
                        //    double loopNumTemp = (double)(Math.Round((decimal)(Convert.ToDecimal(strLength) / Convert.ToDecimal(byteLength)), 5));
                        //    var loopData = WebHelper.GetStr(data, byteLength);
                        //    int loopNum = 1000;
                        //    foreach (var item in loopData)
                        //    {
                        //        string loopStr = item;
                        //        if (loopNum == loopData.Count())
                        //        {
                        //            loopStr = loopStr + socketParameterModel.SpecifiedDisplay;
                        //        }

                        //        //string sendMessage = data + socketParameterModel.SpecifiedDisplay;
                        //        socketParameterModel.Socket.Send(Encoding.UTF8.GetBytes(loopStr));
                        //        LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "发送数据【成功】SendData：" + loopStr);
                        //        loopNum = loopNum + 1;
                        //        Thread.Sleep(2000);
                        //    }
                        //}
                        //else
                        //{
                        //    string sendMessage = data + socketParameterModel.SpecifiedDisplay;
                        //    socketParameterModel.Socket.Send(Encoding.UTF8.GetBytes(sendMessage));
                        //    LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "发送数据【成功】SendData：" + sendMessage);
                        //}

                        string sendMessage = data + socketParameterModel.SpecifiedDisplay;
                        //Thread.Sleep(100);

                        var sendNum = socketParameterModel.Socket.Send(Encoding.UTF8.GetBytes(sendMessage));
                        LoggerSocketHelper.DebugLog(GetIpInfo(socketParameterModel) + "发送数据【成功】SendData：" + sendMessage + "_sendNum：" + sendNum + "_本地端口号：" + socketParameterModel.Socket.LocalEndPoint);
                        #endregion

                        result = GetReceiveResult(socketParameterModel, workflow_id);
                        return result;
                    }
                    catch (Exception ex)
                    {
                        result.status = StateEnum_Equipment.Failed;
                        result.msg = GetIpInfo(socketParameterModel) + "发送数据【出错】SendData：" + ex.Message + ",StackTrace：" + ex.StackTrace;
                        LoggerSocketHelper.DebugLog(result.msg + ex);
                        return result;
                    }
                    //finally
                    //{
                    //    _socket.Blocking = blockingState;    // 恢复状态
                    //}
                }
                else
                {
                    result.status = StateEnum_Equipment.Failed;
                    result.msg = $"发送数据【出错】SendData：设备ID：{equipmentType}，{ip}:{port}，{equipmentId}已断开连接";
                    LoggerSocketHelper.DebugLog(result.msg);
                    return result;
                }
            }
            result.status = StateEnum_Equipment.Failed;
            result.msg = $"发送数据【出错】SendData：未获取到缓存里面的{equipmentType}数据";
            return result;
        }
        #endregion

        #region 获取返回数据-实际结果
        /// <summary>
        /// 获取返回数据-实际结果
        /// </summary>
        /// <param name="workflow_id">发送指令工作流ID</param>
        /// <returns></returns>
        public static Result GetReceiveResult(SocketParameterModel model, string workflow_id)
        {
            Result rModel = new Result();
            while (true)
            {
                if (model.cacheReceiveData != null && model.cacheReceiveData.Count > 0)
                {
                    CacheReceiveDataModel tempData = new CacheReceiveDataModel();

                    for (int i = 0; i < model.cacheReceiveData.Count; i++)
                    {
                        if (model.cacheReceiveData[i] != null && model.cacheReceiveData[i].CacheKey == workflow_id)
                        {
                            tempData = model.cacheReceiveData[i];
                            break;
                        }
                    }

                    if (tempData != null && !string.IsNullOrWhiteSpace(tempData.CacheKey) && tempData.CacheValue != null)
                    {
                        ResponseObject roData = tempData.CacheValue;
                        if (roData != null && roData.workflow_id == workflow_id)
                        {
                            string tempRoData = JsonConvert.SerializeObject(roData);

                            switch (roData.method_status)
                            {
                                case 2:
                                    rModel.status = StateEnum_Equipment.Completed;
                                    rModel.msg = "执行成功";
                                    rModel.data = new Data { json = tempRoData };
                                    break;
                                case 3:
                                    rModel.status = StateEnum_Equipment.Failed;
                                    rModel.msg = "执行失败，错误码：" + roData.error.error_code + "，错误内容：" + roData.error.error_text;
                                    rModel.data = new Data { json = tempRoData };
                                    rModel.DealWithType = EnumManagement.GetEnumValue(DealWithType_Enum.DealWithTypeBEnum).ToString();
                                    if (roData != null && roData.error != null)
                                    {
                                        rModel.ErrorMsg = new ErrorMsgModel { Error_Code = roData.error.error_code, Error_Text = roData.error.error_text, Troubleshoot = roData.error.troubleshoot };
                                        rModel.DealWithType = roData.error.dealwithtype != null ? roData.error.dealwithtype.ToString() : EnumManagement.GetEnumValue(DealWithType_Enum.DealWithTypeBEnum).ToString();
                                    }
                                    break;
                                case 4:
                                    rModel.status = StateEnum_Equipment.Canceled;
                                    rModel.msg = "任务被取消";
                                    rModel.data = new Data { json = tempRoData };
                                    break;
                                case 5:
                                    rModel.status = StateEnum_Equipment.AlarmInfo;
                                    rModel.msg = "告警信息，错误码：" + roData.error.error_code + "，错误内容：" + roData.error.error_text;
                                    rModel.data = new Data { json = tempRoData };
                                    rModel.DealWithType = EnumManagement.GetEnumValue(DealWithType_Enum.DealWithTypeBEnum).ToString();
                                    if (roData != null && roData.error != null)
                                    {
                                        rModel.ErrorMsg = new ErrorMsgModel { Error_Code = roData.error.error_code, Error_Text = roData.error.error_text, Troubleshoot = roData.error.troubleshoot };
                                        rModel.DealWithType = roData.error.dealwithtype != null ? roData.error.dealwithtype.ToString() : EnumManagement.GetEnumValue(DealWithType_Enum.DealWithTypeBEnum).ToString();
                                    }
                                    break;
                                default:
                                    rModel.status = EnumManagement.GetField<StateEnum_Equipment>(roData.method_status);
                                    rModel.msg = "返回出错";
                                    rModel.data = new Data { json = tempRoData };
                                    break;
                            }
                            LoggerSocketHelper.DebugLog(GetIpInfo(model) + $"获取返回数据【{rModel.msg},{rModel.status}】GetReceiveResult" + JsonConvert.SerializeObject(rModel));
                            return rModel;
                        }
                        //else
                        //{
                        //     LoggerSocketHelper.DebugLog(GetIpInfo() + "获取返回数据【出错】GetReceive");
                        //}
                    }
                }

                Thread.Sleep(100);
            }
        }
        #endregion

        #region 获取返回数据-sock结果
        /// <summary>
        /// 获取返回数据-sock结果
        /// </summary>
        /// <param name="_socket"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public static Result GetReceive(SocketParameterModel model)
        {
            Result rModel = new Result();
            while (true)
            {
                try
                {
                    bool isCheckConnected = CheckConnected(model.Socket, model.Ip);

                    //if (model.Socket.Available > 0 )
                    //{
                    //    LoggerSocketHelper.DebugLog("连接状态：" + isCheckConnected + "_IP：" + model.Ip +"_端口："+ model.Port + "_Available数据量：" + model.Socket.Available);
                    //}

                    if (isCheckConnected)
                    {
                        if (model.Socket.Available > 0)
                        {
                            lock (model.LockReceive)
                            {
                                int length = model.Socket.Receive(model.Buffer);
                                if (length > 0 && model.Socket.Connected)
                                {
                                    var resultMsg = Encoding.UTF8.GetString(model.Buffer, 0, length);

                                    if (resultMsg.Contains(model.SpecifiedDisplay) == false)   //如果结尾没有指定符号，继续获取
                                    {
                                        StringBuilder sb = new StringBuilder();
                                        sb.Append(resultMsg);
                                        while (sb.ToString().Contains(model.SpecifiedDisplay) == false)
                                        {
                                            model.Socket.Blocking = true;

                                            int tempLength = model.Socket.Receive(model.Buffer);
                                            if (tempLength > 0 && model.Socket.Connected)
                                            {
                                                var tempStr = Encoding.UTF8.GetString(model.Buffer, 0, tempLength);
                                                sb.Append(tempStr);
                                            }
                                        }
                                        IsLoop(model, sb.ToString());
                                    }
                                    else
                                    {
                                        IsLoop(model, resultMsg);
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    rModel.status = StateEnum_Equipment.Failed;
                    rModel.msg = GetIpInfo(model) + "获取返回数据【缓存失败】GetReceive：" + ex.Message;
                    LoggerSocketHelper.DebugLog(rModel.msg + ex);
                }
            }
            //return rModel;
        }

        /// <summary>
        /// 是否循环数据
        /// </summary>
        /// <param name="model"></param>
        /// <param name="resultMsg"></param>
        private static void IsLoop(SocketParameterModel model, string resultMsg)
        {
            if (!string.IsNullOrWhiteSpace(resultMsg) && resultMsg.Contains("error"))
            {
                string[] sArray = Regex.Split(resultMsg, model.SpecifiedDisplay, RegexOptions.IgnoreCase);
                if (sArray != null && sArray.Count() > 0)
                {
                    //var resultMsgBysArray = sArray.FirstOrDefault(m => m.Contains("error"));

                    foreach (var resultMsgBysArray in sArray)
                    {
                        var isError = resultMsgBysArray.Contains("error");
                        if (isError && !string.IsNullOrWhiteSpace(resultMsgBysArray))
                        {
                            Thread.Sleep(400);

                            ResponseObject roData = JsonConvert.DeserializeObject<ResponseObject>(resultMsgBysArray);

                            try
                            {
                                #region 插入数据到缓存中  不能插入相同值
                                if (model.cacheReceiveData != null && model.cacheReceiveData.Count > 0)
                                {
                                    object isLockAdd = new object();
                                    lock (isLockAdd)
                                    {
                                        bool isHaveValue = false;
                                        for (int i = 0; i < model.cacheReceiveData.Count; i++)
                                        {
                                            if (model.cacheReceiveData[i].CacheKey == roData.workflow_id)
                                            {
                                                isHaveValue = true;
                                                break;
                                            }
                                        }

                                        if (isHaveValue == false)
                                        {
                                            model.cacheReceiveData.Add(new CacheReceiveDataModel { CacheKey = roData.workflow_id, CacheValue = roData });
                                        }
                                    }
                                }
                                else
                                {
                                    model.cacheReceiveData.Add(new CacheReceiveDataModel { CacheKey = roData.workflow_id, CacheValue = roData });
                                }
                                #endregion

                                LoggerSocketHelper.DebugLog(GetIpInfo(model) + "获取返回数据【缓存成功】IsLoop：" + resultMsg);
                            }
                            catch (Exception ex)
                            {
                                LoggerSocketHelper.DebugLog(GetIpInfo(model) + "获取返回数据【缓存失败】IsLoop：" + resultMsg + "失败错误内容：" + ex.Message + ex);
                            }
                        }
                    }
                }
            }      //驱动返回心跳
            else if (resultMsg.Contains("equipment_status") && resultMsg.Contains("connected"))
            {
                if (resultMsg.Contains(model.SpecifiedDisplay))
                {
                    var data = JObject.Parse(resultMsg.Replace(model.SpecifiedDisplay, ""));

                    //获取设备ID
                    string equipmentId = model.EquipmentType + model.Ip + model.Port + model.EquipmentId;

                    //string equipmentId = model.EquipmentId;// data["equipment_id"].ToString();

                    #region 设备状态（0驱动虚拟机模式，1驱动连真机状态） 
                    bool isEquipped = data["connected"].ToString() != "0";

                    //设备是否存在字典中
                    if (SocketParameterModel.Dic_EquipmentConnectedStatus != null && SocketParameterModel.Dic_EquipmentConnectedStatus.Count > 0)
                    {
                        for (int i = 0; i < SocketParameterModel.Dic_EquipmentConnectedStatus.Count; i++)
                        {
                            var dicEcs = SocketParameterModel.Dic_EquipmentConnectedStatus.ElementAt(i);

                            if (dicEcs.Key == equipmentId)
                            {
                                //更新驱动连接设备状态
                                SocketParameterModel.Dic_EquipmentConnectedStatus[equipmentId] = isEquipped;
                            }
                        }
                    }
                    else
                    {
                        //增加驱动连接设备状态
                        SocketParameterModel.Dic_EquipmentConnectedStatus.Add(equipmentId, isEquipped);
                    }

                    ////设备是否存在字典中
                    //if (SocketParameterModel.Dic_EquipmentConnectedStatus.Where(m => m.Key.Equals(equipmentId)).Count() > 0)
                    //{
                    //    //更新驱动连接设备状态
                    //    SocketParameterModel.Dic_EquipmentConnectedStatus[equipmentId] = isEquipped;
                    //}
                    //else
                    //{
                    //    //增加驱动连接设备状态
                    //    SocketParameterModel.Dic_EquipmentConnectedStatus.Add(equipmentId, isEquipped);
                    //}
                    #endregion

                    #region 设备状态（是否忙碌  1空闲、2忙碌）
                    string equipmentStatus = data["equipment_status"].ToString() == "1" ? "空闲" : (data["equipment_status"].ToString() == "2" ? "忙碌" : "出错");

                    if (SocketParameterModel.Dic_EquipmentStatus != null && SocketParameterModel.Dic_EquipmentStatus.Count > 0)
                    {
                        for (int i = 0; i < SocketParameterModel.Dic_EquipmentStatus.Count; i++)
                        {
                            var dicEcs = SocketParameterModel.Dic_EquipmentStatus.ElementAt(i);

                            if (dicEcs.Key == equipmentId)
                            {
                                //更新驱动连接设备状态
                                SocketParameterModel.Dic_EquipmentStatus[equipmentId] = equipmentStatus;
                            }
                        }
                    }
                    else
                    {
                        //增加驱动连接设备状态
                        SocketParameterModel.Dic_EquipmentStatus.Add(equipmentId, equipmentStatus);
                    }

                    ////设备是否存在字典中
                    //if (SocketParameterModel.Dic_EquipmentStatus.Where(m => m.Key.Equals(equipmentId)).Count() > 0)
                    //{
                    //    SocketParameterModel.Dic_EquipmentStatus[equipmentId] = equipmentStatus;
                    //}
                    //else
                    //{
                    //    SocketParameterModel.Dic_EquipmentStatus.Add(equipmentId, equipmentStatus);
                    //}
                    #endregion
                }
            }
        }
        #endregion
        #endregion

        #region 业务逻辑
        #region 随机生成字符串
        /// <summary>
        /// 随机生成字符串
        /// </summary>
        /// <returns></returns>
        public static string InstrunctionId()
        {
            Random random = new Random();
            int randKey = random.Next(1000, 9999);
            string guidStr = Guid.NewGuid().ToString();
            return DateTime.Now.ToString("yyyyMMddHHmmss") + "_" + guidStr;
        }
        #endregion

        #region 获取IP信息
        /// <summary>
        /// 获取IP信息
        /// </summary>
        /// <returns></returns>
        private static string GetIpInfo(SocketParameterModel model)
        {
            if (model == null)
            {
                return "获取socket参数为空【出错】GetIpInfo->";
            }
            return "IP和端口：" + model.Ip + ":" + model.Port + "->";
        }
        #endregion
        #endregion 
    }
}