using DataEntity.Device;
using DataEntity.Share;
using DataEntity.Sockets.Base;
using DataRWDAL.Device;
using HxEnum;
using Newtonsoft.Json;
using System;
using XCommon.Tip;
using XCommon.Log;
using XImagingXhandler.XDAL;
using static HxEnum.SocketS.InfoTypeEnum;
using static HxEnum.StateEnum;
using static HxEnum.OperationTypeEnum;
using XCommon.Event;
using System.Collections.Generic;
using System.Runtime.InteropServices.ComTypes;

namespace HxSocketImplement.Sockets.HxService
{
    /// <summary>
    /// 结果处理
    /// </summary>
    public class ResultHandle
    {
        /// <summary>
        /// 锁
        /// </summary>
        public static object m_Lock = new object();

        #region 添加接口统一返回的结果处理加工 
        /// <summary>
        /// 添加接口统一返回的结果处理加工
        /// </summary>
        /// <param name="commonParameterModel">参数</param>
        /// <param name="isSimulator">参数</param>
        /// <returns>返回统一结果</returns>
        public Result StepResult(InstructCommonMethodSendModel commonParameterModel, bool isSimulator)
        {
            SocketInteriorService.dicManualResetEvent[commonParameterModel.SendData.experiment_id].WaitOne();

            var deviceconfigTypeModel = DeviceConfigTypeDB.GetInfodById(commonParameterModel.EquipmentType);

            #region 插入设备执行日志 
            //string msg = $"设备【{EnumManagement.GetFieldText(deviceconfigTypeModel.Name)}】执行指令【{commonParameterModel.SendData.method}】";
            //LoggerSocketHelper.DebugLog(msg + "请求参数：" + JsonConvert.SerializeObject(commonParameterModel) + "_插入设备执行日志");

            //if (commonParameterModel.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionState_Enum.Virtually))
            //{
            //    msg = EnumManagement.GetFieldText(VirtualConnectionState_Enum.Virtually) + msg;
            //}

            //var executionLogModel = new ExecutionLogModel
            //{
            //    Id = Guid.NewGuid().ToString(),
            //    ExperimentId = commonParameterModel.SendData.experiment_id,
            //    Progress = 1,
            //    ExperimentStep = EnumManagement.GetFieldText(deviceconfigTypeModel.Name),
            //    //DataLogId = 1111111,
            //    EquipmentAction = msg,
            //    StartTime = DateTime.Now,
            //    //EndTime = DateTime.Now,
            //    Equipment = EnumManagement.GetFieldText(deviceconfigTypeModel.Name),
            //    //ErrorMessage = "",
            //    Remark = msg,
            //    CreateTime = DateTime.Now
            //};
            //new ExecutionLogBLL().AddExecutionLog(executionLogModel);
            #endregion

            Result resultModel = new Result();
            resultModel = InstructCommonMethod(commonParameterModel, isSimulator);

            if (resultModel != null && resultModel.status == StateEnum_Equipment.Completed)
            {
                #region 保留请求结果
                var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(commonParameterModel.EquipmentType, commonParameterModel.Ip,
                    commonParameterModel.Port, commonParameterModel.EquipmentId);

                string strData = string.Empty;
                if (resultModel.data != null)
                {
                    // 返回的数据
                    HxResponseBase resData = JsonConvert.DeserializeObject<HxResponseBase>(resultModel.data.json);
                    strData = JsonConvert.SerializeObject(resData.data);
                    //Dictionary<string, object> dicData = JsonConvert.DeserializeObject<Dictionary<string, object>>(strData);
                }

                // 同一设备的同一方法只保存一次结果:data为null时，存入empty
                socketParameterModel.DicReturn.Remove(commonParameterModel.SendData.method);
                socketParameterModel.DicReturn.Add(commonParameterModel.SendData.method, strData);
                #endregion

                LoggerSocketHelper.DebugLog("执行设备动作【成功】 " + JsonConvert.SerializeObject(resultModel));
                //new ExecutionLogBLL().UpdateExecutionLogEndTime(executionLogModel.Id);   //修改结束时间
                return resultModel;
            }

            #region Del
            //else if (resultModel != null && resultModel.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.AlarmInfo))
            //{
            //    #region 警告信息 把重试参数清空 
            //    ResultHandle.instructCommonMethodSendModelByError = new InstructCommonMethodSendModel();
            //    ResultHandle.instructCommonMethodSendModelByError.SendData = new HxSendBase();
            //    ResultHandle.instructCommonMethodSendModelByError.SendData.ExpOperationType = new ExpOperationTypeEnum();
            //    #endregion
            //    resultModel = GetReceiveResultInfo(resultModel, commonParameterModel, executionLogModel);
            //}
            #endregion

            else
            {
                try
                {
                    resultModel = StepResultByError(resultModel, commonParameterModel, true, isSimulator);
                }
                catch (Exception ex)
                {
                    LoggerSocketHelper.DebugLog($"发送指令【失败】{ex.Message}");
                }
            }
            return resultModel;
        }
        ///// <summary>
        ///// 获取返回信息结果
        ///// </summary>
        ///// <param name="resultModel"></param>
        ///// <param name="commonParameterModel"></param>
        ///// <param name="executionLogModel"></param>
        ///// <returns></returns>
        //public Result GetReceiveResultInfo(Result resultModel, InstructCommonMethodSendModel commonParameterModel, ExecutionLogModel executionLogModel)
        //{
        //    StepResultByError(resultModel, commonParameterModel, true, false);

