using WCS.DeviceProtocol;
using WCS.Repository;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using WCS.Common;
using WCS.Entitys;
using WCS.Model;
using WCS.Services;
using HslCommunication.Profinet.Siemens;
using HslCommunication;
using WCS.Utils;
using IMCS.CCS.Services;
using StackExchange.Redis;
using WCS.Models;
using fanuc采集;
using HeidenhainDNCLib;
using IMCS.Device;
using HttpServer;
using YG.Device;
using static HttpServer.ConDevice2;
using FANUC;
using SinumerikOpcUaAPI;
using static SinumerikOpcUaAPI.Server;
using System.Net.NetworkInformation;
using System.Reflection.Emit;
using Opc.Ua;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using static System.Runtime.InteropServices.JavaScript.JSType;
using WinSCP;
using System.Runtime.InteropServices;
namespace WCS.Service.Impl
{
    public class TaskService : ITaskService
    {
        private readonly IDeviceRepository deviceRepository;
        private readonly IWcsActionService wcsActionService;
        private readonly IWcsActionAddressService wcsActionAddressService;
        private readonly ITaskCallbackService taskCallbackService;

        private readonly IConnectionMultiplexer _redis;
        private readonly IDeviceService _deviceService;
        private readonly IWcsTagValueService _wcsTagValueService;
        private readonly IApiRequestService _apiRequestService;
        private string wcs_callback_url;

        private string wcs_redis_key = "WCS:";

        private string LOG_TITLE_S7 = "S7采集";

        private string LOG_TITLE_CALLBACK = "回调任务";

        private static readonly string FANUC = "fanuc";
        private static readonly string OPCUA = "opcua";
        private static readonly string HEIDENHAIN = "heidenhain";
        public Dictionary<string, DNC_STATE> deviceList { get; set; } = new Dictionary<string, DNC_STATE>();
        public Dictionary<string, JHMachineInProcess> machineList { get; set; } = new Dictionary<string, JHMachineInProcess>();
        public string UPLOAD_NC_PATH = "Sinumerik/FileSystem/NCExtend/wks.dir/nc_program/";
        private string RemotePath = "TNC:\\nc_prog\\ATUO";//ConfigurationManager.AppSettings["RemotePath"]; 
        private uint currentToolArea = 1;
        private DNC_STATE m_ControlState;
        private int iChannel = 0;
        // 作为长连接进行bean的存储， key使用ip，
        Dictionary<string, Server> opcServerMap = new Dictionary<string, Server>();

        public IConfiguration Configuration { get; }
        public TaskService(IDeviceRepository deviceRepository,
                            IWcsActionService wcsActionService,
                            IWcsTagValueService wcsTagValueService,
                            IWcsActionAddressService wcsActionAddressService,
                            ITaskCallbackService taskCallbackService,
                            IConnectionMultiplexer redisService,
                            IDeviceService deviceService,
                            IApiRequestService _apiRequestService,
                            IConfiguration configuration
                            )
        {
            this.deviceRepository = deviceRepository;
            this.wcsActionService = wcsActionService;
            this.wcsActionAddressService = wcsActionAddressService;
            this.taskCallbackService = taskCallbackService;
            this._redis = redisService;
            this._deviceService = deviceService;
            this._wcsTagValueService = wcsTagValueService;
            this._apiRequestService = _apiRequestService;
            wcs_callback_url = Configuration.GetConnectionString("wcsCallbackUrl");
        }




        public async Task<ResponseData> ExcuteTask(RequestData<LocationData> data)
        {
            ResponseData responseData = new ResponseData();
            try
            {
                List<WcsDevice> devices = deviceRepository.GetDeviceList();

                WcsDevice? wcsDevice = devices.FirstOrDefault(x => x.Ip == data.ip);
                //WcsDevice device = devices.Where(x => x.Ip == data.url && x.Port == data.port).FirstOrDefault();


                if (wcsDevice == null)
                {
                    Log.Instance.WriteLogAdd("设备已离线===>>" + JsonConvert.SerializeObject(data));
                    responseData.IsSuccess = false;
                    return responseData;
                }

                WcsAction action = new WcsAction();
                action.Ip = data.ip;
                action.OperateType = data.data.operateType.ToString();
                WcsAction? actionInfo = wcsActionService.GetList(action).FirstOrDefault();

                if (actionInfo == null)
                {
                    Log.Instance.WriteLogAdd(data.data.operateType.ToString() + "异常===>>" + "找不到对应实例" + JsonConvert.SerializeObject(data),
                    EnumHelper.GetEnumDescription<WcsActionType>(data.data.operateType));
                    responseData.IsSuccess = false;
                    return responseData;
                }
                WcsDevice? plcDevice = devices.FirstOrDefault(x => x.ProtocolType == "S7_1500");

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(plcDevice.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(data.data.operateType.ToString() + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(data),
                    EnumHelper.GetEnumDescription<WcsActionType>(data.data.operateType));
                    responseData.IsSuccess = false;
                    return responseData;
                }
                WcsActionAddress actionAddressQuery = new WcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                /*actionAddressQuery.Type = ActionAddressTypeEnum.WRITE.ToString();*/
                /*actionAddressQuery.Sort = data.data.type;*/
                List<WcsActionAddress> WcsActionAddresses = wcsActionAddressService.GetList(actionAddressQuery);
                WcsActionAddress? wcsActionAddress = WcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString() && o.Sort == data.data.type).FirstOrDefault();
                if (WcsActionAddresses != null && data.data.type == 0)
                {
                    OperateResult operateResult = s7.Write(wcsActionAddress.Address, Convert.ToInt16(data.data.startPosition));
                }
                else if (WcsActionAddresses != null && data.data.type == 1)
                {
                    s7.Write(wcsActionAddress.Address, Convert.ToInt16(data.data.endPosition));
                }
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(data.url, data.data.operateType.ToString(),
                     EnumHelper.GetEnumDescription<WcsActionType>(data.data.operateType), data.taskId, data.taskNodeId);
                taskCallbackData = setCallBackValue(WcsActionAddresses, taskCallbackData, data);

                await taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetEnumDescription<WcsActionType>(data.data.operateType) + "成功===>>" + JsonConvert.SerializeObject(data)
                   , EnumHelper.GetEnumDescription<WcsActionType>(data.data.operateType));

