using Autofac;
using Bro.Common.Base;
using Bro.Common.Helper;
using Bro.Common.Interface;
using Bro.Common.Model;
using Bro.Common.Model.Interface;
using Bro.Common.PubSub;
using Bro.Common.UI;
using Bro.Device.AuboRobot;
using Bro.Device.OmronFins;
using Bro.Device.SeerAGV;
using Bro.Device.Station.Forms;
using HalconDotNet;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Configuration;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using static Bro.Common.Helper.EnumHelper;

namespace A032.Process
{
    public partial class ProcessControl : IStationProcess
    {
        ContainerBuilder builder = new ContainerBuilder();

        private void AutoFacRegister(bool isBuild = true)
        {
            #region AutoFac注册
            builder.RegisterInstance<ProcessConfig>(StationConfig as ProcessConfig);
            builder.RegisterInstance<List<IDevice>>(GetDeviceList());
            builder.RegisterInstance<List<ProcessMethodAttribute>>(CollectProcessMethods());

            if (isBuild)
            {
                GlobalVar.Container = builder.Build();
            }
            #endregion
        }

        public IStationConfig StationConfig { get; set; }

        string CONFIG_PATH = "";
        private string productionCode = "";
        public string ProductionCode
        {
            get => productionCode;
            set
            {
                if (productionCode != value)
                {
                    productionCode = value;

                    string baseDir = "";

                    string configPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Config.json");
                    if (File.Exists(configPath))
                    {
                        using (StreamReader reader = new StreamReader(configPath, System.Text.Encoding.UTF8))
                        {
                            string dataStr = reader.ReadToEnd();
                            JObject data = JsonConvert.DeserializeObject<JObject>(dataStr);
                            baseDir = data.Value<string>("ConfigPath");
                        }
                    }

                    if (string.IsNullOrWhiteSpace(baseDir))
                    {
                        baseDir = AppDomain.CurrentDomain.BaseDirectory;
                    }

                    if (!string.IsNullOrWhiteSpace(productionCode) && productionCode != "Default")
                    {
                        CONFIG_PATH = Path.Combine(baseDir, $"Config_{productionCode}.json");
                    }
                    else
                    {
                        CONFIG_PATH = Path.Combine(baseDir, "Config.json");
                    }
                }
            }
        }

        #region Event
        public Action<string, Bitmap> OnBitmapOutput { get; set; }
        public Action<string> OnBitmapClear { get; set; }
        public Action<string, object> OnObjectOutput { get; set; }
        public Action<string, Exception> OnExceptionOccured { get; set; }
        public Action<DeviceState> OnProcessStateChanged { get; set; }
        #endregion

        #region Property & Field
        private DeviceState processState = DeviceState.DSUninit;
        public DeviceState ProcessState
        {
            get => processState;
            set
            {
                if (processState != value)
                {
                    processState = value;
                    Task.Run(() =>
                    {
                        OnProcessStateChanged?.Invoke(value);
                    });
                    //OnProcessStateChanged?.BeginInvoke(value, null, null);
                }
            }
        }

        Dictionary<string, OmronFinsDriver> PLCDict = new Dictionary<string, OmronFinsDriver>();
        Dictionary<string, AuboRobotDriver> RobotDict = new Dictionary<string, AuboRobotDriver>();
        Dictionary<string, SeerAGVDriver> AGVDict = new Dictionary<string, SeerAGVDriver>();
        Dictionary<string, CameraBase> CameraDict = new Dictionary<string, CameraBase>();

        private ProcessConfig Config { get => StationConfig as ProcessConfig; }

        string _configBackupStr = "";

        PubSubCenter PubSubCenter = PubSubCenter.GetInstance();
        #region constance variables
        //const int OFFLINE_FLAG = -999;
        //const int IGNORE_FEEDBACK = -999;
        #endregion
        #endregion

        public ProcessControl()
        {
            InitialStationProcess();
        }

        public ProcessControl(string productionCode, string configPath = "")
        {
            ProductionCode = productionCode;
            InitialStationProcess(configPath);
        }

        public virtual void Close()
        {
            if (ProcessState == DeviceState.DSClose)
                return;

            CloseDevice(PLCDict.Values.ToList());
            CloseDevice(RobotDict.Values.ToList());
            CloseDevice(AGVDict.Values.ToList());
            CloseDevice(CameraDict.Values.ToList());

            ProcessState = DeviceState.DSClose;

            LogAsync(DateTime.Now, "Process Closed", "");
        }

        public virtual void Open()
        {
            if (ProcessState == DeviceState.DSOpen)
                return;

            InitialProcessMethods();

            OpenDevices(RobotDict.Values.ToList());
            OpenDevices(AGVDict.Values.ToList());

            OpenCameras();
            PubSubCenter.Subscribe(PubTag.DeviceOperation.ToString(), OnCameraOp);

            OpenDevices(PLCDict.Values.ToList());

            ProcessState = DeviceState.DSOpen;

            QueryRobotIO();

            //Task.Run(() =>
            //{
            //    //PLCMonitor();
            //});

            LogAsync(DateTime.Now, "Process Opened", "");
        }

        private object OnCameraOp(ISubscriber arg1, object arg2, object arg3)
        {
            string cameraId = arg2.ToString();

            if (CameraDict.ContainsKey(cameraId))
            {
                CameraDict[cameraId].Snapshot();
            }

            return null;
        }

        public virtual void OpenCameras()
        {
            //Config.CameraConfigs.ForEach(c =>
            //{
            //    CameraBase camera = CameraHelper.GetCameraInstance(c.DriverType);
            //    camera.InitialConfig = c;

            //    OpenCamera(camera);

            //    CameraDict[camera.InitialConfig.ID] = camera;
            //});

            CameraDict.Values.ToList().ForEach(c =>
            {
                OpenCamera(c);
            });
        }

        protected void OpenCamera(CameraBase camera)
        {
            if (camera.InitialConfig?.IsEnabled ?? false)
            {
                camera.UpdateShowImage -= CameraUpdateImage;
                camera.UpdateShowImage += CameraUpdateImage;
                camera.OnLog = OnDeviceLog;

                camera.StateChange(DeviceState.DSInit);
                camera.StateChange(DeviceState.DSOpen);

                (camera as Bro.Device.HikCamera.HikCameraDriver).HImageOutput = HikCameraHImageOutput;
            }
        }