        //    while (true)
        //    {
        //        var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(commonParameterModel.EquipmentType, commonParameterModel.Ip, commonParameterModel.Port, commonParameterModel.EquipmentId);
        //        if (socketParameterModel != null)
        //        {
        //            //把之前的缓存给删了，再重新去查询
        //            for (int i = 0; i < socketParameterModel.cacheReceiveData.Count; i++)
        //            {
        //                if (socketParameterModel.cacheReceiveData[i].CacheKey == commonParameterModel.SendData.workflow_id)
        //                {
        //                    socketParameterModel.cacheReceiveData.Remove(socketParameterModel.cacheReceiveData[i]);
        //                    break;
        //                }
        //            }

        //            resultModel = HxSockServiceExecute.GetReceiveResult(socketParameterModel, commonParameterModel.SendData.workflow_id);
        //            if (resultModel != null && resultModel.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
        //            {
        //                LoggerSocketHelper.DebugLog("执行设备动作【成功】 " + JsonConvert.SerializeObject(resultModel));
        //                //new ExecutionLogBLL().UpdateExecutionLogEndTime(executionLogModel.Id);   //修改结束时间
        //                break;
        //            }
        //            else if (resultModel != null && resultModel.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.AlarmInfo))
        //            {
        //                resultModel = GetReceiveResultInfo(resultModel, commonParameterModel, executionLogModel);
        //                if (resultModel != null && resultModel.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
        //                {
        //                    LoggerSocketHelper.DebugLog("执行设备动作【成功】 " + JsonConvert.SerializeObject(resultModel));
        //                    //new ExecutionLogBLL().UpdateExecutionLogEndTime(executionLogModel.Id);   //修改结束时间
        //                    break;
        //                }
        //            }
        //            else
        //            {
        //                try
        //                {
        //                    resultModel = StepResultByError(resultModel, commonParameterModel, true, true);
        //                    break;
        //                }
        //                catch (Exception ex)
        //                {
        //                    LoggerSocketHelper.DebugLog($"发送指令【失败】{ex.Message}");
        //                    break;
        //                }
        //            }
        //        }
        //    }
        //    return resultModel;
        //}

