using DataEntity.Device;
using DataEntity.Share;
using HxEnum;
using HxSocket;
using HxSocketImplement.Sockets;
using HxSocketImplement.Sockets.HxService;
//using MySqlX.XDevAPI.Common;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Xml;
using XCommon;
using XCommon.Log;
using XCore;
using XHandler.Controls.Run.Com;
using XHandler.View;
using XImagingXhandler.XDAL;
using static HxEnum.OperationTypeEnum;
using static HxEnum.StateEnum;

namespace XHandler.Controls
{
    /// <summary>
    /// 第三方设备控制逻辑类
    /// </summary>
    public class ThirdPartControl
    {
        #region 变量
        // 系统语言
        private string m_currentCulture = string.Empty;

        #region BLL
        private ThirdPartBll m_thirdPartBll = new ThirdPartBll();
        #endregion

        // 运行界面
        public static RunWnd LaunchView = null;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public ThirdPartControl()
        {
            m_currentCulture = Shared.SoftwareInformation.currentculture;
        }

        #region 执行第三方设备方法
        /// <summary>
        /// 执行第三方设备方法
        /// </summary>
        /// <param name="xmlEnv"></param>
        /// <param name="methodNode"></param>
        /// <param name="isSimulator"></param>
        /// <returns></returns>
        public bool ExecuteCoatingTransfer(XmlNode xmlEnv, XmlNode methodNode, bool isSimulator)
        {
            bool bResult = false;
            string strMethodName = methodNode.SelectSingleNode("name").InnerText;
            string log = string.Empty;

            #region 任务被取消
            if (LaunchView._cancelSource.IsCancellationRequested)
            {
                bResult = false;
                return bResult;
            }
            #endregion

            try
            {
                #region 数据准备
                MethodThirdPart thirdPartData = m_thirdPartBll.GenerateMethodThirdPartDataByXmlNode(methodNode);
                #endregion

                #region 数据检查
                if (thirdPartData.device == null)
                {
                    LaunchView.AddLogs(string.Format("【{0}】> Xhandler: 【{1}】{2}", DateTime.Now.ToString("HH:mm:ss:fff"), strMethodName, Properties.ThirdPartResource.strSendMethodError.ToString()));
                    LoggerHelper.ErrorLog(string.Format("设备不存在！ deviceId = {0}", thirdPartData.deviceValue));
                    return bResult;
                }

                if (thirdPartData.deviceMethod == null)
                {
                    LaunchView.AddLogs(string.Format("【{0}】> Xhandler: 【{1}】{2}", DateTime.Now.ToString("HH:mm:ss:fff"), strMethodName, Properties.ThirdPartResource.strSendMethodError.ToString()));
                    LoggerHelper.ErrorLog(string.Format("设备方法不存在！ deviceMethodId = {0}", thirdPartData.deviceMethodValue));
                    return bResult;
                }
                #endregion

                #region 运行日志
                if (m_currentCulture.Equals("zh-CN"))
                {
                    log = string.Format("【{0}】> Xhandler: 【{1}({2})】{3}", DateTime.Now.ToString("HH:mm:ss:fff"), strMethodName, thirdPartData.deviceMethod.ParameterName, Properties.MachineRunResource.strStart.ToString());
                    LaunchView.AddLogs(log);
                }
                else
                {
                    log = string.Format("【{0}】> Xhandler: 【{1}({2})】{3}", DateTime.Now.ToString("HH:mm:ss:fff"), strMethodName, thirdPartData.deviceMethod.ParameterName, "start");
                    LaunchView.AddLogs(log);
                }
                #endregion

                #region 化学工作站 判断离心机开关门前是否机械臂在安全位置
                if (thirdPartData.deviceMethod != null)
                {
                    if ((thirdPartData.deviceMethod.ParameterName.Equals("OpenDoor") || thirdPartData.deviceMethod.ParameterName.Equals("CloseDoor"))&&Shared.SoftwareInformation.software_device_number.Equals("HXFX"))
                    {
                        //强制控制机械臂到安全位
                        Dictionary<string, object> dicParamsRobot = new Dictionary<string, object>();
                        string xmlText = "<?xml version=\"1.0\" encoding=\"utf-8\"?><root><method id=\"135\"><isrun></isrun><status>enable</status><name>机械臂</name><label>机械臂</label>\r\n<strIndex>14-17</strIndex><isThirdPart>True</isThirdPart><device><id>d40b4dfc-6ae9-402f-8946-2fe5ef908b2d</id>\r\n<name>机械臂</name><communicateType>0</communicateType></device><method><id>83c2225e-9942-46a5-8b80-b661b55d131a</id>\r\n<name>Pick</name></method><paramtersSocket><paramtersGroup><id>b7ab14c7-89a4-436a-a999-550432ec5ce3</id><name>target</name>\r\n<value>SAFE_01</value></paramtersGroup></paramtersSocket></method></root>";
                        XmlDocument xmldoc = new XmlDocument();
                        xmldoc.LoadXml(xmlText);
                        XmlNode methodNodeRobot = xmldoc.SelectSingleNode("root/method");
                        MethodThirdPart thirdPartDataRobot = m_thirdPartBll.GenerateMethodThirdPartDataByXmlNode(methodNodeRobot);
                        GetDeviceInParams(thirdPartDataRobot, ref dicParamsRobot);
                        InstructCommonMethodSendModel sendModelRobot = new InstructCommonMethodSendModel();
                        sendModelRobot.DeviceId = thirdPartDataRobot.device.Id;
                        sendModelRobot.DeviceName = thirdPartDataRobot.device.Name;
                        sendModelRobot.EquipmentType = thirdPartDataRobot.device.Type;
                        sendModelRobot.Ip = thirdPartDataRobot.device.Ip;
                        sendModelRobot.Port = Convert.ToInt32(thirdPartDataRobot.device.Port);
                        sendModelRobot.EquipmentId = thirdPartDataRobot.device.EquipmentId;
                        sendModelRobot.VirtualConnectionState = thirdPartDataRobot.device.VirtualConnectionState;
                        sendModelRobot.CommunicateType = thirdPartDataRobot.device.CommunicateType;
                        sendModelRobot.SendData = new HxSendBase { experiment_id = Shared.Exp.ExperimentId, parameters = dicParamsRobot, method = thirdPartDataRobot.deviceMethod.ParameterName };

                        InstructCommonMethodSendModel instructCommonMethodSendModelRobot = HxSocketParameterService.GetInstructCommonMethodSendModel(sendModelRobot);

                        // 给设备节点发送指令
                        LockDeviceAndSendMsg(instructCommonMethodSendModelRobot, isSimulator);
                    }
                }
                #endregion

                // 指令发送之前
                BeforeSend(thirdPartData);

                #region Send
                LoggerHelper.DebugLog(string.Format("deviceId = {0}, methodId = {1} 执行开始.", thirdPartData.device.Id, thirdPartData.deviceMethod.Id));

                // 获取指令发送参数
                Dictionary<string, object> dicParams = new Dictionary<string, object>();
                if (!GetDeviceInParams(thirdPartData, ref dicParams))
                {
                    LaunchView.AddLogs(string.Format("【{0}】> Xhandler: 【{1}】{2}", DateTime.Now.ToString("HH:mm:ss:fff"), strMethodName, Properties.ThirdPartResource.strSendMethodError.ToString()));
                    return false;
                }

                #region 作成发送参数
                InstructCommonMethodSendModel sendModel = new InstructCommonMethodSendModel();
                sendModel.DeviceId = thirdPartData.device.Id;
                sendModel.DeviceName = thirdPartData.device.Name;
                sendModel.EquipmentType = thirdPartData.device.Type;
                sendModel.Ip = thirdPartData.device.Ip;
                sendModel.Port = Convert.ToInt32(thirdPartData.device.Port);
                sendModel.EquipmentId = thirdPartData.device.EquipmentId;
                sendModel.VirtualConnectionState = thirdPartData.device.VirtualConnectionState;
                sendModel.CommunicateType = thirdPartData.device.CommunicateType;
                sendModel.SendData = new HxSendBase { experiment_id = Shared.Exp.ExperimentId, parameters = dicParams, method = thirdPartData.deviceMethod.ParameterName };

                InstructCommonMethodSendModel instructCommonMethodSendModel = HxSocketParameterService.GetInstructCommonMethodSendModel(sendModel);
                #endregion

                // 给设备节点发送指令
                Result deviceResult = LockDeviceAndSendMsg(instructCommonMethodSendModel, isSimulator);
                #endregion

                // 指令发送之后
                AfterSend(thirdPartData);

                if (deviceResult.status != StateEnum_Equipment.Completed)
                {
                    bResult = deviceResult.OperMark == NodeOperationTypeEnum.Continue ? true : false;
                }
                else
                {
                    bResult = true;
                }
            }
            catch (Exception ex)
            {
                LoggerHelper.ErrorLog("ERROR:", ex);

                #region Exception
                LaunchView.AddLogs("【" + DateTime.Now.ToString("HH:mm:ss:fff") + "】>Xhandler: 【" + strMethodName + "】error:source:" + ex.Source + ";error:" + ex.Message + ";");
                bResult = false;
                #endregion
            }

            return bResult;
        }
        #endregion