        private void HikCameraHImageOutput(HImage arg1, string arg2)
        {
        }

        private void OpenDevices<T>(List<T> devices) where T : IDevice
        {
            devices.ForEach(d =>
            {
                if (d.InitialConfig?.IsEnabled ?? false)
                {
                    d.OnLog = OnDeviceLog;

                    d.StateChange(DeviceState.DSInit);
                    d.StateChange(DeviceState.DSOpen);
                }
            });
        }

        private void CloseDevice<T>(List<T> devices) where T : IDevice
        {
            devices.ForEach(d =>
            {
                if (d.CurrentState != DeviceState.DSClose)
                {
                    d.StateChange(DeviceState.DSClose);
                }
            });
        }

        public List<ProcessMethodAttribute> CollectProcessMethods()
        {
            List<ProcessMethodAttribute> resultList = new List<ProcessMethodAttribute>();
            var methods = this.GetType().GetMethods().ToList();

            methods.ForEach(m =>
            {
                var attr = m.GetCustomAttribute<ProcessMethodAttribute>();
                if (attr != null)
                {
                    resultList.Add(attr);
                }
            });

            return resultList;
        }

        public void InitialStationProcess(string configPath = "")
        {
            ProcessException.OnExceptionNotice = LogAsync;

            StationConfig = LoadStationConfig(configPath);

            #region 个别配置的特别处理

            #endregion

            _warningRemains.CollectionChanged -= _warningRemains_CollectionChanged;
            _warningRemains.CollectionChanged += _warningRemains_CollectionChanged;

            InitialPLCs();
            InitialRobots();
            InitialAGVs();
            InitialCameras();

            AutoFacRegister();

            LogAsync(DateTime.Now, "Process Initialized", "");
        }

        private void InitialCameras()
        {
            Config.CameraConfigCollection.ForEach(c =>
            {
                CameraBase camera = CameraHelper.GetCameraInstance(c.DriverType);
                camera.InitialConfig = c;
                CameraDict[camera.InitialConfig.ID] = camera;
            });
        }

        private void InitialPLCs()
        {
            Config.PLCConfigCollection.ForEach(c =>
            {
                OmronFinsDriver plc = new OmronFinsDriver();
                plc.InitialConfig = c;
                PLCDict[plc.InitialConfig.ID] = plc;

                plc.OnMonitorAlarm -= Plc_OnMonitorAlarm;
                plc.OnMonitorInvoke -= Plc_OnMonitorInvoke;

                plc.OnMonitorAlarm += Plc_OnMonitorAlarm;
                plc.OnMonitorInvoke += Plc_OnMonitorInvoke;
            });
        }

        private void InitialRobots()
        {
            Config.RobotConfigCollection.ForEach(c =>
            {
                AuboRobotDriver robot = new AuboRobotDriver();
                robot.InitialConfig = c;
                RobotDict[robot.InitialConfig.ID] = robot;
            });
        }

        private void InitialAGVs()
        {
            Config.AGVConfigCollection.ForEach(c =>
            {
                SeerAGVDriver agv = new SeerAGVDriver();
                agv.InitialConfig = c;
                AGVDict[agv.InitialConfig.ID] = agv;
            });
        }

        public void InitialStationProcess()
        {
            InitialStationProcess("");
        }

        private ProcessConfig LoadStationConfig(string configPath = "")
        {
            ProcessConfig config = new ProcessConfig();

            if (string.IsNullOrWhiteSpace(configPath))
            {
                configPath = CONFIG_PATH;
            }

            try
            {
                if (File.Exists(configPath))
                {
                    using (StreamReader reader = new StreamReader(configPath, System.Text.Encoding.UTF8))
                    {
                        _configBackupStr = reader.ReadToEnd();
                        config = JsonConvert.DeserializeObject<ProcessConfig>(_configBackupStr, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });
                    }
                }

                if (config == null)
                {
                    config = new ProcessConfig();
                }
            }
            catch (Exception ex)
            {
            }

            return config;
        }

        public void Pause()
        {
        }

        public void Resume()
        {
        }

        public void SaveStationConfig(IStationConfig config)
        {
            AutoFacRegister(false);

            ProcessConfig pConfig = config as ProcessConfig;
            if (pConfig == null)
                throw new ProcessException("目前只支持ProcessConfig类型的非空内容保存", null);

            string newConfig = JsonConvert.SerializeObject(pConfig, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Auto });
            using (StreamWriter writer = new StreamWriter(CONFIG_PATH, false, System.Text.Encoding.UTF8))
            {
                writer.Write(newConfig);
                writer.Flush();
                writer.Close();
            }