        /// <summary>
        /// 出错处理
        /// </summary>
        /// <param name="resultModel">结果信息</param>
        /// <param name="commonParameterModel">指令公共模型---发送</param>
        /// <param name="isUpdateExpState">是否更新实验状态和暂停实验进程;True是，False否</param>
        /// <param name="isSimulator"></param>
        /// <returns></returns>
        public Result StepResultByError(Result resultModel, InstructCommonMethodSendModel commonParameterModel, bool isUpdateExpState, bool isSimulator)
        {
            //这里要发送错误信息给用户界面
            LoggerSocketHelper.DebugLog($"执行设备动作【失败】,返回内容：{JsonConvert.SerializeObject(resultModel)}{",发送参数：" + JsonConvert.SerializeObject(commonParameterModel)}");

            var deviceconfigTypeModel = DeviceConfigTypeDB.GetInfodById(commonParameterModel.EquipmentType);

            #region 发送短信+语音播报 
            // wdy
            //string errorStr = "";
            //if (resultModel.ErrorMsg != null && !string.IsNullOrWhiteSpace(resultModel.ErrorMsg.Error_Code))
            //{
            //    errorStr = resultModel.ErrorMsg.Error_Code;

            //}
            //else
            //{
            //    errorStr = "设备名称：" + deviceconfigTypeModel.Name;
            //}
            //#region 发送短信
            //Task.Run(() =>
            //{
            //    new SmsSending.SmsSending().SendMsg(SharedServiceModel.ServiceConfigModel.SmsContent + "," + errorStr, SharedServiceModel.ServiceConfigModel.Phones, SharedServiceModel.ServiceConfigModel.SmsPort);
            //});
            //#endregion

            //#region 语音播报 
            //Task.Run(() =>
            //{
            //    CommonMethod.GetSpeechLib($"实验运行出错：{errorStr}");
            //});
            //#endregion
            #endregion

            #region 添加错误信息 
            var dealWithTypeAEnum = EnumManagement.GetEnumValue(DealWithType_Enum.DealWithTypeAEnum).ToString();
            var dealWithTypeBEnum = EnumManagement.GetEnumValue(DealWithType_Enum.DealWithTypeBEnum).ToString();
            var dealWithTypeCEnum = EnumManagement.GetEnumValue(DealWithType_Enum.DealWithTypeCEnum).ToString();

            ErrorStateDB.AddErrorState(new ErrorStateModel
            {
                Id = Guid.NewGuid().ToString(),
                ExpId = commonParameterModel.SendData.experiment_id,
                OperationState = (resultModel != null ? (resultModel.DealWithType == dealWithTypeAEnum || resultModel.DealWithType == dealWithTypeCEnum ? EnumManagement.GetEnumValue(OperationStateEnum.OperationStateBEnum) : EnumManagement.GetEnumValue(OperationStateEnum.OperationStateAEnum)) :
                EnumManagement.GetEnumValue(OperationStateEnum.OperationStateAEnum)),//EnumManagement.GetEnumValue(OperationStateEnum.OperationStateAEnum),
                DealWithType = (!string.IsNullOrWhiteSpace(resultModel.DealWithType) ? resultModel.DealWithType : dealWithTypeBEnum),
                DeviceId = commonParameterModel.DeviceId,
                JsonStr = resultModel != null ? (resultModel.data != null ? resultModel.data.json : "") : "",
                CommonParameterModelJsonStr = JsonConvert.SerializeObject(commonParameterModel),
                ExperimentName = Shared.Exp.ExperimentName,
                EquipmentName = deviceconfigTypeModel.Name,
                ErrorContent = resultModel.msg,
                ErrorCode = resultModel.ErrorMsg != null ? resultModel.ErrorMsg.Error_Code : "",// "错误CODE",
                CreateTime = DateTime.Now
            });
            #endregion

            #region 更新实验状态
            if (isUpdateExpState)
            {
                SocketInteriorService.Upt_DicTestState(commonParameterModel.SendData.experiment_id, ProcessTypeColorEnum_Equipment.RedColor, InfoTypeEnum_Enum.SuspendExperiment, ProcessLogicTypeEnum_Equipment.YesType);   //修改实验进程状态字典-暂停实验

                // wdy
                //int statusValue = EnumManagement.GetEnumValue(StatusEnum.StatusEEnum);
                //if (resultModel != null && resultModel.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Canceled))
                //{
                //    statusValue = EnumManagement.GetEnumValue(StatusEnum.StatusFEnum);
                //}
                //var updateExperimentStatus = new ExperimentBLL().UpdateExperimentStatus(new ExperimentModel { Id = commonParameterModel.SendData.experiment_id, Status = statusValue });

                //RunFlow.UpDateNodeDetailStatus(commonParameterModel.CurrentNode, commonParameterModel.FlowWrapRootNode, true);   //更新节点详细状态
            }
            #endregion

            #region 发送消息到客户端  

            #region Del
            //string instrunctionId = HxSockServiceExecute.InstrunctionId();
            //HxClientResponseObject hxClientResponseObject = new HxClientResponseObject();
            //hxClientResponseObject.EquipmentType = deviceconfigTypeModel.Name;
            //hxClientResponseObject.Ip = commonParameterModel.Ip;
            //hxClientResponseObject.Port = commonParameterModel.Port;
            //hxClientResponseObject.EquipmentId = commonParameterModel.EquipmentId;

            //hxClientResponseObject.ResponseBase = new HxResponseBase
            //{
            //    message_id = instrunctionId,
            //    message_type = 2,
            //    method = InfoTypeEnum_Enum.SendErrorClientData.ToString(),
            //    equipment_id = "",
            //    workflow_id = "workflow_id_" + instrunctionId + "_" + InfoTypeEnum_Enum.SendErrorClientData.ToString(),
            //    experiment_id = "experiment_id_" + instrunctionId,
            //    dataResult = new DataResult { ResultJson = JsonConvert.SerializeObject(commonParameterModel) },
            //    method_status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed),
            //    timestamp = DateTime.Now.ToString(),

            //    error = new ErrorResult
            //    {
            //        error_text = resultModel.msg + "实验错误",
            //        dealwithtype = (resultModel != null && !string.IsNullOrWhiteSpace(resultModel.DealWithType) ? resultModel.DealWithType : dealWithTypeBEnum),
            //        error_code = (resultModel != null ? (resultModel.ErrorMsg != null ? resultModel.ErrorMsg.Error_Code : "") : ""),
            //        troubleshoot = (resultModel != null ? (resultModel.ErrorMsg != null ? resultModel.ErrorMsg.Troubleshoot : 0) : 0)
            //    },
            //};
            //var sendData = SocketInteriorService.SendMessage(hxClientResponseObject);
            #endregion

            ErrorResult error = new ErrorResult();
            error.error_text = resultModel.msg;
            //error.dealwithtype = (resultModel != null && !string.IsNullOrWhiteSpace(resultModel.DealWithType) ? resultModel.DealWithType : dealWithTypeBEnum);
            error.error_code = (resultModel != null ? (resultModel.ErrorMsg != null ? resultModel.ErrorMsg.Error_Code : "") : "");
            error.troubleshoot = (resultModel != null ? (resultModel.ErrorMsg != null ? resultModel.ErrorMsg.Troubleshoot : 0) : 0);

            // 显示设置报错Dialog
            ErrorClientData errorData = new ErrorClientData() { ParameterModel = commonParameterModel, Error = error };
            EventBind.CallEvent(errorData);
            #endregion

            if (isUpdateExpState)
            {
                SocketInteriorService.dicManualResetEvent[commonParameterModel.SendData.experiment_id].WaitOne();   //出错等待
            }

            #region 出错后重试
            if (EventBind.OperMark == NodeOperationTypeEnum.Retry)
            {
                // 更新节点状态
                // wdy
                //RunFlow.UpDateNodeDetailStatus(commonParameterModel.CurrentNode, commonParameterModel.FlowWrapRootNode, false);
                string instrunctionId = HxSockServiceExecute.InstrunctionId();
                commonParameterModel.SendData.workflow_id = "workflow_id_" + commonParameterModel.SendData.experiment_id + "_" + instrunctionId;
                commonParameterModel.SendData.message_id = instrunctionId;

                LoggerSocketHelper.DebugLog("运行方法【StepResult】重试参数" + JsonConvert.SerializeObject(commonParameterModel));
                //if (frontEnd)
                //{
                resultModel = StepResult(commonParameterModel, isSimulator);
                //}
                //else
                //{
                //    //这里写前端处理逻辑 
                //    resultModel.ErrorMsg = new ErrorMsgModel { Error_Code = "", Error_Text = "", Troubleshoot = 0 };
                //    resultModel.DealWithType = resultModel.DealWithType;
                //    resultModel.msg = "重试成功";
                //    resultModel.status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed);
                //}
            }
            #endregion

            resultModel.OperMark= EventBind.OperMark;
            return resultModel;
        }
        #endregion