        #region 指令发送之前
        /// <summary>
        /// 指令发送之前
        /// </summary>
        /// <param name="thirdPartData"></param>
        private void BeforeSend(MethodThirdPart thirdPartData)
        {
            LoggerHelper.DebugLog($"[BeforeSend]: start. methodId = {thirdPartData.deviceMethod.Id}");

            try
            {

            }
            finally
            {
                LoggerHelper.DebugLog($"[BeforeSend]: end. methodId = {thirdPartData.deviceMethod.Id}");
            }
        }
        #endregion

        #region 指令发送之后
        /// <summary>
        /// 指令发送之后
        /// </summary>
        /// <param name="thirdPartData"></param>
        private void AfterSend(MethodThirdPart thirdPartData)
        {
            LoggerHelper.DebugLog($"[AfterSend]: start. methodId = {thirdPartData.deviceMethod.Id}");

            try
            {

            }
            finally
            {
                LoggerHelper.DebugLog($"[AfterSend]: end. methodId = {thirdPartData.deviceMethod.Id}");
            }
        }
        #endregion

        #region 获取发送参数
        /// <summary>
        /// 获取发送参数
        /// </summary>
        /// <param name="thirdPartData"></param>
        /// <param name="dicParams"></param>
        /// <returns></returns>
        public bool GetDeviceInParams(MethodThirdPart thirdPartData, ref Dictionary<string, object> dicParams)
        {
            #region Socket-TCP标准协议
            if (thirdPartData.device.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Socket))
            {
                var selSendParameters = thirdPartData.methodParametersData.Where(it=>it.Type == EnumManagement.GetEnumValue(ParameterTypeEnum.Send));
                if (selSendParameters.Any())
                {
                    List<DeviceConfigMethodParametersModel> parametersData = selSendParameters.ToList();
                    foreach (var inParamItem in parametersData)
                    {
                        // 获取变量值
                        string varValue = inParamItem.Value;

                        //如果值是变量，取出变量的值
                        string globalVariableValue = "";
                        globalVariableValue = ControlCom.SearchValueOfGlobalVariable(LaunchView, varValue);
                        if (!string.IsNullOrEmpty(globalVariableValue))
                        {
                            varValue = globalVariableValue;
                        }

                        #region 字符串类型
                        if (inParamItem.DataType == EnumManagement.GetEnumValue(ParameterDataTypeEnum.Varchar))
                        {
                            dicParams.Add(inParamItem.ParameterName, varValue);
                        }
                        #endregion

                        #region 数字类型
                        else if (inParamItem.DataType == EnumManagement.GetEnumValue(ParameterDataTypeEnum.Int))
                        {
                            int nVarValue = 0;
                            // 转成数字类型
                            if (!ComUtility.ParseToInt(varValue, out nVarValue))
                            {
                                return false;
                            }

                            dicParams.Add(inParamItem.ParameterName, nVarValue);
                        }
                        #endregion

                        #region Json类型
                        else if (inParamItem.DataType == EnumManagement.GetEnumValue(ParameterDataTypeEnum.JSON))
                        {
                            if (!string.IsNullOrEmpty(varValue))
                            {
                                dicParams = JsonConvert.DeserializeObject<Dictionary<string, object>>(varValue);
                            }
                            break;
                        }
                        #endregion

                        #region bool类型
                        else if (inParamItem.DataType == EnumManagement.GetEnumValue(ParameterDataTypeEnum.Bool))
                        {
                            bool bVarValue = false;
                            // 转成数字类型
                            if (!ComUtility.ParseToBool(varValue, ref bVarValue))
                            {
                                LoggerHelper.ErrorLog(string.Format("ParseToInt,value = {0}, 参数不是bool！！！", varValue));
                                return false;
                            }

                            dicParams.Add(inParamItem.ParameterName, bVarValue);
                        }
                        #endregion
                    }
                }
            }
            #endregion

            return true;
        }
        #endregion

        #region 给设备节点发送指令
        /// <summary>
        /// 给设备节点发送指令
        /// </summary>
        /// <param name="commonMethodSendModel"></param>
        /// <param name="isSimulator"></param>
        /// <returns></returns>
        private Result LockDeviceAndSendMsg(InstructCommonMethodSendModel commonMethodSendModel, bool isSimulator)
        {
            return new ResultHandle().StepResult(commonMethodSendModel, isSimulator);
        }
        #endregion


    }
}