using Aitex.Common.Util;
using Aitex.Core.Common;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.DBCore;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.UI.Control;
using Aitex.Core.Util;
using Caliburn.Micro.Core;
using DocumentFormat.OpenXml.Wordprocessing;
using FurnaceRT.Devices;
using FurnaceRT.Equipments.Boats;
using FurnaceRT.Equipments.Systems;
using FurnaceRT.Equipments.WaferRobots;
using MECF.Framework.Common.CommonData.EnumData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.Utilities;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using TwinCAT.Ads.Internal;
using static Aitex.Core.RT.Device.Unit.IoBoat;
using static log4net.Appender.RollingFileAppender;

namespace FurnaceRT.Equipments.PMs
{
    /// <summary>
    /// 分布类 定义各种方法
    /// </summary>
    public partial class PMModule
    {

        private static Dictionary<string, Dictionary<string, string>> _allWaferTypeNode = new Dictionary<string, Dictionary<string, string>>();


        private void InitOtherData()
        {

            DATA.Subscribe($"System.CompareFileDataA", () => _compareADic, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"System.CompareFileDataB", () => _compareBDic, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"System.SCDataLastWriteTime", () => GetSCDataLastWriteTime(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"System.BackUpFileData", () => GetAllBackUpFiles(), SubscriptionAttribute.FLAG.IgnoreSaveDB);

        }
        private void InitOtherOP()
        {
            OP.Subscribe($"System.BackUpFileData", (string cmd, object[] args) =>
            {
                BackUpFileDataMethod();
                return true;
            });
            OP.Subscribe($"System.CreateZIP", (string cmd, object[] args) =>
            {
                CreateZIPMethod();
                return true;
            });
            OP.Subscribe($"System.CompareFileData", CompareFileDataMethod);
            OP.Subscribe($"System.RollBackFileData", RollBackFileDataMethod);
        }



        #region 备份/ZIP

        private Dictionary<string, string> _compareADic = new Dictionary<string, string>();
        private Dictionary<string, string> _compareBDic = new Dictionary<string, string>();
        private int _backUpFileMaxNumber = 10;
        private Dictionary<string, List<string>> GetAllBackUpFiles()
        {
            Dictionary<string, List<string>> result = new Dictionary<string, List<string>>();
            string sourcePath = $"{PathManager.GetCfgDir()}";
            string backUpFolderPath = Path.Combine(sourcePath, BackUpDireEnum.BackUp.ToString());
            if (!Directory.Exists(backUpFolderPath))
            {
                Directory.CreateDirectory(backUpFolderPath);
            }
            var allDires = new DirectoryInfo(backUpFolderPath).GetDirectories();
            foreach (var item in allDires)
            {
                var direFiles = item.GetFiles().OrderByDescending(a => a.CreationTime).Select(a => a.Name).ToList();

                if (result.ContainsKey(item.Name))
                {
                    result[item.Name] = direFiles;
                }
                else
                {

                    result.Add(item.Name, direFiles);
                }
            }
            return result;
        }
        private void CreateZIPMethod()
        {
            _backUpFileMaxNumber = SC.GetValue<int>("System.BackUpFileMaxNumber");
            var startupPath = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion;
            string sourcePath = Path.GetDirectoryName(PathManager.GetAppDir());
            string zipPath = $"{PathManager.GetAppDir()}\\ZIP";
            if (SC.ContainsItem("System.ZIPToDesktop") && SC.GetValue<bool>("System.ZIPToDesktop"))
                zipPath = $"{Environment.GetFolderPath(Environment.SpecialFolder.Desktop)}\\ZIP";

            string timestamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
            string zipAllPath = $"{zipPath}\\{timestamp}_{startupPath}.zip";
            if (!Directory.Exists(zipPath))
                Directory.CreateDirectory(zipPath);

            var allFiles = Directory.GetFiles(zipPath).OrderBy(f => new FileInfo(f).CreationTime).ToArray();
            if (allFiles.Count() >= _backUpFileMaxNumber)
                File.Delete(allFiles[0]);

            if (File.Exists(zipAllPath))
                File.Delete(zipAllPath);

            CreateZIP(sourcePath, zipAllPath);

        }
        private async void CreateZIP(string sourcePath, string zipAllPath)
        {
            await ZIPUtil.ZipAllExceptLogFolderAsync(sourcePath, zipAllPath);
        }
        private bool RollBackFileDataMethod(out string reason, int time, object[] param)
        {

            reason = string.Empty;
            if (param == null || param.Length == 0)
                return true;

            //先备份当前数据
            BackUpFileDataMethod();

            //在进行RollBack
            string sourcePath = $"{PathManager.GetCfgDir()}";

            var scDataPath = $"{sourcePath}\\_sc.data";
            var rollBackScDataPath = $"{sourcePath}\\{BackUpDireEnum.BackUp}\\{BackUpDireEnum.SC}\\{param[0]}";

            if (!File.Exists(rollBackScDataPath))
                return false;


            if (File.Exists(scDataPath))
                File.Delete(scDataPath);


            File.Copy(rollBackScDataPath, scDataPath, true);

            return true;
        }
        private bool CompareFileDataMethod(out string reason, int time, object[] param)
        {

            reason = string.Empty;
            if (param == null || param.Count() == 0)
                return true;

            string sourcePath = $"{Directory.GetCurrentDirectory()}";
            var dataPara = param[0].ToString().Split(',');
            if (dataPara.Count() == 1)
            {

                var compareAPath = $"{PathManager.GetCfgDir()}\\{BackUpDireEnum.BackUp}\\{BackUpDireEnum.SC}\\{dataPara[0]}";
                var compareBPath = $"{PathManager.GetCfgDir()}\\_sc.data";
                _compareADic = GetScDataByFilePath(compareAPath);
                _compareBDic = GetScDataByFilePath(compareBPath);
            }
            else if (dataPara.Count() == 2)
            {
                var compareAPath = $"{PathManager.GetCfgDir()}\\{BackUpDireEnum.BackUp}\\{BackUpDireEnum.SC}\\{dataPara[0]}";
                var compareBPath = $"{PathManager.GetCfgDir()}\\{BackUpDireEnum.BackUp}\\{BackUpDireEnum.SC}\\{dataPara[1]}";
                _compareADic = GetScDataByFilePath(compareAPath);
                _compareBDic = GetScDataByFilePath(compareBPath);
            }
            return true;
        }
        private string GetSCDataLastWriteTime()
        {
            var compareBPath = $"{PathManager.GetCfgDir()}\\_sc.data";
            return File.GetLastWriteTime(compareBPath).ToString("yyyy-MM-dd HH-mm-ss");

        }
        private Dictionary<string, string> GetScDataByFilePath(string filePath)
        {
            Dictionary<string, string> result = new Dictionary<string, string>();
            try
            {
                // 加载XML文件
                XDocument xmlDoc = XDocument.Load(filePath);

                // 获取所有的scdata元素
                var scDataElements = xmlDoc.Descendants("scdata");

                // 遍历每个scdata元素并打印其属性
                foreach (var element in scDataElements)
                {
                    string name = element.Attribute("name")?.Value ?? "N/A";
                    string value = element.Attribute("value")?.Value ?? "N/A";
                    if (result.ContainsKey(name))
                    {
                        result[name] = value;
                    }
                    else
                    {
                        result.Add(name, value);
                    }
                }
            }
            catch (Exception ex)
            {
                // 如果发生异常，捕获并显示错误消息
                Console.WriteLine("Error reading file: " + ex.Message);
            }

            return result;

        }
        private async void BackUpFileDataMethod()
        {
            _backUpFileMaxNumber = SC.GetValue<int>("System.BackUpFileMaxNumber");
            var dateTime = DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss");
            string sourcePath = $"{PathManager.GetAppDir()}";
            string newSourcePath = $"{PathManager.GetCfgDir()}";
            string backUpFolderPath = Path.Combine(newSourcePath, $"{BackUpDireEnum.BackUp}");
            string scFolderPath = Path.Combine(newSourcePath, $"{BackUpDireEnum.BackUp}\\{BackUpDireEnum.SC}");
            string ioFolderPath = Path.Combine(newSourcePath, $"{BackUpDireEnum.BackUp}\\{BackUpDireEnum.IO}");
            string recipeFolderPath = Path.Combine(newSourcePath, $"{BackUpDireEnum.BackUp}\\{BackUpDireEnum.Recipes}");
            string gasXmlFolderPath = Path.Combine(newSourcePath, $"{BackUpDireEnum.BackUp}\\{BackUpDireEnum.GasXml}");
            string objectsFolderPath = Path.Combine(newSourcePath, $"{BackUpDireEnum.BackUp}\\{BackUpDireEnum.Objects}");
            string parametersFolderPath = Path.Combine(newSourcePath, $"{BackUpDireEnum.BackUp}\\{BackUpDireEnum.Parameters}");
            // 检查 SC 文件夹并复制 sc.data 文件
            await CheckAndCopyFile(scFolderPath, Path.Combine(newSourcePath, "_sc.data"), $"{dateTime}@", "_sc.data");

            // 检查 IO 文件夹并复制 IO 文件夹内容
            await CheckAndCopyFolder(ioFolderPath, Path.Combine(newSourcePath, $"{BackUpDireEnum.IO}"), dateTime);

            // 检查 Recipe 文件夹并复制 Recipe 文件夹内容
            await CheckAndCopyFolder(recipeFolderPath, Path.Combine(sourcePath, $"{BackUpDireEnum.Recipes}"), dateTime);

            // 检查 GasXml 文件夹并复制 GasXml 文件夹内容
            await CheckAndCopyFolder(gasXmlFolderPath, Path.Combine($"{newSourcePath}", $"{BackUpDireEnum.GasXml}"), dateTime);

            // 检查 Objects 文件夹并复制 Objects 文件夹内容
            await CheckAndCopyFolder(objectsFolderPath, Path.Combine(sourcePath, $"{BackUpDireEnum.Objects}"), dateTime);

            // 检查 Parameters 文件夹并复制 Parameters 文件夹内容
            await CheckAndCopyFolder(parametersFolderPath, Path.Combine(sourcePath, $"{BackUpDireEnum.Parameters}"), dateTime);

            GetAllBackUpFiles();
        }
        private async Task CheckAndCopyFile(string targetFolderPath, string sourceFilePath, string prefixFileName, string fileName)
        {
            if (!Directory.Exists(targetFolderPath))
                Directory.CreateDirectory(targetFolderPath);
            var allpath = $"{prefixFileName}{fileName}";
            string destinationFilePath = Path.Combine(targetFolderPath, allpath);
            try
            {
                var filesWithSameName = Directory.GetFiles(targetFolderPath)
                                       .Where(f => Path.GetFileName(f).Contains(fileName))
                                       .OrderBy(f => new FileInfo(f).CreationTime)
                                       .ToArray();
                // If there are more than 10 files, delete the oldest one
                if (filesWithSameName.Length >= _backUpFileMaxNumber)
                {
                    File.Delete(filesWithSameName[0]);
                }

                if (File.Exists(destinationFilePath))
                    return;

                await Task.Run(() => File.Copy(sourceFilePath, destinationFilePath, true));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error copying {fileName}: {ex.Message}");
            }

        }

        private async Task CheckAndCopyFolder(string targetFolderPath, string sourceFolderPath, string dateTime)
        {
            if (!Directory.Exists(targetFolderPath))
                Directory.CreateDirectory(targetFolderPath);

            if (!Directory.Exists(sourceFolderPath))
            {
                return;
            }
            try
            {
                await CopyDirectory(sourceFolderPath, targetFolderPath, dateTime);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error copying folder {sourceFolderPath}: {ex.Message}");
            }

        }

        private async Task CopyDirectory(string sourceDirName, string destDirName, string dateTime)
        {
            // Get the subdirectories for the specified directory.
            DirectoryInfo dir = new DirectoryInfo(sourceDirName);

            if (!dir.Exists)
            {
                throw new DirectoryNotFoundException(
                    "Source directory does not exist or could not be found: "
                    + sourceDirName);
            }

            DirectoryInfo[] dirs = dir.GetDirectories();
            // If the destination directory doesn't exist, create it.
            if (!Directory.Exists(destDirName))
                Directory.CreateDirectory(destDirName);

            var newFies = new DirectoryInfo(destDirName).GetFiles().OrderBy(f => f.CreationTime).Select(a => a.Name).ToList();

            // Get the files in the directory and copy them to the new location.
            FileInfo[] files = dir.GetFiles();
            foreach (FileInfo file in files)
            {
                var sameFiles = newFies.Where(a => a.Contains(file.Name)).ToArray();
                if (sameFiles.Length >= _backUpFileMaxNumber)
                {
                    File.Delete(Path.Combine(destDirName, sameFiles[0]));
                }
                var newName = $"{dateTime}@{file.Name}";
                if (newFies.Contains(newName))
                {
                    continue;
                }
                string tempPath = Path.Combine(destDirName, newName);
                await Task.Run(() => file.CopyTo(tempPath, true));
            }

            // Recursively call CopyDirectory on each subdirectory.
            foreach (DirectoryInfo subdir in dirs)
            {
                string temppath = Path.Combine(destDirName, subdir.Name);
                await CopyDirectory(subdir.FullName, temppath, dateTime);
            }
        }
        #endregion

        public void InitAllWaferTypeNode()
        {
            _allWaferTypeNode = SC.GetAllWaferTypeColor();
        }
        public string GetCarrierUIColor(string carrierType, CarrierStatus carrierStatus)
        {
            var defaultColor = "#ccc";
            if (carrierType == null || !_allWaferTypeNode.ContainsKey(carrierType))
                return defaultColor;

            if (!_allWaferTypeNode[carrierType].ContainsKey(carrierStatus.ToString()))
                return defaultColor;

            return _allWaferTypeNode[carrierType][carrierStatus.ToString()];
        }

        private void AxisDataLoad(object[] args)
        {

            var trigDataLoad = DEVICE.GetDevice<IoTrigger>($"{ModuleName.PM1.ToString()}.TrigDataLoad");
            var trigDataSend = DEVICE.GetDevice<IoTrigger>($"{ModuleName.PM1.ToString()}.TrigDataSend");
            trigDataSend.SetTrigger(false, out _);
            trigDataLoad.SetTrigger(true, out _);
            Thread.Sleep(1500);
            var paras = args[0].ToString().Split(',');
            foreach (var item in paras)
            {
                var path = $"System.AxisParameters.{item}";
                if (!SC.ContainsItem(path))
                    continue;
                var ioName = $"{ModuleName.PM1}.{item}";
                var dataValue = IO.AO[ioName].FloatValue;

                SC.SetItemValue(path, dataValue);

            }
            trigDataLoad.SetTrigger(false, out _);
        }
        private void AxisDataSend(object[] args)
        {
            var trigDataLoad = DEVICE.GetDevice<IoTrigger>($"{ModuleName.PM1.ToString()}.TrigDataLoad");
            var trigDataSend = DEVICE.GetDevice<IoTrigger>($"{ModuleName.PM1.ToString()}.TrigDataSend");
            trigDataSend.SetTrigger(true, out _);
            trigDataLoad.SetTrigger(false, out _);
            var paras = args[0].ToString().Split(',');

            foreach (var item in paras)
            {
                var path = $"System.AxisParameters.{item}";
                if (!SC.ContainsItem(path))
                    continue;
                var ioName = $"{ModuleName.PM1}.{item}";
                var scDataValue = SC.GetValue<double>(path);

                IO.AO[ioName].FloatValue = (float)scDataValue;
            }
            trigDataSend.SetTrigger(false, out _);
        }
        private Dictionary<string, string> GetHeatersData()
        {
            Dictionary<string, string> result = new Dictionary<string, string>();
            if (_heaters == null || _heaters.Count == 0)
            {
                return result;
            }
            foreach (var item in _heaters)
            {

                result.Add(item.Display, item.TempFeedback.ToString("f1"));
            }
            return result;
        }

        public bool CheckDumyWafer(WaferInfo[] wafers)
        {
            var pm = (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule);
            foreach (var wafer in wafers)
            {
                if (wafer == null || wafer.IsEmpty || (wafer.WaferType != WaferType.SD && wafer.WaferType != WaferType.ED))
                    continue;
                #region New
                var isScheduleMaintenance = SC.ContainsItem("System.EnableScheduleMaintenance") && SC.GetValue<bool>("System.EnableScheduleMaintenance");
                if (isScheduleMaintenance)
                {
                    #region  SD Dummy 时间/次数/膜厚限制

                    var maintenanceItemSDCarrierUseFreq = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.SDCarrierUseFreq.ToString());
                    var maintenanceItemSDWaferThickness = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.SDWaferThickness.ToString());
                    var maintenanceItemSDWaferUserTime = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.SDWaferUserTime.ToString());


                    int SDCountWarning = (int)maintenanceItemSDCarrierUseFreq.StartValue;
                    int SDCountAlarm = (int)maintenanceItemSDCarrierUseFreq.LimitValue;
                    bool IsEnableSDWaferUseCountWarning = SDCountWarning > 0;


                    int SDThicknessWarning = (int)maintenanceItemSDWaferThickness.StartValue;
                    int SDThicknessAlarm = (int)maintenanceItemSDWaferThickness.LimitValue;
                    bool IsEnableSDWaferThicknessWarning = SDThicknessWarning > 0;

                    int SDTimeWarning = DateTimeUtil.GetSecond(maintenanceItemSDWaferUserTime.StartValue);
                    int SDTimeAlarm = DateTimeUtil.GetSecond(maintenanceItemSDWaferUserTime.LimitValue);
                    bool IsEnableSDWaferUseTimeWarning = SDTimeWarning > 0;
                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseCountWarning && wafer.UseCount > SDCountWarning && wafer.UseCount < SDCountAlarm)
                    {

                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set, $"more than {SDCountWarning} 次"));

                    }

                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseTimeWarning && wafer.UseTime > SDTimeWarning && wafer.UseTime < SDTimeAlarm)
                    {
                        DateTimeUtil.ConvertSecondsToHoursAndMinutes(SDTimeWarning, out var hours, out var minutes);

                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set, $"more than {hours} hour {minutes} min"));

                    }

                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferThicknessWarning && wafer.UseThick > SDThicknessWarning && wafer.UseThick < SDThicknessAlarm)
                    {
                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set, $"more than {SDThicknessWarning} nm"));

                    }

                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseCountWarning && wafer.UseCount >= SDCountAlarm)
                    {
                        if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
                            return true;

                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set, $"more than {SDCountAlarm} 次"),"",false);
                        return false;
                    }

                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseTimeWarning && wafer.UseTime >= SDTimeAlarm)
                    {
                        if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
                            return true;

                        DateTimeUtil.ConvertSecondsToHoursAndMinutes(SDTimeAlarm, out var hours, out var minutes);
                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set, $"more than {hours} hour {minutes}"), "", false);

                        return false;
                    }

                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferThicknessWarning && wafer.UseThick >= SDThicknessAlarm)
                    {
                        if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
                            return true;

                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set, $"more than {SDThicknessAlarm} nm"), "", false);

                        return false;
                    }
                    #endregion

                    #region ED
                    var maintenanceItemEDCarrierUseFreq = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.FDCarrierUseFreq.ToString());
                    var maintenanceItemEDWaferThickness = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.FDWaferThickness.ToString());
                    var maintenanceItemEDWaferUserTime = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.FDWaferUserTime.ToString());

                    int EDCountWarning = (int)maintenanceItemEDCarrierUseFreq.StartValue;
                    int EDCountAlarm = (int)maintenanceItemEDCarrierUseFreq.LimitValue;
                    bool IsEnableEDWaferUseCountWarning = EDCountWarning > 0;


                    int EDThicknessWarning = (int)maintenanceItemEDWaferThickness.StartValue;
                    int EDThicknessAlarm = (int)maintenanceItemEDWaferThickness.LimitValue;
                    bool IsEnableEDWaferThicknessWarning = EDThicknessWarning > 0;

                    int EDTimeWarning = DateTimeUtil.GetSecond(maintenanceItemEDWaferUserTime.StartValue);
                    int EDTimeAlarm = DateTimeUtil.GetSecond(maintenanceItemEDWaferUserTime.LimitValue);
                    bool IsEnableEDWaferUseTimeWarning = EDTimeWarning > 0;
                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseCountWarning && maintenanceItemEDCarrierUseFreq.CurrentValue > EDCountWarning && wafer.UseCount < EDCountAlarm)
                    {
                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set));
                    }

                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseTimeWarning && wafer.UseTime > EDTimeWarning && wafer.UseTime < EDTimeAlarm)
                    {
                        var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.CurrentValue.ToString());
                        var startValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.StartValue.ToString());
                        var limitValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.LimitValue.ToString());


                        var msg = $"{maintenanceItemEDWaferUserTime.Item}-{maintenanceItemEDWaferUserTime.Display} {maintenanceItemEDWaferUserTime.AdditionInformationDisplay}  {currentValue} limit is ({startValue}~{limitValue}) {maintenanceItemEDWaferUserTime.Unit}";
                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set, msg));


                    }

                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferThicknessWarning && wafer.UseThick > EDThicknessWarning && wafer.UseThick < EDThicknessAlarm)
                    {
                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set, $"more than {EDThicknessWarning} nm"));

                    }

                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseCountWarning && wafer.UseCount >= EDCountAlarm)
                    {
                        if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
                            return true;

                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set, $"more than {EDCountAlarm} 次"), "", false);
                        return false;
                    }

                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseTimeWarning && wafer.UseTime >= EDTimeAlarm)
                    {

                        if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
                            return true;

                        DateTimeUtil.ConvertSecondsToHoursAndMinutes(EDTimeAlarm, out var hours, out var minutes);
                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set, $"more than {hours} hour {minutes}"), "", false);
                        return false;
                    }

                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferThicknessWarning && wafer.UseThick >= EDThicknessAlarm)
                    {

                        if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
                            return true;

                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set, $"more than {EDThicknessAlarm} nm"), "", false);
                        return false;
                    }
                    #endregion
                }
                else
                {
                    // SD Dummy
                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseCountWarning") && wafer.UseCount > SC.GetValue<int>($"PM1.WaferCycleTime.SDCountWarning") && wafer.UseCount < SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.SDCountWarning")} 次");
                    }

                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseTimeWarning") && wafer.UseTime / 3600 > SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeWarning") && wafer.UseTime / 3600 < SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeWarning")} hour");
                    }

                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferThicknessWarning") && wafer.UseThick > SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessWarning") && wafer.UseThick < SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessWarning")} nm");
                    }

                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm")} 次");

                        return false;
                    }

                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm")} hour");

                        return false;
                    }

                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm")} nm");

                        return false;
                    }

                    // Extra Dummy
                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseCountWarning") && wafer.UseCount > SC.GetValue<int>($"PM1.WaferCycleTime.EDCountWarning") && wafer.UseCount < SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountWarning")} 次");
                    }

                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseTimeWarning") && wafer.UseTime / 3600 > SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeWarning") && wafer.UseTime / 3600 < SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeWarning")} hour");
                    }

                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferThicknessWarning") && wafer.UseThick > SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessWarning") && wafer.UseThick < SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessWarning")} nm");
                    }

                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm")} 次");

                        return false;
                    }

                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm")} hour");

                        return false;
                    }

                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm"))
                    {
                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm")} nm");

                        return false;
                    }

                }
                #endregion
            }
            return true;
        }
    }

    public enum BackUpDireEnum
    {

        SC,
        GasXml,
        IO,
        Objects,
        Parameters,
        Recipes,
        BackUp,
        Config,

    }
}