                return responseData;


            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(data.data.operateType + "异常===>>" + ex.Message + JsonConvert.SerializeObject(data),
                   EnumHelper.GetEnumDescription<WcsActionType>(data.data.operateType));
                responseData.IsSuccess = false;
                responseData.Msg = ex.Message;
                return responseData;
            }


        }



        /// <summary>
        /// 采集数据S7
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DataCollectS7Job()
        {
            try
            {
                List<WcsDevice> deviceList = await getDeviceList();
                deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString()) && x.State).ToList();
                foreach (WcsDevice device in deviceList)
                {
                    List<WcsTagValue> tagValues = new List<WcsTagValue>();
                    string redis_key = "WCS:" + device.Ip + ":" + device.ProtocolType;
                    var data = await _redis.GetDatabase().StringGetAsync(redis_key);
                    if (data.IsNullOrEmpty)
                    {
                        WcsTagValue tagQuery = new WcsTagValue();
                        tagQuery.ProtocolType = device.ProtocolType;
                        tagQuery.Ip = device.Ip;
                        tagValues = _wcsTagValueService.GetList(tagQuery);
                        //首次设置redis
                        if (tagValues != null && tagValues.Count > 0)
                        {
                            await _redis.GetDatabase().StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
                        }
                    }
                    else
                    {
                        tagValues = JsonConvert.DeserializeObject<List<WcsTagValue>>(data);
                    }

                    if (tagValues != null && tagValues.Count > 0)
                    {
                        tagValues = JsonConvert.DeserializeObject<List<WcsTagValue>>(data);
                        List<WcsTagValue> changTagValues = new List<WcsTagValue>();


                        //Plc s7 = DevicePlcS7.S7(device.ServerUrl, ProtocalTypeEnum.S7_1500.ToString());
                        SiemensS7Net s7 = DevicePlcS7.SiemensS7(device.Ip);
                        OperateResult ConnectionResult = s7.ConnectServer();
                        if (!ConnectionResult.IsSuccess)
                        {
                            device.State = false;
                            await _deviceService.UpdateDevice(device);
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd("S7采集异常,plc连不上==>" + device.Ip, LOG_TITLE_S7);
                            return "采集失败，plc连不上";
                        }
                        else
                        {
                            foreach (WcsTagValue tagValueData in tagValues)
                            {
                                string operateResult = "";
                                if (tagValueData.Type.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                                {
                                    operateResult = s7.ReadBool(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                                {
                                    operateResult = s7.ReadInt16(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.String.ToString()))
                                {
                                    operateResult = s7.ReadString(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.Array.ToString()))
                                {
                                    operateResult = ToolUtils.ReturnStringByBytes(s7.Read(tagValueData.Address, 40).Content);
                                }

                                if (!string.IsNullOrEmpty(operateResult) && tagValueData.TagValue != operateResult)
                                {
                                    tagValueData.TagValue = operateResult.ToString();
                                    tagValueData.UpdateTime = DateTime.Now;
                                    changTagValues.Add(tagValueData);
                                    Log.Instance.WriteLogAdd("S7采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_S7);
                                    //有变化更新数据库
                                    await _wcsTagValueService.Update(tagValueData);
                                }
                                Thread.Sleep(50);
                            }
                            s7.ConnectClose();
                            //值有变化，重新设置一次redis
                            if (changTagValues != null && changTagValues.Count > 0)
                            {
                                await _redis.GetDatabase().StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
                            }
                            //存储采集数据
                            CollectDataLog.Instance.WriteLogAdd(data, LOG_TITLE_S7);
                        }

                    }
                }
                return "S7采集成功";
            }
            catch (Exception ex)
            {
                string errorMessage = $"S7采集异常===>> {ex.Message}\nStack Trace: {ex.StackTrace}";
                Log.Instance.WriteLogAdd(errorMessage, LOG_TITLE_S7);
                return "S7采集失败";
            }
        }



        /// <summary>
        /// 获取redis 设备在线列表
        /// </summary>
        /// <param name="strData"></param>
        /// <returns></returns>
        private async Task<List<WcsDevice>> getDeviceList()
        {
            List<WcsDevice> deviceList = new List<WcsDevice>();
            var deviceListData = await _redis.GetDatabase().StringGetAsync(wcs_redis_key + RedisKeyEnum.DeviceList);
            if (deviceListData.IsNullOrEmpty || deviceListData.Length() == 0)
            {
                deviceList = _deviceService.GetDeviceList();
                await _redis.GetDatabase().StringSetAsync(wcs_redis_key + RedisKeyEnum.DeviceList, JsonConvert.SerializeObject(deviceList));
            }
            else
            {
                deviceList = JsonConvert.DeserializeObject<List<WcsDevice>>(deviceListData);
            }
            return deviceList;
        }

        public string Test()
        {
            Console.WriteLine(DateTime.Now);

            return "111";
        }

        /// <summary>
        /// 柔性产线,伺服等取和放回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob2()
        {
            List<TaskCallback> taskList = new List<TaskCallback>();
            var taskCallbackListData = await _redis.GetDatabase().StringGetAsync(wcs_redis_key + RedisKeyEnum.CallbackTaskList);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                taskList = await taskCallbackService.GetAllList();
            }
            else
            {
                taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
            }
            //在线设备 
            List<WcsDevice> deviceList = await getDeviceList();

            //taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.RobotAction.ToString())).ToList();
            taskList = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).ToList();
            //TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault() ; 
            if (taskList == null || taskList.Count == 0)
            {
                return "无回调任务";
            }
            string message = "";
            try
            {
                foreach (TaskCallback task in taskList)
                {
                    WcsTagValue tagValueQuery = new WcsTagValue();
                    tagValueQuery.Ip = task.IP;
                    tagValueQuery.Address = task.Address;
                    List<WcsTagValue> tagValues = _wcsTagValueService.GetList(tagValueQuery).ToList();
                    WcsTagValue callBacktagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();

                    //if ((callBacktagValue != null && callBacktagValue.TagValue == task.CallbackValue))
                    if (callBacktagValue != null)
                    {
                        CallBackRequestData requestData = new CallBackRequestData();
                        requestData.taskId = long.Parse(task.TaskId);
                        requestData.taskNodeId = long.Parse(task.TaskNodeId);
                        requestData.TagValue = callBacktagValue.TagValue;
                        var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, wcs_callback_url, requestData, null);
                        ResponseWCSCallbackData responseECSCallback = JsonConvert.DeserializeObject<ResponseWCSCallbackData>(result.Message);
                        if (result.IsSuccess && responseECSCallback.code == 0)
                        {
                            //取 放动作结果 如果完成修改状态，否则
                            if (callBacktagValue.TagValue == "3")
                            {
                                task.State = false;
                                task.UpdateTime = DateTime.Now;
                                await taskCallbackService.CreateOrUpdateAndCache(task);
                                message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
                                Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
                            }
                            else
                            {
                                message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ",返回结果:" + callBacktagValue.TagValue + ";";
                                Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
                            }

                        }
                        else
                        {
                            //ecs返回-5 任务作废
                            if (result.IsSuccess && responseECSCallback.code == -5)
                            {
                                task.State = false;
                                task.UpdateTime = DateTime.Now;
                                task.Description = "ecs返回-5,回调任务作废";
                                await taskCallbackService.CreateOrUpdateAndCache(task);
                                message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
                                Log.Instance.WriteLogAdd("回调异常，请求接口失败,wcs通知任务作废==>" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);

                            }
                            else
                            {
                                message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
                                Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
                            }

                        }

                    }
                    //回调检测到失败，回调通知ecs
                    /*if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
                    {
                        bool failFalg = false;
                        if (!string.IsNullOrEmpty(task.FailAddress))
                        {
                            List<WcsTagValue> FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress && o.TagValue == task.CallbackFailValue).ToList();

                            if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
                            {
                                failFalg = true;
                            }
                        }
                        if (!string.IsNullOrEmpty(task.FailAddress2))
                        {
                            List<WcsTagValue> FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress2 && o.TagValue == task.CallbackFailValue2).ToList();

                            if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
                            {
                                failFalg = true;
                            }
                        }
                        if (!string.IsNullOrEmpty(task.FailAddress3))
                        {
                            List<WcsTagValue> FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress3 && o.TagValue == task.CallbackFailValue3).ToList();

                            if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
                            {
                                failFalg = true;
                            }
                        }
                        if (failFalg)
                        {
                            CallBackRequestData requestData = new CallBackRequestData();
                            requestData.taskId = long.Parse(task.TaskId);
                            requestData.taskNodeId = long.Parse(task.TaskNodeId);
                            requestData.code = "0";
                            requestData.msg = "操作失败";
                            var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, wcs_callback_url, requestData, null);
                            if (result.IsSuccess)
                            {
                                task.State = false;
                                task.UpdateTime = DateTime.Now;
                                await taskCallbackService.CreateOrUpdateAndCache(task);
                                message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + message + ",请求结果:" + result.Message + ";";
                                Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
                            }
                            else
                            {
                                message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
                                Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
                            }
                        }
                    }*/
                    Thread.Sleep(1000);
                }
                return string.IsNullOrEmpty(message) ? "无回调任务" : message;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
                return "回调异常" + ex.Message;
            }
        }


        //设置回调值
        private TaskCallback setCallBackValue(List<WcsActionAddress> CcsActionAddresses, TaskCallback taskCallbackData, RequestData<LocationData> data)
        {
            WcsActionAddress actionAddress = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK.ToString() && o.Sort == data.data.type).FirstOrDefault();
            if (actionAddress != null)
            {
                taskCallbackData.Address = actionAddress.Address;
                taskCallbackData.CallbackValue = actionAddress.Value;
            }
            /*List<WcsActionAddress> CcsActionAddressCallBackFails = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK_FAIL.ToString()).ToList();
            List<WcsActionAddress> CcsActionAddressCallBackResets = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.RESET.ToString()).ToList();
            foreach (WcsActionAddress actionAddress in CcsActionAddressCallBacks)
            {
                if (actionAddress.Sort == data.data.type)
                {
                    taskCallbackData.Address = actionAddress.Address;
                    taskCallbackData.CallbackValue = actionAddress.Value;
                }
                
            }
            foreach (WcsActionAddress actionAddress in CcsActionAddressCallBackFails)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.FailAddress = actionAddress.Address;
                    taskCallbackData.CallbackFailValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.FailAddress2 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.FailAddress3 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue3 = actionAddress.Value;
                }
            }
            foreach (WcsActionAddress actionAddress in CcsActionAddressCallBackResets)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.SuccessResetAddress = actionAddress.Address;
                    taskCallbackData.SuccessResetValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.SuccessResetAddress2 = actionAddress.Address;
                    taskCallbackData.SuccessResetValue2 = actionAddress.Value;
                }

            }
            return taskCallbackData;*/
            return taskCallbackData;
        }

        public ResponseData fanuc(RequestData<LocationData> data)
        {
            ResponseData responseData = new ResponseData();
            try
            {
                string ip = data.ip;
                string port = data.port;
                string fun = data.fun;
                int ret = 0;
                ConDevice CIF = new ConDevice();
                if (fun == "All")
                {
                    ConDevice2 CIF2 = new ConDevice2(ip, port);
                    DeviceInfo info = new DeviceInfo();
                    if (CIF2.h > 0)
                    {
                        info.MainProg = CIF2.MainProg();
                        info.CurProg = CIF2.MainProg();
                        info.Status = CIF2.Status();
                        info.EMG = CIF2.EMG();
                        info.ActFeed = CIF2.ActFeed();
                        info.ActSpindle = CIF2.ActSpindle();
                        info.SpindleLoad = CIF2.SpindleLoad();
                        info.spindleMagnification = CIF2.spindleMagnification();
                        info.ServoLoadX = CIF2.ServoLoadX();
                        info.ServoLoadY = CIF2.ServoLoadY();
                        info.ServoLoadZ = CIF2.ServoLoadZ();
                        info.PowerOnTime = CIF2.PowerOnTime();
                        info.AccumulateCuttingTime = CIF2.AccumulateCuttingTime();
                        info.CuttingTimePerCycle = CIF2.CuttingTimePerCycle();
                        info.WorkTime = CIF2.WorkTime();
                        info.Part_Count = CIF2.Part_Count();

                        string isalarm = "";

                        //info.AlmMsg = CIF2.AlmMsg(out isalarm);
                        info.AlmMsg = CIF2.operationAlarm();

                        info.IsAlarm = isalarm;
                        info.ToolNo = CIF2.ToolNo();
                        info.ToolLife = CIF2.ToolLife();
                        //info.ToolLife = CIF2.ToolLife(ip, port);

                        string jsonalldata = JsonConvert.SerializeObject(info);

                        CIF2.freehand();
                    }
                }else if(fun== "UploadFile")
                {
                    string prgname = data.prgname;
                    
                    ret = CIF.UploadNcProg(ip, port, prgname);
                    if (ret == Fanuc.EW_OK)
                    {
                        Log.Instance.WriteLogAdd("UploadFile_OK:" + JsonConvert.SerializeObject(data),
                    EnumHelper.GetEnumDescription<WcsActionType>(FANUC));

                    }
                    else
                    {
                        Log.Instance.WriteLogAdd("UploadFile_error:" + JsonConvert.SerializeObject(data),
                   EnumHelper.GetEnumDescription<WcsActionType>(FANUC));
                    }
                }

                return responseData;


            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("异常===>>" + ex + JsonConvert.SerializeObject(data),
                   EnumHelper.GetEnumDescription<WcsActionType>(FANUC));
                responseData.IsSuccess = false;
                responseData.Msg = ex.Message;
                return responseData;
            }


        }

        public ResponseData opcua(RequestBody opcBody)
        {
            ResponseData responseBody = new ResponseData();
            Server opcServer = null;
            try
            {


                // 从map中取出opcServer 判断是否存在，以及是否可用
                opcServerMap.TryGetValue(opcBody.ServerUrl, out opcServer);

                // 如果key不存在，或者存在单连接不上，则需要重新创建连接
                if (!opcServerMap.ContainsKey(opcBody.ServerUrl) || !opcServer.Session.Connected)
                {
                    Ping pingSender = new Ping();
                    PingReply reply = pingSender.Send(opcBody.Ip);
                    if (reply.Status == IPStatus.Success)
                    {
                        opcServer = DeviceOPCUat.OpcUa_Connection1(opcBody.ServerUrl, opcBody.UserName, opcBody.Password);
                    }

                    if (opcServer != null && opcServer.Session != null && opcServer.Session.Connected)
                    {
                        // 存储Server bean
                        opcServerMap.Add(opcBody.ServerUrl, opcServer);
                    }

                }

                if (opcServer != null && opcServer.Session != null && opcServer.Session.Connected)
                {
                    if (opcBody.Type == ActionTypeEnum.Connect.ToString()) //连接状态
                    {
                        responseBody.result = true;
                    }
                    else if (opcBody.Type == ActionTypeEnum.Collect.ToString()) //采集
                    {
                        //ETH_S7Simens s7 = new ETH_S7Simens("192.168.11.164");

                        //responseBody.runDatasInfo = JsonConvert.SerializeObject(s7.deviceInfo);

                        if (opcBody.check == null)
                        {
                            // 封装需要采集字段的数据
                            //this.addAddress(opcBody);
                        }
                        else
                        {
                            opcBody.Addresses.Add("ns=2;s=/Plc/DB2.DBX626.6");//千机质检结果
                        }
                        List<string> values = opcServer.ReadValues(opcBody.Addresses);
                        responseBody.values = values;
                        /*RunDatasInfo runDatasInfo = new RunDatasInfo();
                        for (int i = 0; i < values.Count; i++)
                        {
                            if (i == 0)
                            {
                                runDatasInfo.feedRate = values[i];
                            }
                            else if (i == 1)
                            {
                                runDatasInfo.spindleMagnification = values[i];
                            }
                            else if (i == 2)
                            {
                                runDatasInfo.spindleSpeed = values[i];
                            }
                            else if (i == 3)
                            {
                                runDatasInfo.spindleLoad = values[i];
                            }
                            else if (i == 4)
                            {
                                runDatasInfo.mainPro = values[i];
                            }
                            else if (i == 5)
                            {
                                runDatasInfo.content = values[i];
                            }
                        }
                        responseBody.runDatasInfo = JsonConvert.SerializeObject(runDatasInfo);*/

                        /*//报警 
                        SinumerikOpcUaAPI.FilterDefinition m_filter = new SinumerikOpcUaAPI.FilterDefinition();
                        m_filter.AreaId = new NodeId("Sinumerik", (ushort)2);
                        m_filter.Severity = EventSeverity.Min;
                        m_filter.IgnoreSuppressedOrShelved = true;
                        m_filter.EventTypes = (IList<NodeId>)new NodeId[1]
                        {
                         ObjectTypeIds.ConditionType
                        };
                        m_filter.SelectClauses = m_filter.ConstructSelectClauses(opcServer.Session, ObjectTypeIds.ConditionType);
                        for (int index = 0; index < m_filter.SelectClauses.Count<SimpleAttributeOperand>(); ++index)
                        {
                            responseBody.errorsInfo += m_filter.SelectClauses[index].ToString() + (object)index + " ";
                        }*/
                    }
                    else if (opcBody.Type == ActionTypeEnum.ToolList.ToString())
                    {
                        List<string> nums = this.readVariables(opcServer, new string[1]
                            {
                                            "/Tool/Catalogue/numTools[u<Area index>]".Replace("<Area index>", this.currentToolArea.ToString())
                            }
                        );
                        int num = int.Parse(nums[0]);
                        List<ToolsInfo> toolInfoList = new List<ToolsInfo>();
                        for (int index = 1; index <= num; index++)
                        {
                            try
                            {
                                List<string> stringList = this.readVariables(opcServer, new string[10]
                           {
                                          "/Tool/Catalogue/toolNo[u<Area index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Row index>", index.ToString()),
                                          "/Tool/Catalogue/toolIdent[u<Area index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Row index>", index.ToString()),
                                          "/Tool/Catalogue/toolInMag[u<Area index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Row index>", index.ToString()),
                                          "/Tool/Catalogue/toolInPlace[u<Area index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Row index>", index.ToString()),
                                          "/Tool/Catalogue/nrDuplo[u<Area index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Row index>", index.ToString()),
                                          "/Tool/Catalogue/numCuttEdges[u<Area index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Row index>", index.ToString()),
                                          "/Tool/Compensation/edgeData[u<Area index>,c<Column index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Column index>",index.ToString()).Replace("<Row index>", "3"),
                                          "/Tool/Compensation/edgeData[u<Area index>,c<Column index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Column index>",index.ToString()).Replace("<Row index>", "6"),
                                          "/Tool/Compensation/edgeData[u<Area index>,c<Column index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Column index>",index.ToString()).Replace("<Row index>", "12"),
                                          "/Tool/Compensation/edgeData[u<Area index>,c<Column index>, <Row index>]".Replace("<Area index>", this.currentToolArea.ToString()).Replace("<Column index>",index.ToString()).Replace("<Row index>", "15")
                           }
                           );

                                ToolsInfo toolInfo = new ToolsInfo(); ;
                                toolInfo.number = Convert.ToUInt16(stringList[0]) + "";
                                toolInfo.name = stringList[1];
                                toolInfo.length = stringList[6];
                                toolInfo.radius = stringList[7];
                                toolInfo.wearLength = stringList[8];
                                toolInfo.wearRadius = stringList[9];
                                //toolInfo.toolInMag = Convert.ToUInt16(stringList[2]);
                                //toolInfo.toolInPlace = Convert.ToUInt16(stringList[3]);
                                //toolInfo.nrDuplo = Convert.ToUInt16(stringList[4]);
                                //toolInfo.numCuttEdges = Convert.ToUInt16(stringList[5]);
                                toolInfoList.Add(toolInfo);
                            }
                            catch (Exception ex)
                            {
                                Log.Instance.WriteLogAdd("异常===>>" + ex + JsonConvert.SerializeObject(responseBody),
                  EnumHelper.GetEnumDescription<WcsActionType>(OPCUA));

                            }

                        }
                        responseBody.toolsInfo = JsonConvert.SerializeObject(toolInfoList);
                    }
                  /*  else if (opcBody.Type == ActionTypeEnum.Read.ToString())
                    {
                        responseBody.values = opcServer.ReadValues(opcBody.Addresses);
                    }
                    else if (opcBody.Type == ActionTypeEnum.Write.ToString())
                    {
                        opcServer.WriteValues(opcBody.Values, opcBody.Addresses);
                    }
                    else if (opcBody.Type == ActionTypeEnum.SelectNc.ToString())
                    {
                        string sSelectedFileName = Path.GetFileName(opcBody.Path);
                        string status = opcServer.MethodCallSelectProgram(UPLOAD_NC_PATH + sSelectedFileName, Convert.ToUInt32(CHANNEL_NO)).status;
                        if (status == "Good")
                        {
                            responseBody.msg = "选择成功";
                        }
                        else
                        {
                            responseBody.msg = "选择失败";
                        }
                    }
                    else if (opcBody.Type == ActionTypeEnum.Upload.ToString())
                    {
                        string file = opcBody.Path;
                        string serverPath = "";
                        string status = "";
                        //选择临时文件
                        status = opcServer.MethodCallSelectProgram(UPLOAD_NC_PATH + TEMP_NC_NAME, Convert.ToUInt32(CHANNEL_NO)).status;
                        try
                        {
                            string extension = Path.GetExtension(file);
                            if (string.IsNullOrWhiteSpace(extension))
                            {
                                responseBody.msg = "文件名不合法";
                            }
                            try
                            {

                                byte[] data = opcServer.ReadFile(file);

                                serverPath = UPLOAD_NC_PATH + Path.GetFileName(file);
                                Server.MethodCallResult methodCallResult = opcServer.MethodCallCopyFileToServer("/Methods/CopyFileToServer", serverPath, data, true);

                                if (methodCallResult.status.ToUpper().Equals("GOOD"))
                                {
                                    responseBody.msg = "上传文件成功";
                                    YG.Log.Instance.WriteLogAdd(file + "上传文件成功");
                                }
                                else
                                {
                                    responseBody.msg = "上传文件失败";
                                    YG.Log.Instance.WriteLogAdd(file + "上传文件失败");
                                }
                                // } 
                            }
                            catch (Exception ex)
                            {
                                responseBody.msg = "上传文件失败===>" + ex.Message;
                                YG.Log.Instance.WriteLogAdd($"{ex.Message}");
                            }


                        }
                        catch (Exception ex)
                        {
                            responseBody.msg = "上传文件失败===>" + ex.Message;
                            YG.Log.Instance.WriteLogAdd($"493-->{ex.Message}");
                        }
                        //设位主程序
                        status = opcServer.MethodCallSelectProgram(serverPath, Convert.ToUInt32(CHANNEL_NO)).status;
                    }*/
                    else if (opcBody.Type == ActionTypeEnum.UploadFileList.ToString())
                    {
                       

                        for (int i = 0; i < opcBody.subFileList.Count; i++)
                        {
                            string file = opcBody.subFileList[i];
                            string serverPath = "";
                            try
                            {
                                string extension = Path.GetExtension(file);
                                if (string.IsNullOrWhiteSpace(extension))
                                {
                                    responseBody.result = false;
                                    responseBody.Msg = file + "==文件名不合法";
                                    break;
                                }
                                try
                                {

                                    byte[] data = opcServer.ReadFile(file);

                                    serverPath = UPLOAD_NC_PATH + Path.GetFileName(file);
                                    Server.MethodCallResult methodCallResult = opcServer.MethodCallCopyFileToServer("/Methods/CopyFileToServer", serverPath, data, true);

                                    if (methodCallResult.status.ToUpper().Equals("GOOD"))
                                    {
                                        responseBody.Msg = "上传文件成功";
                                        
                                    }
                                    else
                                    {
                                        responseBody.Msg = "上传文件失败";
                                        responseBody.result = false;
                                        break;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    responseBody.Msg = "上传文件失败===>" + ex.Message;
                                    break;
                                }


                            }
                            catch (Exception ex)
                            {
                                responseBody.Msg = "上传文件失败===>" + ex.Message;
                                responseBody.result = false;

                            }
                        }

                        //设为主程序
                        string status = opcServer.MethodCallSelectProgram(UPLOAD_NC_PATH + opcBody.prgName, Convert.ToUInt32(1)).status;
                        if (status != "Good")
                        {
                            responseBody.Msg = "选择失败";
                            responseBody.result = false;
                        }

                        /*for (int i = 0; i < opcBody.toolFileList.Count; i++)
                        {
                            string file = opcBody.toolFileList[i];
                            string serverPath = "";
                            try
                            {
                                string extension = Path.GetExtension(file);
                                if (string.IsNullOrWhiteSpace(extension))
                                {
                                    responseBody.result = false;
                                    responseBody.Msg = file + "==文件名不合法";
                                    break;
                                }
                                try
                                {

                                    byte[] data = opcServer.ReadFile(file);

                                    serverPath = UPLOAD_TOOL_PATH + Path.GetFileName(file);
                                    Server.MethodCallResult methodCallResult = opcServer.MethodCallCopyFileToServer("/Methods/CopyFileToServer", serverPath, data, true);

                                    if (methodCallResult.status.ToUpper().Equals("GOOD"))
                                    {

                                        YG.Log.Instance.WriteLogAdd(file + "对刀仪上传文件成功");
                                    }
                                    else
                                    {

                                        YG.Log.Instance.WriteLogAdd(file + "对刀仪上传文件失败");
                                        break;
                                    }
                                }
                                catch (Exception ex)
                                {

                                    YG.Log.Instance.WriteLogAdd($"{ex.Message}");
                                    break;
                                }


                            }
                            catch (Exception ex)
                            {

                                YG.Log.Instance.WriteLogAdd($"对刀仪493-->{ex.Message}");
                            }
                        }*/



                    }
                    /*else if (opcBody.Type == ActionTypeEnum.DownLoad.ToString())
                    {
                        string file = opcBody.Path;
                        string serverPath = "";
                        try
                        {
                            string extension = Path.GetExtension(file);
                            if (string.IsNullOrWhiteSpace(extension))
                            {
                                responseBody.msg = "文件名不合法";
                            }
                            try
                            {

                                //byte[] data = opcServer.ReadFile(file);

                                serverPath = UPLOAD_NC_PATH + Path.GetFileName(file);
                                // Server.MethodCallResult methodCallResult = opcServer.MethodCallCopyFileFromServer("/Methods/CopyFileFromServer", serverPath);

                                //

                                byte[] op = opcServer.ReadFile(serverPath);

                                DiagnosticInfoCollection diagnosticInfos = null;
                                CallMethodRequestCollection callMethodRequestCollection = new CallMethodRequestCollection();
                                CallMethodResultCollection results = new CallMethodResultCollection();
                                CallMethodRequest callMethodRequest = new CallMethodRequest();
                                callMethodRequest.MethodId = new NodeId("/Methods/CopyFileFromServer", mNAMESPACE_INDEX);
                                callMethodRequest.ObjectId = new NodeId("/Methods", mNAMESPACE_INDEX);
                                callMethodRequest.InputArguments.Add(serverPath);
                                //callMethodRequest.InputArguments.Add(data);
                                callMethodRequestCollection.Add(callMethodRequest);
                                RequestHeader requestHeader = new RequestHeader();
                                ResponseHeader responseHeader = opcServer.Session.Call(null, callMethodRequestCollection, out results, out diagnosticInfos);
                                Server.MethodCallResult methodCallResult = new MethodCallResult(results);

                                if (methodCallResult.status.ToUpper().Equals("GOOD"))
                                {
                                    responseBody.msg = "上传文件成功";
                                    YG.Log.Instance.WriteLogAdd(file + "上传文件成功");
                                    Variant result3 = methodCallResult.results;

                                    byte[] buff;
                                    using (MemoryStream ms = new MemoryStream())
                                    {
                                        IFormatter iFormatter = new BinaryFormatter();
                                        iFormatter.Serialize(ms, result3.Value);
                                        buff = ms.GetBuffer();
                                    }
                                    // 将byte[]写入文件
                                    File.WriteAllBytes(file, buff);

                                    // 读取文件内容到字符串
                                    string fileContent = File.ReadAllText(file);
                                    fileContent = fileContent.Trim();

                                    // 去除字符串中的空格
                                    //string trimmedContent = fileContent.Trim(); // 使用Trim去除字符串首尾的空格
                                    // 或者使用Replace去除所有空格
                                    string trimmedContent = fileContent.Replace(" ", "");

                                    // 将处理过的字符串写回文件
                                    File.WriteAllText(file, trimmedContent);


                                    string aa = result3.ToString();




                                }
                                else
                                {
                                    responseBody.msg = "上传文件失败";
                                    YG.Log.Instance.WriteLogAdd(file + "上传文件失败");
                                }
                                // } 
                            }
                            catch (Exception ex)
                            {
                                responseBody.msg = "上传文件失败===>" + ex.Message;
                                YG.Log.Instance.WriteLogAdd($"{ex.Message}");
                            }


                        }
                        catch (Exception ex)
                        {
                            responseBody.msg = "上传文件失败===>" + ex.Message;
                            YG.Log.Instance.WriteLogAdd($"493-->{ex.Message}");
                        }
                    }
                    else if (opcBody.Type == ActionTypeEnum.Delete.ToString())
                    {
                        string file = opcBody.Path;
                        string serverPath = "";
                        try
                        {
                            string extension = Path.GetExtension(file);
                            if (string.IsNullOrWhiteSpace(extension))
                            {
                                responseBody.msg = "文件名不合法";
                            }
                            else
                            {
                                try
                                {

                                    //byte[] data = opcServer.ReadFile(file);

                                    serverPath = UPLOAD_NC_PATH + Path.GetFileName(file);
                                    Server.MethodCallResult methodCallResult = opcServer.MethodCallDeleteFile(serverPath);



                                    if (methodCallResult.status.ToUpper().Equals("GOOD"))
                                    {

                                        responseBody.msg = "删除文件成功";
                                        YG.Log.Instance.WriteLogAdd(file + "删除文件成功");
                                    }
                                    else
                                    {
                                        responseBody.msg = "上传文件失败";
                                        YG.Log.Instance.WriteLogAdd(file + "上传文件失败");
                                    }
                                    // } 
                                }
                                catch (Exception ex)
                                {
                                    responseBody.msg = "上传文件失败===>" + ex.Message;
                                    YG.Log.Instance.WriteLogAdd($"{ex.Message}");
                                }
                            }

                        }
                        catch (Exception ex)
                        {
                            responseBody.msg = "上传文件失败===>" + ex.Message;
                            YG.Log.Instance.WriteLogAdd($"493-->{ex.Message}");
                        }
                    }
                    else if (opcBody.Type == ActionTypeEnum.SynFile.ToString())
                    {

                        try
                        {
                            Server.MethodCallResult methodCallResult = opcServer.MethodCall("GetAllFiles", UPLOAD_NC_PATH);
                            if (methodCallResult.status.ToUpper().Equals("GOOD"))
                            {

                                responseBody.msg = "同步文件成功";
                            }
                            else
                            {
                                responseBody.msg = "同步文件失败";
                            }
                            // } 
                        }
                        catch (Exception ex)
                        {
                            responseBody.msg = "同步文件失败===>" + ex.Message;
                            YG.Log.Instance.WriteLogAdd($"{ex.Message}");
                        }

                    }*/
                }
                else
                {
                    responseBody.Code = 0;
                    responseBody.Msg = "服务器离线，连不上opcUa";
                    responseBody.result = false;
                }

                return responseBody;


            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("异常===>>" + ex + JsonConvert.SerializeObject(responseBody),
                   EnumHelper.GetEnumDescription<WcsActionType>(OPCUA));
                responseBody.result = false;
                responseBody.Msg = ex.Message;
                return responseBody;
            }


        }

        public ResponseData heidenhain(RequestBody hdhBody)
        {
            ResponseData responseBody = new ResponseData();
            try
            {
                if (hdhBody.Type == ActionTypeEnum.Connect.ToString())
                {
                    Ping pingSender = new Ping();
                    PingReply reply = pingSender.Send(hdhBody.ServerUrl);
                    if (reply.Status != IPStatus.Success)
                    {
                        responseBody.result = false;
                    }
                }
                else
                {
                    //第一次连接加入数组,以支持多台设备
                    if (deviceList == null || (deviceList.Where(m => m.Key == hdhBody.MachineName).Count() == 0))
                    {
                        m_ControlState = connect(hdhBody.MachineName);

                        //DNC连接正常,加入数组
                        if (m_ControlState.ToString() == "DNC_STATE_MACHINE_IS_AVAILABLE")
                        {
                            deviceList.Add(hdhBody.MachineName, m_ControlState);
                        }
                        Thread.Sleep(500);
                    }
                    else
                    {
                        //取设备对应的状态
                        m_ControlState = deviceList.Where(m => m.Key == hdhBody.MachineName).FirstOrDefault().Value;
                    }
                    JHMachineInProcess Machine = machineList.Where(m => m.Key == hdhBody.MachineName).FirstOrDefault().Value;


                    if (m_ControlState != null && m_ControlState.ToString() == "DNC_STATE_MACHINE_IS_AVAILABLE")
                    {
                        JHError m_Error = (JHError)Machine.GetInterface(HeidenhainDNCLib.DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHERROR);
                        JHErrorEntry2List errorsList = m_Error.GetErrorList();
                        IJHErrorEntry2 pErrorEntry = null;
                        for (int i = 0; i < errorsList.Count; i++)
                        {
                            pErrorEntry = errorsList[i];
                            if (pErrorEntry != null && pErrorEntry.Text != null)
                            {
                                //Console.WriteLine("===" + pErrorEntry.Text.ToString());
                                responseBody.errorsInfo += pErrorEntry.Text.ToString() + " ";
                            }
                        }


                        /*if (hdhBody.Type == ActionTypeEnum.Collect.ToString())
                        {

                            JHAutomatic m_Automatic = Machine.GetInterface(DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHAUTOMATIC);

                            JHProcessData m_ProcessData = Machine.GetInterface(HeidenhainDNCLib.DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHPROCESSDATA);


                            object pFeed = new object();
                            object pSpeed = new object();
                            object pRapid = new object();
                            object proStatus = new object();
                            //进出倍率 主轴倍率 
                            m_Automatic.GetOverrideInfo(ref pFeed, ref pSpeed, ref pRapid);
                            m_Automatic.GetExecutionMode();
                            DNC_STS_PROGRAM dncProgram = m_Automatic.GetProgramStatus();

                            RunDatasInfo runDatasInfo = new RunDatasInfo();
                            runDatasInfo.feedRate = pFeed.ToString();
                            runDatasInfo.spindleMagnification = pSpeed.ToString();
                            runDatasInfo.spindleSpeed = pRapid.ToString();

                            responseBody.runDatasInfo = JsonConvert.SerializeObject(runDatasInfo);

                            object oHours = new object();
                            object oMinutes = new object();
                            // --- NC uptime --------------------------------------------------------------------------
                            m_ProcessData.GetNcUpTime(ref oHours, ref oMinutes);
                            string ncUpTime = oHours.ToString() + ":" + (Convert.ToInt32(oMinutes) > 9 ? oMinutes.ToString() : ("0" + oMinutes.ToString()));

                            // --- Machine uptime ---------------------------------------------------------------------
                            m_ProcessData.GetMachineUpTime(ref oHours, ref oMinutes);
                            string machineUpTime = oHours.ToString() + ":" + (Convert.ToInt32(oMinutes) > 9 ? oMinutes.ToString() : ("0" + oMinutes.ToString()));
                            // --- Machine running time ---------------------------------------------------------------
                            m_ProcessData.GetMachineRunningTime(ref oHours, ref oMinutes);
                            string runningTimes = oHours.ToString() + ":" + (Convert.ToInt32(oMinutes) > 9 ? oMinutes.ToString() : ("0" + oMinutes.ToString()));


                        }
                        else */
                        if (hdhBody.Type == ActionTypeEnum.Upload.ToString())
                        {

                            JHFileSystem m_FileSystem = (JHFileSystem)Machine.GetInterface(DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHFILESYSTEM);

                            JHAutomatic m_Automatic = (JHAutomatic)Machine.GetInterface(DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHAUTOMATIC);

                            string sSelectedFile = Path.GetFileName(hdhBody.Path);

                            string dncPath = GenPath(RemotePath, sSelectedFile);
                            string tempDncPath = RemotePath + "\\2.h";
                            //设置临时程序为主程序
                            m_Automatic.SelectProgram(iChannel, tempDncPath);
                            try
                            { //删除上传文件，try异常防止文件不存在
                              //m_FileSystem.DeleteFile(dncPath);
                            }
                            catch (Exception edel)
                            {
                            }
                            //上传
                            m_FileSystem.TransmitFile(hdhBody.Path, dncPath);
                            //设当前上传程序为主程序
                            m_Automatic.SelectProgram(iChannel, dncPath);
                        }
                        /*else if (hdhBody.Type == ActionTypeEnum.DeleteNc.ToString())
                        {

                            JHFileSystem m_FileSystem = Machine.GetInterface(DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHFILESYSTEM);

                            string dncPath = GenPath(RemotePath, hdhBody.Path);
                            m_FileSystem.DeleteFile(dncPath);
                        }
                        else if (hdhBody.Type == ActionTypeEnum.SelectNcProgram.ToString())//选中程序
                        {

                            JHAutomatic m_Automatic = Machine.GetInterface(DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHAUTOMATIC);

                            string dncPath = GenPath(RemotePath, hdhBody.Path);
                            m_Automatic.SelectProgram(iChannel, dncPath);
                        }
                        else if (hdhBody.Type == ActionTypeEnum.StartNcProgram.ToString())//启动程序备用
                        {

                            JHAutomatic m_Automatic = Machine.GetInterface(DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHAUTOMATIC);

                            //m_Automatic.SelectProgram(iChannel, GenPath(RemotePath, hdhBody.Path));
                            //Thread.Sleep(1000);
                            m_Automatic.StartProgram(GenPath(RemotePath, hdhBody.Path));
                        }
                        else if (hdhBody.Type == ActionTypeEnum.Read.ToString())
                        {

                        }
                        else if (hdhBody.Type == ActionTypeEnum.Write.ToString())
                        {

                        }
                        else if (hdhBody.Type == ActionTypeEnum.ToolList.ToString())
                        {
                            IJHDataEntry2 ToolLine = null;
                            IJHDataEntry2List ToolCells = null;
                            //IJHDataEntry2 ToolCell = null;                                    
                            List<ToolsInfo> toolsList = new List<ToolsInfo>();
                            JHDataAccess dataAccess = Machine.GetInterface(HeidenhainDNCLib.DNC_INTERFACE_OBJECT.DNC_INTERFACE_JHDATAACCESS);
                            dataAccess.SetAccessMode(DNC_ACCESS_MODE.DNC_ACCESS_MODE_TABLEDATAACCESS, "");
                            //string ToolColumnNamesAccessor = @"\TABLE\TOOL\T\('1'-'50')";   // see Init()
                            string ToolColumnNamesAccessor = @"\TABLE\TOOL_P\T\('1'-'50')";
                            IJHDataEntry2 ToolTable = dataAccess.GetDataEntry2(ToolColumnNamesAccessor, DNC_DATA_UNIT_SELECT.DNC_DATA_UNIT_SELECT_METRIC, false);
                            IJHDataEntry2List ToolLines = ToolTable.GetChildList();
                            int ToolLinesCount = ToolLines.Count >= 50 ? 50 : ToolLines.Count;
                            //int ToolLinesCount = ToolLines.Count;                                    
                            for (int i = 0; i < ToolLinesCount; i++)
                            {
                                ToolLine = ToolLines[i];
                                ToolCells = ToolLine.GetChildList();
                                // get child list from server                                       
                                ToolsInfo toolsInfo = new ToolsInfo();

                                //刀位编码
                                int[] pCode = ToolCells[0].GetPropertyValue(DNC_DATAENTRY_PROPKIND.DNC_DATAENTRY_PROPKIND_DATA);
                                toolsInfo.position = string.Join(".", pCode);
                                toolsInfo.number = ToolCells[1].GetPropertyValue(DNC_DATAENTRY_PROPKIND.DNC_DATAENTRY_PROPKIND_DATA).ToString();
                                toolsInfo.name = ToolCells[2].GetPropertyValue(DNC_DATAENTRY_PROPKIND.DNC_DATAENTRY_PROPKIND_DATA).ToString();


                                if (!String.IsNullOrEmpty(toolsInfo.name) && !String.IsNullOrEmpty(toolsInfo.number) && pCode.Length > 0 && pCode[1] > 0)
                                {
                                    string ToolNumberAccessor = @"\TABLE\TOOL\T\" + toolsInfo.number.ToString();
                                    IJHDataEntry2List ToolList = dataAccess.GetDataEntry2(ToolNumberAccessor, DNC_DATA_UNIT_SELECT.DNC_DATA_UNIT_SELECT_METRIC, false).GetChildList();

                                    //报警期限
                                    toolsInfo.warnLife = ToolList[10].GetPropertyValue(DNC_DATAENTRY_PROPKIND.DNC_DATAENTRY_PROPKIND_DATA).ToString();
                                    //刀具寿命目标值
                                    toolsInfo.targetLife = ToolList[11].GetPropertyValue(DNC_DATAENTRY_PROPKIND.DNC_DATAENTRY_PROPKIND_DATA).ToString();
                                    //Cur_Time使用时间
                                    toolsInfo.curTime = ToolList[12].GetPropertyValue(DNC_DATAENTRY_PROPKIND.DNC_DATAENTRY_PROPKIND_DATA).ToString();

                                    toolsList.Add(toolsInfo);
                                }
                            }
                            //获取海德汉的刀具寿命信息
                            responseBody.toolsInfo = JsonConvert.SerializeObject(toolsList.Distinct().ToList());
                        }
                    }
                    else
                    {
                        responseBody.msg = m_ControlState.ToString();
                        responseBody.result = false;
                        deviceList.Remove(hdhBody.MachineName);
                    }*/
                    }



                }
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("异常===>>" + ex + JsonConvert.SerializeObject(hdhBody),
                   EnumHelper.GetEnumDescription<WcsActionType>(HEIDENHAIN));
                responseBody.IsSuccess = false;
                responseBody.Msg = ex.Message;
                return responseBody;
            }
            return responseBody;
        }

        private List<string> readVariables(Server server, string[] variables)
        {
            List<string> nodeIdStrings = new List<string>();
            foreach (string variable in variables)
            {
                NodeId nodeId = new NodeId(variable, (ushort)2);
                nodeIdStrings.Add(nodeId.ToString());
            }
            return server.ReadValues(nodeIdStrings);
        }

        private DNC_STATE connect(string connectName)
        {
            DNC_CNC_TYPE CncType;

            IJHConnectionList connectionList = null;
            IJHConnection connection = null;
            try
            {
                JHMachineInProcess Machine = null;
                //第一次连接加入数组,以支持多台设备
                if (machineList == null || (machineList.Where(m => m.Key == connectName).Count() == 0))
                {
                    Machine = new JHMachineInProcess();
                    //DNC连接正常,加入数组 
                    machineList.Add(connectName, Machine);
                    Thread.Sleep(20);
                }
                else
                {
                    //取对应设备 
                    Machine = machineList.Where(m => m.Key == connectName).FirstOrDefault().Value;
                }
                Machine.ConnectRequest(connectName);
                string sCurrentMachine = Machine.currentMachine;

                // Find out control type
                connectionList = Machine.ListConnections();
                for (int i = 0; i < connectionList.Count; i++)
                {
                    connection = connectionList[i];

                    if (connection.name == sCurrentMachine)
                    {
                        CncType = connection.cncType;
                    }

                    if (connection != null)
                        Marshal.ReleaseComObject(connection);
                }
                return Machine.GetState();
            }
            catch (COMException cex)
            {
                return DNC_STATE.DNC_STATE_NOT_INITIALIZED;
            }
            catch (Exception ex)
            {
                return DNC_STATE.DNC_STATE_NOT_INITIALIZED;
            }
            finally
            {
                if (connectionList != null)
                    Marshal.ReleaseComObject(connectionList);
                if (connection != null)
                    Marshal.ReleaseComObject(connection);
            }
        }

        private string GenPath(string part1, string part2)
        {
            string sFullPath = part1;
            switch (part2)
            {
                case ".":
                    break;
                case "..":
                    if (part1.EndsWith(@"\") && part1.Length > 5)
                        part1 = part1.Substring(0, part1.Length - 3);
                    int iLastFolderPos = part1.LastIndexOf(@"\");
                    if (iLastFolderPos >= 0)
                        sFullPath = part1.Substring(0, iLastFolderPos + 1);
                    break;
                default:
                    if (part1.EndsWith(@"\"))
                        sFullPath = part1 + part2;
                    else
                        sFullPath = part1 + @"\" + part2;
                    break;
            }
            return sFullPath;
        }

    }
}