        #region 指令公共方法 
        /// <summary>
        /// 指令公共方法
        /// </summary>
        /// <param name="instructCommonMethodModel"></param>
        /// <param name="isSimulator"></param>
        /// <returns></returns>
        public static Result InstructCommonMethod(InstructCommonMethodSendModel instructCommonMethodModel, bool isSimulator)
        {
            Result resultModel = new Result();
            try
            {
                if (instructCommonMethodModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Socket))
                {
                    var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(instructCommonMethodModel.EquipmentType, instructCommonMethodModel.Ip, instructCommonMethodModel.Port, instructCommonMethodModel.EquipmentId);
                    if (socketParameterModel != null)
                    {
                        #region 虚拟连接
                        var virtualConnectionStateResult = HxSocketParameterService.GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime);
                        if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
                        {
                            return virtualConnectionStateResult;
                        }
                        else if (isSimulator)
                        {
                            return HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(),
                                new Result { status = StateEnum_Equipment.Completed, msg = "虚拟连接状态【成功】" });
                        }
                        #endregion

                        string sendJson = JsonConvert.SerializeObject(instructCommonMethodModel.SendData);
                        resultModel = HxSockServiceExecute.SendData(instructCommonMethodModel.EquipmentType, instructCommonMethodModel.Ip, instructCommonMethodModel.Port, instructCommonMethodModel.EquipmentId
                            , sendJson, instructCommonMethodModel.SendData.workflow_id);
                    }
                    else
                    {
                        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "socketParameterModel对像为空" });
                    }
                }

                #region Del
                //else if (instructCommonMethodModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Modbus))
                //{
                //    resultModel = SendDataToPlc(instructCommonMethodModel);   //向PLC读写数据
                //}
                //else if (instructCommonMethodModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SerialPort))
                //{
                //    SerialPortParameterModel serialPortsModel = new SerialPortParameterModel();
                //    serialPortsModel.PortName = instructCommonMethodModel.PortName;
                //    serialPortsModel.IsSendHex = instructCommonMethodModel.MethodParametersModel.IsHexSend == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    serialPortsModel.SendMsg = instructCommonMethodModel.SendData.parameters.ToString();
                //    serialPortsModel.VirtualConnectionState = instructCommonMethodModel.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionState_Enum.Virtually);
                //    serialPortsModel.IsRecHex = instructCommonMethodModel.MethodParametersModel.IsHexReceive == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    serialPortsModel.TimeOut = Sys.ConvertToTrimDouble(instructCommonMethodModel.MethodParametersModel.TimeOut);
                //    serialPortsModel.WaitTime = Sys.ConvertToTrimDouble(instructCommonMethodModel.MethodParametersModel.WaitTime);

                //    SerialPortResultModel result = new SerialPortResultModel();
                //    if (instructCommonMethodModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(DeviceConfigMethodType_Enum.TypeBEnum).ToString())
                //    {
                //        result = SerialPorts.SendSerialPort(serialPortsModel);
                //        if (result != null && result.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //        {
                //            if (instructCommonMethodModel.MethodParametersModel.IsResult == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum))
                //            {
                //                result = SerialPorts.ReceivedSerialPort(serialPortsModel);
                //            }
                //        }
                //    }
                //    else if (instructCommonMethodModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(DeviceConfigMethodType_Enum.TypeAEnum).ToString())
                //    {
                //        result = SerialPorts.ReceivedSerialPort(serialPortsModel);
                //    }

                //    if (result != null && result.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result
                //        {
                //            status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed),
                //            msg = "执行成功",
                //            data = new Data { json = result.data?.json }
                //        });
                //    }
                //    else
                //    {
                //        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Failed), msg = result.msg });
                //    }
                //}
                //else if (instructCommonMethodModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketUDP))
                //{
                //    SocketUdpNonstandardParameterModel socketUdpNonstandardModel = new SocketUdpNonstandardParameterModel();
                //    socketUdpNonstandardModel.EquipmentType = instructCommonMethodModel.EquipmentType;
                //    socketUdpNonstandardModel.EquipmentId = instructCommonMethodModel.EquipmentId;
                //    socketUdpNonstandardModel.Ip = instructCommonMethodModel.Ip;
                //    socketUdpNonstandardModel.Port = instructCommonMethodModel.Port;
                //    socketUdpNonstandardModel.VirtualConnectionState = instructCommonMethodModel.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionState_Enum.Virtually);
                //    socketUdpNonstandardModel.IsHexSend = instructCommonMethodModel.MethodParametersModel.IsHexSend == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    socketUdpNonstandardModel.IsHexReceive = instructCommonMethodModel.MethodParametersModel.IsHexReceive == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    socketUdpNonstandardModel.IsResult = instructCommonMethodModel.MethodParametersModel.IsResult == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    socketUdpNonstandardModel.TimeOut = Sys.ConvertToTrimDouble(instructCommonMethodModel.MethodParametersModel.TimeOut);
                //    socketUdpNonstandardModel.WaitTime = Sys.ConvertToTrimDouble(instructCommonMethodModel.MethodParametersModel.WaitTime);

                //    SocketUdpNonstandardResultModel socketUdpNonstandardResultModel = new SocketUdpNonstandardResultModel();
                //    if (instructCommonMethodModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(DeviceConfigMethodType_Enum.TypeBEnum).ToString())
                //    {
                //        socketUdpNonstandardResultModel = SocketUdpNonstandardClient.SendData(socketUdpNonstandardModel, instructCommonMethodModel.SendData.parameters.ToString());
                //    }
                //    else if (instructCommonMethodModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(DeviceConfigMethodType_Enum.TypeAEnum).ToString())
                //    {
                //        socketUdpNonstandardResultModel = SocketUdpNonstandardClient.GetReceiveResult(socketUdpNonstandardModel);
                //    }

                //    if (socketUdpNonstandardResultModel != null && socketUdpNonstandardResultModel.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result
                //        {
                //            status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed),
                //            msg = "执行成功",
                //            data = new Data { json = socketUdpNonstandardResultModel.Data?.json }
                //        });
                //    }
                //    else
                //    {
                //        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Failed), msg = socketUdpNonstandardResultModel.msg });
                //    }
                //}
                //else if (instructCommonMethodModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketNonstandard))
                //{
                //    SocketNonstandardParameterModel socketNonstandardModel = new SocketNonstandardParameterModel();
                //    socketNonstandardModel.EquipmentType = instructCommonMethodModel.EquipmentType;
                //    socketNonstandardModel.EquipmentId = instructCommonMethodModel.EquipmentId;
                //    socketNonstandardModel.Ip = instructCommonMethodModel.Ip;
                //    socketNonstandardModel.Port = instructCommonMethodModel.Port;
                //    socketNonstandardModel.VirtualConnectionState = instructCommonMethodModel.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionState_Enum.Virtually);
                //    socketNonstandardModel.IsHexSend = instructCommonMethodModel.MethodParametersModel.IsHexSend == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    socketNonstandardModel.IsHexReceive = instructCommonMethodModel.MethodParametersModel.IsHexReceive == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    socketNonstandardModel.IsResult = instructCommonMethodModel.MethodParametersModel.IsResult == EnumManagement.GetEnumValue(IsYesOrNo_Enum.TypeBEnum);
                //    socketNonstandardModel.TimeOut = Sys.ConvertToTrimDouble(instructCommonMethodModel.MethodParametersModel.TimeOut);
                //    socketNonstandardModel.WaitTime = Sys.ConvertToTrimDouble(instructCommonMethodModel.MethodParametersModel.WaitTime);

                //    SocketNonstandardResultModel socketNonstandardResultModel = new SocketNonstandardResultModel();
                //    if (instructCommonMethodModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(DeviceConfigMethodType_Enum.TypeBEnum).ToString())
                //    {
                //        socketNonstandardResultModel = SocketNonstandardClient.SendData(socketNonstandardModel, instructCommonMethodModel.SendData.parameters.ToString());
                //    }
                //    else if (instructCommonMethodModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(DeviceConfigMethodType_Enum.TypeAEnum).ToString())
                //    {
                //        socketNonstandardResultModel = SocketNonstandardClient.GetReceiveResult(socketNonstandardModel);
                //    }

                //    if (socketNonstandardResultModel != null && socketNonstandardResultModel.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result
                //        {
                //            status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed),
                //            msg = "执行成功",
                //            data = new Data { json = socketNonstandardResultModel.Data?.json }
                //        });
                //    }
                //    else
                //    {
                //        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Failed), msg = socketNonstandardResultModel.msg });
                //    }
                //}

                #endregion
            }
            catch (Exception ex)
            {
                resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = ex.Message });
            }
            return resultModel;
        }
        #endregion
    }
}