            if (_configBackupStr != newConfig)
            {
                SaveBackupConfig();
            }
        }

        private void SaveBackupConfig()
        {
            string backPath = Path.GetDirectoryName(CONFIG_PATH);
            backPath = Path.Combine(backPath, ProductionCode + "_bk");
            if (!Directory.Exists(backPath))
            {
                Directory.CreateDirectory(backPath);
            }

            backPath = Path.Combine(backPath, $"Config_{ProductionCode}_{DateTime.Now.ToString("yyyyMMddHHmmss")}.json");

            using (StreamWriter writer = new StreamWriter(backPath, false, System.Text.Encoding.UTF8))
            {
                writer.Write(_configBackupStr);
                writer.Flush();
                writer.Close();
            }
        }

        /// <summary>
        /// 调用方法的字典集合
        /// Key：MethodCode，Value：MethodInfo
        /// </summary>
        public Dictionary<string, MethodInfo> _processMethodDict = new Dictionary<string, MethodInfo>();

        /// <summary>
        /// Halcon算法工具字典，在初始化时统一一次性载入
        /// Key：MethodCode，Value：HalconTool
        /// </summary>
        protected Dictionary<string, HDevEngineTool> _halconToolDict = new Dictionary<string, HDevEngineTool>();

        private void InitialProcessMethods()
        {
            _processMethodDict = new Dictionary<string, MethodInfo>();
            var methods = this.GetType().GetMethods().ToList();
            methods.ForEach(m =>
            {
                var attr = m.GetCustomAttribute<ProcessMethodAttribute>();
                if (attr != null)
                {
                    _processMethodDict[attr.MethodCode] = m;

                    #region 初始化HalconTool
                    //if (attr.DeviceType.EndsWith("Camera"))
                    //{
                    //    if (StationConfig.ProcessOpConfigDict.Keys.Contains(attr.MethodCode))
                    //    {
                    //        var opConfig = StationConfig.ProcessOpConfigDict[attr.MethodCode] as HalconRelatedCameraOprerationConfigBase;

                    //        if (opConfig != null)
                    //        {
                    //            if (!string.IsNullOrWhiteSpace(opConfig.AlgorithemPath))
                    //            {
                    //                string directoryPath = Path.GetDirectoryName(opConfig.AlgorithemPath);
                    //                string fileName = Path.GetFileNameWithoutExtension(opConfig.AlgorithemPath);

                    //                HDevEngineTool tool = new HDevEngineTool(directoryPath);
                    //                tool.LoadProcedure(fileName);

                    //                _halconToolDict[attr.MethodCode] = tool;
                    //            }
                    //        }
                    //    }
                    //}
                    #endregion
                }
            });

            #region 初始化HalconTool
            _halconToolDict = new Dictionary<string, HDevEngineTool>();
            Config.PLCConfigCollection.SelectMany(plcConfig => plcConfig.MonitorSetCollection).Select(ms => ms.OpConfig).ToList().ForEach(c =>
                {
                    IHalconToolPath toolPath = c as IHalconToolPath;
                    if (toolPath != null)
                    {
                        toolPath.GetHalconToolPathList().ForEach(path =>
                        {
                            if (!string.IsNullOrWhiteSpace(path))
                            {
                                string directoryPath = Path.GetDirectoryName(path);
                                string fileName = Path.GetFileNameWithoutExtension(path);

                                HDevEngineTool tool = new HDevEngineTool(directoryPath);
                                tool.LoadProcedure(fileName);

                                _halconToolDict[path] = tool;
                            }
                        });
                    }
                });
            #endregion
        }

        public List<IDevice> GetDeviceList()
        {
            List<IDevice> list = new List<IDevice>();

            list.AddRange(PLCDict.Values);
            list.AddRange(RobotDict.Values);
            list.AddRange(AGVDict.Values);
            list.AddRange(CameraDict.Values);

            return list;
        }

        #region PLC监听

        private void Plc_OnMonitorInvoke(DateTime dt, MonitorSet monitorSet)
        {
            IOperationConfig config = monitorSet.OpConfig;
            string methodCode = monitorSet.MethodCode;
            object res = null;
            int reTryTimes = config.ReTryTimes;

            do
            {
                try
                {
                    //有IOperationConfig参数的调用
                    res = _processMethodDict[methodCode].Invoke(this, new object[] { config });
                    reTryTimes = -1;
                }
                catch (Exception invokeEX)  //流程动作异常失败
                {
                    Exception ex = invokeEX.InnerException == null ? invokeEX : invokeEX.InnerException;
                    reTryTimes--;

                    if (reTryTimes <= 0) //如果没有重试次数了就通知PLC
                    {
                        if (config == null || config.ExceptionValue == 0)
                        {
                            if (!(ex is ProcessException))
                            {
                                //如果是算法异常，返回NG值；否则返回异常值
                                if (ex is HDevEngineException)
                                {
                                    res = new ProcessResponse((int)ReturnValue.NGVALUE);
                                }
                                else
                                {
                                    res = new ProcessResponse((int)ReturnValue.EXCEPTIONVALUE);
                                }

                                var newEx = new ProcessException("函数" + methodCode + "执行异常", ex);
                            }
                            else
                            {
                                if ((ex as ProcessException).OriginalException != null)
                                {
                                    res = new ProcessResponse((int)ReturnValue.EXCEPTIONVALUE);
                                }
                                else
                                {
                                    res = new ProcessResponse((int)ReturnValue.NGVALUE);
                                }
                            }
                        }
                        else
                        {
                            res = new ProcessResponse(config.ExceptionValue);
                        }

                        LogAsync(DateTime.Now, methodCode + "异常信息", ex.GetExceptionMessage());
                    }
                }

                if (reTryTimes > 0)
                {
                    LogAsync(DateTime.Now, methodCode + " reTryTimes", reTryTimes.ToString());
                }
            } while (reTryTimes > 0);

            #region 设置返回值
            monitorSet.Response = res as ProcessResponse;

            //测试模式下始终反馈OK信号
            if (StationConfig.IsDemoMode && monitorSet.Response.ResultValue <= 0)
            {
                monitorSet.Response.ResultValue = (int)ReturnValue.OKVALUE;
            }
            #endregion

            //sw.Stop();
            //LogAsync(DateTime.Now, methodCode + " 调用耗时: " + sw.ElapsedMilliseconds.ToString() + "ms", "");
            //TimeRecordCSV(DateTime.Now, methodCode + "调用", (int)sw.ElapsedMilliseconds);
            //sw.Start();

            #region 原有PLC写入结果操作，现转到异步调用后回调去执行
            //ProcessResponse resValues = res as ProcessResponse;

            //if (resValues.ResultValue == (int)PLCReplyValue.IGNORE)
            //{
            //    return;
            //}

            //if (monitorSet.ReplyDataAddress != -1 && resValues.DataList.Count > 0)
            //{
            //    PLC_ITEM item = new PLC_ITEM();
            //    item.OP_TYPE = 2;
            //    item.ITEM_LENGTH = resValues.DataList.Count;
            //    item.ADDRESS = monitorSet.ReplyDataAddress.ToString();
            //    item.ITEM_VALUE = String.Join(",", resValues.DataList);
            //    PLC.WriteItem(item, false);
            //}

            //if (monitorSet.NoticeAddress != -1)
            //{
            //    //测试模式下始终反馈OK信号
            //    if (StationConfig.IsDemoMode && resValues.ResultValue <= 0)
            //    {
            //        resValues.ResultValue = (int)ReturnValue.OKVALUE;
            //    }

            //    int repeatTime = 5;

            //    //LogAsync(DateTime.Now, methodCode + "开始反馈", "");
            //    do
            //    {
            //        try
            //        {
            //            PLC.WriteSingleAddress(set.NoticeAddress, resValues.ResultValue, false);
            //            repeatTime = 0;
            //        }
            //        catch (Exception ex)
            //        {
            //            repeatTime--;

            //            if (repeatTime <= 0)
            //            {
            //                new ProcessException("PLC反馈写入异常", ex);
            //            }
            //        }
            //    } while (repeatTime > 0);
            //}
            #endregion
        }

        private void Plc_OnMonitorAlarm(DateTime dt, WarningSet warning, bool isAlarmRaised)
        {
        }

        //List<int> _monitorList = new List<int>();
        //List<MonitorSet> _monitorSetList = new List<MonitorSet>();
        //List<string> _methodCodeList = new List<string>();

        //ConcurrentDictionary<string, Task> _halconTaskDict = new ConcurrentDictionary<string, Task>();
        //ConcurrentDictionary<string, AutoResetEvent> _halconHandleDict = new ConcurrentDictionary<string, AutoResetEvent>();

        ///// <summary>
        ///// PLC监听
        ///// </summary>
        //private void PLCMonitor()
        //{
        //    _monitorSetList = StationConfig.PLCMonitorSet.Values.ToList();
        //    _methodCodeList = StationConfig.PLCMonitorSet.Keys.ToList();

        //    while (PLC.CurrentState == DeviceState.DSOpen)
        //    {
        //        try
        //        {
        //            List<int> newMonitorList = PLC.Monitor(PLC.IConfig.EventStartAddress, PLC.IConfig.EventLength);

        //            if (newMonitorList == null || newMonitorList.Count == 0)
        //                continue;

        //            Stopwatch sw = new Stopwatch();
        //            sw.Start();
        //            if (_monitorList.Count == newMonitorList.Count)
        //            {
        //                var tempNew = new List<int>(newMonitorList);
        //                var tempOld = new List<int>(_monitorList);
        //                //Task.Run(() =>
        //                //{
        //                MonitorCheckAndInvoke(tempNew, tempOld);
        //                //});
        //            }
        //            _monitorList = new List<int>(newMonitorList);
        //            sw.Stop();

        //            if (sw.ElapsedMilliseconds > 10)
        //            {
        //                LogAsync(DateTime.Now, $"轮询时间：{sw.ElapsedMilliseconds}", "");
        //                TimeRecordCSV(DateTime.Now, "轮询时间", (int)sw.ElapsedMilliseconds);
        //            }

        //            Thread.Sleep(PLC.IConfig.ScanInterval);
        //        }
        //        catch (Exception ex)
        //        {
        //            LogAsync(DateTime.Now, "PLC监听异常", ex.GetExceptionMessage());
        //        }
        //    };
        //}

        //private void MonitorCheckAndInvoke(List<int> newMonitorList, List<int> monitorList)
        //{
        //    //await Task.Run(() =>
        //    {
        //        Parallel.For(0, monitorList.Count, (index) =>
        //        //for (int index = 0; index < monitorList.Count; index++)
        //        {
        //            int plcValue = newMonitorList[index];
        //            int plcOldValue = monitorList[index];

        //            #region PLC警报信息
        //            //bool warningSignal = (index >= Config.PLCConfig.WarningStartIndex && index < Config.PLCConfig.WarningStartIndex + Config.PLCConfig.WarningLength);

        //            // if (warningSignal)
        //            // {
        //            //     if (plcValue != plcOldValue)
        //            //     {
        //            //         int warningIndex = index - Config.PLCConfig.WarningStartIndex;
        //            //         for (int i = 0; i < 16; i++)
        //            //         {
        //            //             var ws = StationConfig.WarningSets.FirstOrDefault(w => w.WaringIndex == (warningIndex * 16) + i);

        //            //             if (ws != null)
        //            //             {
        //            //                 int newValue = plcValue >> i & 1;
        //            //                 int oldValue = plcOldValue >> i & 1;

        //            //                 if (newValue != oldValue)
        //            //                 {
        //            //                    //CurrentPubSub.Publish(PubTag.PLCWarningUpdate.ToString(), newValue == 1, ws, true);

        //            //                    //仅保存警报信息，不保存提示信息
        //            //                    if (ws.WarningLvl == 0)
        //            //                     {
        //            //                         if (newValue == 1)
        //            //                         {
        //            //                             if (!_warningRemains.Contains(ws.WarningCode))
        //            //                             {
        //            //                                 _warningRemains.Add(ws.WarningCode);
        //            //                             }
        //            //                         }
        //            //                         else
        //            //                         {
        //            //                             if (_warningRemains.Contains(ws.WarningCode))
        //            //                             {
        //            //                                 _warningRemains.Remove(ws.WarningCode);
        //            //                             }
        //            //                         }

        //            //                         SaveAlarm(Config.StationCode, ws, newValue);
        //            //                     }
        //            //                 }
        //            //             }
        //            //         }
        //            //     }

        //            //    //continue;
        //            //    return;
        //            // }
        //            #endregion

        //            if (plcValue != plcOldValue)
        //            {
        //                _monitorSetList.Where(u => u.TriggerIndex == index).ToList().ForEach(monitorSet =>
        //                {
        //                    int monitorSetIndex = _monitorSetList.IndexOf(monitorSet);
        //                    string methodCode = _methodCodeList[monitorSetIndex];
        //                    LogAsync(DateTime.Now, $"索引{monitorSet.TriggerIndex}变动,方法：{methodCode}", $"原先值：{plcOldValue}，变化值:{plcValue}");

        //                    //触发值为-999时，监听地址数据变动即触发函数
        //                    if (monitorSet != null && (plcValue == monitorSet.TriggerValue || monitorSet.TriggerValue == -999))
        //                    {
        //                        List<int> inputData = new List<int>();
        //                        if (monitorSet.InputDataIndex != null && monitorSet.InputDataIndex.Count > 0)
        //                        {
        //                            monitorSet.InputDataIndex.ForEach(p =>
        //                            {
        //                                inputData.Add(newMonitorList[p]);
        //                            });
        //                        }

        //                        LogAsync(DateTime.Now, "PLC触发", methodCode + "触发\r\n触发值：" + plcValue + ";传入值：" + (inputData == null || inputData.Count == 0 ? "NA" : string.Join(",", inputData)));

        //                        if (_halconToolDict.Keys.Contains(methodCode))
        //                        {
        //                            if (!_halconTaskDict.Keys.Contains(methodCode))
        //                            {
        //                                _halconHandleDict[methodCode] = new AutoResetEvent(false);
        //                                _halconTaskDict[methodCode] = new Task((obj) =>
        //                                {
        //                                    while (true)
        //                                    {
        //                                        _halconHandleDict[methodCode].WaitOne();

        //                                        if (PLC.CurrentState != DeviceState.DSOpen)
        //                                            continue;

        //                                        object[] objs = obj as object[];
        //                                        int msIndex = Convert.ToInt32(objs[0]);
        //                                        MonitorSet set = objs[1] as MonitorSet;
        //                                        List<int> inputDataIndex = objs[2] as List<int>;
        //                                        List<int> datas = new List<int>();

        //                                        if (inputDataIndex != null)
        //                                        {
        //                                            inputDataIndex.ForEach(p =>
        //                                            {
        //                                                datas.Add(newMonitorList[p]);
        //                                            });
        //                                        }

        //                                        MethodHandle(msIndex, set, datas, plcValue);
        //                                    }
        //                                }, new object[] { monitorSetIndex, monitorSet, monitorSet.InputDataIndex });

        //                                _halconTaskDict[methodCode].Start();
        //                            }

        //                            _halconHandleDict[methodCode].Set();
        //                        }
        //                        else
        //                        {
        //                            ThreadPool.QueueUserWorkItem(MethodHandle, new object[] { monitorSetIndex, monitorSet, inputData, plcValue });
        //                        }
        //                    }
        //                });
        //            }
        //        }
        //        );
        //    }
        //    //);
        //}

        //private void MethodHandle(object obj)
        //{
        //    object[] objs = obj as object[];
        //    int monitorSetIndex = Convert.ToInt32(objs[0]);
        //    MonitorSet set = objs[1] as MonitorSet;
        //    List<int> inputDataValue = objs[2] as List<int>;
        //    int triggerValue = Convert.ToInt32(objs[3]);

        //    MethodHandle(monitorSetIndex, set, inputDataValue, triggerValue);
        //}

        //private void MethodHandle(int monitorSetIndex, MonitorSet set, List<int> inputDataValue, int triggerValue)
        //{
        //    //await Task.Run(() =>
        //    //Task.Run(() =>
        //    {
        //        string methodCode = _methodCodeList[monitorSetIndex];
        //        Stopwatch sw = new Stopwatch();
        //        sw.Start();

        //        try
        //        {
        //            if (_processMethodDict.Keys.Contains(methodCode))
        //            {
        //                IOperationConfig config = null;
        //                if (StationConfig.ProcessOpConfigDict.Keys.Contains(methodCode))
        //                {
        //                    config = StationConfig.ProcessOpConfigDict[methodCode];
        //                }
        //                else
        //                {
        //                    config = new OperationConfigBase();
        //                }

        //                config.InputPara = inputDataValue;

        //                object res = null;
        //                int reTryTimes = config.ReTryTimes;

        //                do
        //                {
        //                    try
        //                    {
        //                        //有IOperationConfig参数的调用
        //                        res = _processMethodDict[methodCode].Invoke(this, new object[] { config });
        //                        reTryTimes = -1;
        //                    }
        //                    catch (Exception invokeEX)  //流程动作异常失败
        //                    {
        //                        Exception ex = invokeEX.InnerException == null ? invokeEX : invokeEX.InnerException;
        //                        reTryTimes--;

        //                        if (reTryTimes <= 0) //如果没有重试次数了就通知PLC
        //                        {
        //                            //保存最后一次NG的图片
        //                            //SaveNGImage(_processMethodDict[methodCode]);

        //                            if (config == null || config.ExceptionValue == 0)
        //                            {
        //                                if (!(ex is ProcessException))
        //                                {
        //                                    //CurrentPubSub.Publish(PubTag.ExceptionUpdate.ToString(), "函数" + methodCode + "执行异常", ex, true);

        //                                    //如果是算法异常，返回NG值；否则返回异常值
        //                                    if (ex is HDevEngineException)
        //                                    {
        //                                        res = new ProcessResponse((int)ReturnValue.NGVALUE);
        //                                    }
        //                                    else
        //                                    {
        //                                        res = new ProcessResponse((int)ReturnValue.EXCEPTIONVALUE);
        //                                    }

        //                                    var newEx = new ProcessException("函数" + methodCode + "执行异常", ex);
        //                                }
        //                                else
        //                                {
        //                                    if ((ex as ProcessException).OriginalException != null)
        //                                    {
        //                                        res = new ProcessResponse((int)ReturnValue.EXCEPTIONVALUE);
        //                                    }
        //                                    else
        //                                    {
        //                                        res = new ProcessResponse((int)ReturnValue.NGVALUE);
        //                                    }
        //                                }
        //                            }
        //                            else
        //                            {
        //                                res = new ProcessResponse(config.ExceptionValue);
        //                            }

        //                            LogAsync(DateTime.Now, methodCode + "异常信息", ex.GetExceptionMessage());
        //                        }
        //                    }

        //                    if (reTryTimes > 0)
        //                    {
        //                        LogAsync(DateTime.Now, methodCode + " reTryTimes", reTryTimes.ToString());
        //                    }
        //                } while (reTryTimes > 0);

        //                sw.Stop();
        //                LogAsync(DateTime.Now, methodCode + " 调用耗时: " + sw.ElapsedMilliseconds.ToString() + "ms", "");
        //                TimeRecordCSV(DateTime.Now, methodCode + "调用", (int)sw.ElapsedMilliseconds);
        //                sw.Start();

        //                ProcessResponse resValues = res as ProcessResponse;

        //                //if (resValues != null)
        //                //{
        //                if (resValues.ResultValue == (int)PLCReplyValue.IGNORE)
        //                {
        //                    return;
        //                }

        //                if (set.ReplyDataAddress != -1 && resValues.DataList.Count > 0)
        //                {
        //                    //int stepLength = 120;
        //                    //int startAdd = set.ReplyDataAddress;

        //                    //while (resValues.DataList.Count > 0)
        //                    //{
        //                    //    var data = resValues.DataList.Take(stepLength).ToList();

        //                    //    PLC_ITEM item = new PLC_ITEM();
        //                    //    item.OP_TYPE = 2;
        //                    //    item.ITEM_LENGTH = data.Count;
        //                    //    item.ADDRESS = startAdd.ToString();
        //                    //    item.ITEM_VALUE = String.Join(",", data);
        //                    //    PLC.WriteItem(item);

        //                    //    if (resValues.DataList.Count > stepLength)
        //                    //    {
        //                    //        startAdd += stepLength;
        //                    //        resValues.DataList = resValues.DataList.Skip(stepLength).ToList();
        //                    //    }
        //                    //}

        //                    //if (resValues.DataList.Count > 0)
        //                    //{
        //                    PLC_ITEM item = new PLC_ITEM();
        //                    item.OP_TYPE = 2;
        //                    item.ITEM_LENGTH = resValues.DataList.Count;
        //                    item.ADDRESS = set.ReplyDataAddress.ToString();
        //                    item.ITEM_VALUE = String.Join(",", resValues.DataList);
        //                    PLC.WriteItem(item, false);
        //                    //}
        //                }

        //                if (set.NoticeAddress != -1)
        //                {
        //                    //测试模式下始终反馈OK信号
        //                    if (StationConfig.IsDemoMode && resValues.ResultValue <= 0)
        //                    {
        //                        resValues.ResultValue = (int)ReturnValue.OKVALUE;
        //                    }

        //                    int repeatTime = 5;

        //                    //LogAsync(DateTime.Now, methodCode + "开始反馈", "");
        //                    do
        //                    {
        //                        try
        //                        {
        //                            PLC.WriteSingleAddress(set.NoticeAddress, resValues.ResultValue, false);
        //                            repeatTime = 0;
        //                        }
        //                        catch (Exception ex)
        //                        {
        //                            repeatTime--;

        //                            if (repeatTime <= 0)
        //                            {
        //                                new ProcessException("PLC反馈写入异常", ex);
        //                            }
        //                        }
        //                    } while (repeatTime > 0);
        //                    //LogAsync(DateTime.Now, methodCode + "结束反馈", "");
        //                }
        //                //}
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogAsync(DateTime.Now, _methodCodeList[monitorSetIndex] + "调用异常", ex.GetExceptionMessage());
        //        }
        //        //finally
        //        //{
        //        //    //IdleFlag--;
        //        //    //_idleTimer.Change(BaseConfig.IdleTimeThreshold * 1000, Timeout.Infinite);

        //        //}

        //        sw.Stop();
        //        LogAsync(DateTime.Now, methodCode + " Elapsed: " + sw.ElapsedMilliseconds.ToString() + "ms", "");
        //        TimeRecordCSV(DateTime.Now, methodCode + "完成", (int)sw.ElapsedMilliseconds);
        //    }
        //    //);
        //}

        //private async void CTHandle(OperationCTCollection ct, int plcValue)
        //{
        //    await Task.Run(() =>
        //    {
        //        if (plcValue == 0)
        //        {
        //            ct.CSVOutput(StationConfig.CSVFilePath);

        //            //ct.CTList.ForEach(u =>
        //            foreach (var u in ct.CTList)
        //            {
        //                u.StartTime = null;
        //                u.EndTime = null;
        //            }
        //            //);

        //            //CurrentPubSub.Publish(PubTag.CTUpdate.ToString(), ct, null, true);
        //        }
        //        else
        //        {
        //            for (int i = 0; i < ct.CTList.Count; i++)
        //            {
        //                if (plcValue == ct.CTList[i].OpTrigger)
        //                {
        //                    DateTime dt = DateTime.Now;

        //                    if (i < ct.CTList.Count - 1)
        //                    {
        //                        ct.CTList[i].StartTime = dt;
        //                    }

        //                    if (i > 1)
        //                    {
        //                        ct.CTList[i - 1].EndTime = dt;
        //                    }

        //                    //CurrentPubSub.Publish(PubTag.CTUpdate.ToString(), ct, null, true);
        //                    break;
        //                }
        //            }
        //        }
        //    });
        //}

        //public virtual ProcessResponse MonitorMethodInvoke(string methodCode, IOperationConfig config)
        //{
        //    return _processMethodDict[methodCode].Invoke(this, new object[] { config }) as ProcessResponse;
        //    //return null;
        //}
        #endregion

        #region 图像处理
        protected Dictionary<string, Queue<string>> CameraBitmapDict = new Dictionary<string, Queue<string>>();
        //protected Dictionary<string, Bitmap> CameraBitmapDict = new Dictionary<string, Bitmap>();

        protected HObject CollectHImage(CameraBase camera, IOperationConfig opConfig, string cameraId, string methodCode)
        {
            HObject hImage = null;

            if (StationConfig.IsImageOffline)
            {
                using (OfflineImageFrm oiF = new OfflineImageFrm())
                {
                    if (oiF.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        hImage = oiF.HImg;
                    }
                    else
                    {
                        //MessageBox.Show("未能获取离线图片！");
                        throw new ProcessException("未能获取离线图片！", null);
                    }
                }
            }
            else
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();

                var cameraConifg = opConfig as HalconRelatedCameraOprerationConfigBase;
                if (cameraConifg.DelayBefore > 0)
                {
                    Thread.Sleep(cameraConifg.DelayBefore);
                }

                camera.UploadOperationConfig(opConfig);
                camera.Snapshot(opConfig, out hImage);

                //SaveTempImage(cameraName, camera.ImageFilePath);
                //SaveTempImage(camera, cameraId);

                if (cameraConifg.DelayAfter > 0)
                {
                    Thread.Sleep(cameraConifg.DelayAfter);
                }

                sw.Stop();
                LogAsync(DateTime.Now, $"{methodCode}采图耗时:{sw.ElapsedMilliseconds}ms", "");
                TimeRecordCSV(DateTime.Now, methodCode + "采图", (int)sw.ElapsedMilliseconds);
            }

            return hImage;
        }

        //private async void SaveTempImage(string cameraName, string imgFilePath)
        //{
        //    await Task.Run(() =>
        //    {
        //        //if (!string.IsNullOrWhiteSpace(cameraId))
        //        //{
        //        //    //if (CameraBitmapDict.ContainsKey(cameraId) && CameraBitmapDict[cameraId] != null)
        //        //    //{
        //        //    //    CameraBitmapDict[cameraId].Dispose();
        //        //    //    CameraBitmapDict[cameraId] = null;
        //        //    //}
        //        //    CameraBitmapDict[cameraId] = imgFilePath;
        //        //}

        //        CameraBitmapDict[cameraName] = imgFilePath;
        //    });
        //}

        private async void SaveTempImage(CameraBase camera, string cameraId)
        {
            await Task.Run(() =>
            {
                //if (!string.IsNullOrWhiteSpace(cameraId))
                //{
                //    //if (CameraBitmapDict.ContainsKey(cameraId) && CameraBitmapDict[cameraId] != null)
                //    //{
                //    //    CameraBitmapDict[cameraId].Dispose();
                //    //    CameraBitmapDict[cameraId] = null;
                //    //}
                //    CameraBitmapDict[cameraId] = imgFilePath;
                //}

                //camera.ImageGetHandle.WaitOne();
                //CameraBitmapDict[cameraName] = camera.ShowImage;

                if (string.IsNullOrWhiteSpace(cameraId))
                    return;

                camera.ImageSaveDoneHandle.WaitOne();

                if (!CameraBitmapDict.ContainsKey(cameraId))
                {
                    CameraBitmapDict.Add(cameraId, new Queue<string>());
                }
                CameraBitmapDict[cameraId].Enqueue(camera.ImageFilePath);
            });
        }

        protected async void CameraUpdateImage(CameraBase camera, Bitmap image, string imageFilePath)
        {
            await Task.Run(() =>
            {
                OnBitmapOutput?.Invoke(camera.InitialConfig.ID, image);
            });
        }

        //protected async void SaveNGImage(MethodInfo methodInfo)
        //{
        //    await Task.Run(() =>
        //    {
        //        try
        //        {
        //            if (string.IsNullOrWhiteSpace(Config.NGImageFolderPath))
        //                return;

        //            var attr = methodInfo.GetCustomAttribute<CameraInvokeAttribute>();
        //            if (attr == null)
        //                return;

        //            SaveCameraImage(attr.CameraName);
        //        }
        //        catch (Exception ex)
        //        {
        //            LogAsync(DateTime.Now, "保存NG图片异常", ex.GetExceptionMessage());
        //        }
        //    });
        //}

        //protected void SaveCameraImage(string cameraName)
        //{
        //    try
        //    {
        //        if (CameraBitmapDict.ContainsKey(cameraName))
        //        {
        //            DirectoryInfo dir = new DirectoryInfo(Path.Combine(Config.NGImageFolderPath, DateTime.Now.ToString("yyyyMMdd")));
        //            if (!dir.Exists)
        //                dir.Create();

        //            //string imageFilePath = Path.Combine(dir.FullName, DateTime.Now.ToString("HHmmssfff") + ".jpg");

        //            //if (CameraBitmapDict[cameraName] != null)
        //            //    CameraBitmapDict[cameraName].Save(imageFilePath, ImageFormat.Jpeg);

        //            FileInfo file = new FileInfo(CameraBitmapDict[cameraName]);
        //            if (file.Exists)
        //            {
        //                file.CopyTo(Path.Combine(dir.FullName, file.Name));
        //            }
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        LogAsync(DateTime.Now, "保存相机图片异常", ex.GetExceptionMessage());
        //    }
        //}

        //private async void SaveFitImage(CameraBase camera, HalconRelatedCameraOprerationConfigBase config, List<ElementBase> list)
        //{
        //    await Task.Run(() =>
        //    {
        //        if (!config.IsSaveFitImage)
        //            return;

        //        if (string.IsNullOrWhiteSpace(config.FitImagePath))
        //            return;

        //        string imageFilePath = "";

        //        int repeatTime = 15;
        //        do
        //        {
        //            if (CameraBitmapDict.ContainsKey(camera.InitialConfig.ID) && CameraBitmapDict[camera.InitialConfig.ID].Count > 0)
        //            {
        //                imageFilePath = CameraBitmapDict[camera.InitialConfig.ID].Dequeue();
        //            }

        //            if (string.IsNullOrWhiteSpace(imageFilePath) || !File.Exists(imageFilePath))
        //            {
        //                repeatTime--;
        //                Thread.Sleep(50);
        //            }
        //            else
        //            {
        //                repeatTime = 0;
        //            }

        //        } while (repeatTime > 0);

        //        if (string.IsNullOrWhiteSpace(imageFilePath))
        //            return;

        //        var dir = new DirectoryInfo(Path.Combine(config.FitImagePath, DateTime.Now.ToString("yyyyMMdd")));
        //        if (!dir.Exists)
        //        {
        //            dir.Create();
        //        }

        //        repeatTime = 10;
        //        do
        //        {
        //            try
        //            {
        //                string fileName = Path.GetFileNameWithoutExtension(imageFilePath);
        //                fileName = Path.Combine(dir.FullName, fileName + ".jpg");
        //                Bitmap image = (Bitmap)Image.FromFile(imageFilePath);

        //                SaveFitImage(image, list, fileName);

        //                repeatTime = 0;
        //            }
        //            catch (Exception ex)
        //            {
        //                repeatTime--;
        //                LogAsync(DateTime.Now, "保存拟合图片异常1", ex.GetExceptionMessage());
        //                Thread.Sleep(500);
        //            }
        //        } while (repeatTime > 0);
        //    });
        //}

        //[HandleProcessCorruptedStateExceptions]
        //private async void SaveFitImage(Bitmap image, List<ElementBase> eleList, string fileName)
        //{
        //    await Task.Run(() =>
        //    {
        //        if (image == null)
        //            return;

        //        Bitmap map = new Bitmap(image.Width, image.Height);
        //        using (Graphics g = Graphics.FromImage(map))
        //        {
        //            int saveRetry = 15;
        //            do
        //            {
        //                try
        //                {
        //                    g.DrawImage(image, 0, 0);

        //                    eleList.ForEach(e =>
        //                    {
        //                        int repeatTime = 5;
        //                        do
        //                        {
        //                            try
        //                            {
        //                                e.State = ElementState.Normal;
        //                                e.Draw(g);
        //                                repeatTime = 0;
        //                            }
        //                            catch (Exception)
        //                            {
        //                                repeatTime--;
        //                            }
        //                        } while (repeatTime > 0);
        //                    });

        //                    map.Save(fileName, ImageFormat.Jpeg);
        //                    saveRetry = 0;
        //                }
        //                //catch (System.AccessViolationException ex)
        //                //{
        //                //    saveRetry--;
        //                //    LogAsync(DateTime.Now, "保存拟合图片异常2", ex.GetExceptionMessage());

        //                //    Thread.Sleep(100);
        //                //}
        //                catch (Exception ex)
        //                {
        //                    saveRetry--;
        //                    LogAsync(DateTime.Now, "保存拟合图片异常2", ex.GetExceptionMessage());

        //                    Thread.Sleep(100);
        //                }
        //            } while (saveRetry > 0);
        //        }

        //        map.Dispose();
        //        image.Dispose();
        //    });
        //}
        #endregion

        #region 报警和DownTime
        public ObservableCollection<string> _warningRemains = new ObservableCollection<string>();

        bool warningRemainFlag = false;
        bool WarningRemainFlag
        {
            get
            {
                return warningRemainFlag;
            }
            set
            {
                if (value && !warningRemainFlag)
                {
                    //CurrentPubSub.Publish(EnumHelper.PubTag.DownTimeNotice.ToString(), true, null, true);
                    //SaveDownTime(DateTime.Now, true);
                }

                if (!value)
                {
                    //CurrentPubSub.Publish(EnumHelper.PubTag.DownTimeNotice.ToString(), false, null, true);
                    //SaveDownTime(DateTime.Now, false);
                }

                warningRemainFlag = value;
            }
        }

        private void _warningRemains_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            //lock (_idleTimeLock)
            //{
            //    if (_warningRemains.Count == 0)
            //    {
            //        if (!_idleFlag)
            //        {
            //            StartIdleRecordAsync();
            //        }

            //        WarningRemainFlag = false;
            //    }
            //    else
            //    {
            //        if (_idleFlag)
            //        {
            //            //_idleFlag = false;
            //            EndIdleRecordAsync();
            //        }

            //        WarningRemainFlag = true;
            //    }
            //}
        }

        private void SaveAlarm(string stationCode, WarningSet ws, int newValue)
        {
        }
        #endregion

        #region Log
        static object logObj = new object();
        public Action<DateTime, string, string> OnLog;
        public virtual async void LogAsync(DateTime dt, string prefix, string msg)
        {
            await Task.Run(() =>
            {
                OnLog?.BeginInvoke(dt, prefix, msg, null, null);

                if (!StationConfig.IsLogEnabled)
                    return;

                DirectoryInfo dir = new DirectoryInfo(StationConfig.LogPath);
                if (!dir.Exists)
                {
                    dir.Create();
                }

                string logPath = Path.Combine(StationConfig.LogPath, DateTime.Today.ToString("yyyyMMdd") + ".txt");

                lock (logObj)
                {
                    using (StreamWriter writer = new StreamWriter(logPath, true, System.Text.Encoding.UTF8))
                    {
                        //writer.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                        writer.WriteLine(dt.ToString("yyyy-MM-dd HH:mm:ss.fff"));
                        writer.WriteLine(prefix);
                        writer.Write(msg);
                        writer.WriteLine();
                        writer.WriteLine();

                        writer.Flush();
                        writer.Close();
                    }
                }
            });
        }

        protected void OnDeviceLog(DateTime dt, IDevice device, string msg)
        {
            LogAsync(dt, device.InitialConfig.Name, msg);
        }

        static object csvLock = new object();
        private async void TimeRecordCSV(DateTime dt, string desc, int ms)
        {
            await Task.Run(() =>
            {
                lock (csvLock)
                {
                    string filePath = Path.Combine(Config.LogPath, $"TimeRecords_{DateTime.Now.ToString("yyyyMMdd")}.csv");
                    bool isFileExisted = File.Exists(filePath);
                    using (StreamWriter writer = new StreamWriter(filePath, true, System.Text.Encoding.UTF8))
                    {
                        if (!isFileExisted)
                        {
                            writer.WriteLine("Time,Prefix,Consumed");
                        }
                        writer.WriteLine($"{dt.ToString("HH:mm:ss.fff")},{desc},{ms}");
                        writer.Flush();
                        writer.Close();
                    }
                }
            });
        }
        #endregion

        #region 临时数据保存和读取
        protected static Dictionary<string, object> _tempDataLock = new Dictionary<string, object>();
        protected string _tempFileDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TempData");

        protected virtual T ReadTempDataFromHistory<T>(T t, string propertyName) where T : class
        {
            if (!_tempDataLock.ContainsKey(propertyName))
            {
                _tempDataLock[propertyName] = new object();
            }

            if (t != null)
            {
                return t;
            }
            else
            {
                if (!Directory.Exists(_tempFileDirectory))
                {
                    Directory.CreateDirectory(_tempFileDirectory);
                }

                string filePath = Path.Combine(_tempFileDirectory, propertyName);

                if (!File.Exists(filePath))
                {
                    return null;
                }

                lock (_tempDataLock[propertyName])
                {
                    using (StreamReader reader = new StreamReader(filePath, System.Text.Encoding.UTF8))
                    {
                        string content = reader.ReadToEnd();
                        var result = JsonConvert.DeserializeObject<T>(content);
                        return result;
                    }
                }
            }
        }

        protected virtual void SaveTempData<T>(T t, string propertyName, string defaultStr = "")
        {
            //await Task.Run(() =>
            {
                if (!_tempDataLock.ContainsKey(propertyName))
                {
                    _tempDataLock[propertyName] = new object();
                }

                lock (_tempDataLock[propertyName])
                {
                    try
                    {
                        if (!Directory.Exists(_tempFileDirectory))
                        {
                            Directory.CreateDirectory(_tempFileDirectory);
                        }

                        string serialStr = JsonConvert.SerializeObject(t);

                        if (!string.IsNullOrWhiteSpace(defaultStr))
                        {
                            if (t == null)
                            {
                                serialStr = defaultStr;
                            }
                        }
                        else
                        {
                            if (t == null)
                                return;
                        }

                        string filePath = Path.Combine(_tempFileDirectory, propertyName);

                        using (StreamWriter writer = new StreamWriter(filePath, false, System.Text.Encoding.UTF8))
                        {
                            writer.Write(serialStr);
                            writer.Flush();
                            writer.Close();
                        }
                    }
                    catch (Exception)
                    {
                    }
                }
            }
            //);
        }
        #endregion
    }

    public enum ReturnValue
    {
        OKVALUE = 1,
        NGVALUE = -1,
        EXCEPTIONVALUE = -2,
        LEVEL3EXCEPTION = -3,
        INCOMINGMATERIALEXCEPTION = -4,
    }
}