FurnaceELK/Furnace/FurnaceRT/Equipments/PMs/PMScheduleMaintenance.cs

using Aitex.Core.Common;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
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 DocumentFormat.OpenXml.VariantTypes;
using FurnaceRT.Equipments.Systems;
using MECF.Framework.Common.CommonData.EnumData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Utilities;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.Remoting.Metadata.W3cXsd2001;

namespace FurnaceRT.Equipments.PMs
{
    public partial class PMModule
    {

        private void InitScheduleMaintenance()
        {

            new ScheduleMaintenanceData(MaintenanceItemEnum.SDCarrierUseFreq.ToString(), "Times", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferThickness.ToString(), "Å", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDUsableDummyWafer.ToString(), "Sheets", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDBufferRackStayTime.ToString(), "h:m", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferUserTime.ToString(), "h:m", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");


            new ScheduleMaintenanceData(MaintenanceItemEnum.FDCarrierUseFreq.ToString(), "Times", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferThickness.ToString(), "Å", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDUsableDummyWafer.ToString(), "Sheets", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDBufferRackStayTime.ToString(), "h:m", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferUserTime.ToString(), "h:m", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");


            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatRecipeThickness1.ToString(), "Å", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatTCUseTime.ToString(), "h:m", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatCKDUseTime.ToString(), "h:m", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatPUMPUseTime.ToString(), "h:m", "Boat");



            new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime1.ToString(), "h:m", "Conditioning");
            new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime2.ToString(), "h:m", "Conditioning");

            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeExecuteFreq.ToString(), "Times", "Reactor.Recipe", "Select Recipe");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness.ToString(), "Å", "Reactor.Recipe", "Select Recipe");


            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq1.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq2.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq3.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");


            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime1.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime2.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime3.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime4.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime5.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime6.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime7.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime8.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");



            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness1_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness2_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness3_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness4_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness5_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness6_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness7_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness8_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");


        }

        public void MaintenanceProcessingCommandExec(string maintenanceProcessing, AlarmReportItem alarmReportItem)
        {
            if (Enum.TryParse<MaintenanceProcessingCommandEnum>(maintenanceProcessing, out var command))
            {
                switch (command)
                {
                    case MaintenanceProcessingCommandEnum.None:
                        break;
                    case MaintenanceProcessingCommandEnum.AlarmReport:
                        alarmReportItem?.Exec();
                        break;

                    case MaintenanceProcessingCommandEnum.JobAutoStart:
                        break;
                    case MaintenanceProcessingCommandEnum.JobProhibition:
                        break;
                    case MaintenanceProcessingCommandEnum.JobManualStart:
                        break;
                }
            }
        }

        #region Carrier/Wafer

        public void UpdateSEDWafer()
        {
            var ccc = BinarySerializer<Dictionary<ModuleName, Dictionary<int, WaferInfo>>>.FromStream("WaferManager");
            if (ccc == null)
                return;


            List<WaferInfo> waferInfos = new List<WaferInfo>();


            foreach (var moduleWafers in ccc)
            {
                waferInfos.AddRange(moduleWafers.Value.Select(a => a.Value));
            }
            if (waferInfos.Any(a => a.WaferType == WaferType.ED))
            {

                var maxEDUseCount = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseCount);
                var maxEDUseThick = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseThick);
                var maxEDUseTime = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseTime);


                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDCarrierUseFreq.ToString(), out var FDCarrierUseFreq))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDCarrierUseFreq.Item, maxEDUseCount);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDWaferThickness.ToString(), out var FDWaferThickness))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDWaferThickness.Item, maxEDUseThick);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDWaferUserTime.ToString(), out var FDWaferUserTime))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDWaferUserTime.Item, maxEDUseTime);
            }
            if (waferInfos.Any(a => a.WaferType == WaferType.SD))
            {

                var maxSDUseCount = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseCount);
                var maxSDUseThick = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseThick);
                var maxSDUseTime = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseTime);
                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDCarrierUseFreq.ToString(), out var SDCarrierUseFreq))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDCarrierUseFreq.Item, maxSDUseCount);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDWaferThickness.ToString(), out var SDWaferThickness))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDWaferThickness.Item, maxSDUseThick);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDWaferUserTime.ToString(), out var SDWaferUserTime))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDWaferUserTime.Item, maxSDUseTime);
            }

        }
        #endregion



        /// <summary>
        /// 根据RecipeStep +StepGroup统计  累计膜厚
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepGroupThickness(string stepName, float thickness)
        {
            if (string.IsNullOrEmpty(stepName) || thickness <= 0)
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();
            var list = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values
                .Where(a => !string.IsNullOrEmpty(a.AdditionInformationDisplaySupplement))
                .Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepThickness}")
                .Where(a => a.AdditionInformationDisplaySupplement.Split(',').Contains(stepNo))
                .ToList();
            if (list == null || list.Count == 0)
                return;

            foreach (var item in list)
            {
                if (item == null)
                    continue;
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, thickness);


                if (item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue)
                    MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.ReatorStepThicknessWarning.Set, $"more than {item.StartValue} Å"));

                if (item.CurrentValue >= item.LimitValue)
                    MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.ReatorStepThicknessAlarm.Set, $"more than {item.LimitValue} Å"));

            }
        }
        /// <summary>
        /// 根据RecipeStep统计 Step执行Time 累计时间
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepRunTime(string stepName, double stepTime)
        {
            if (string.IsNullOrEmpty(stepName) || stepTime <= 0)
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();
            var list = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunTime}" && a.AdditionInformationDisplay == stepNo).ToList();
            if (list == null || list.Count == 0)
                return;
            foreach (var item in list)
            {
                if (item == null)
                    continue;
                var data = Math.Round(stepTime, 1, MidpointRounding.AwayFromZero);
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, (float)data);



            }

        }
        /// <summary>
        /// 根据RecipeStep统计 Step执行 累计次数
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepFre(string stepName)
        {
            if (string.IsNullOrEmpty(stepName))
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();
            var list = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunFreq}" && a.AdditionInformationDisplay == stepNo).ToList();
            if (list == null || list.Count == 0)
                return;
            foreach (var item in list)
            {
                if (item == null)
                    continue;
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item);
            }

        }
        /// <summary>
        /// 根据RecipeName统计 Recipe执行 累计次数
        /// </summary>
        /// <param name="processRecipeName"></param>
        public void UpdateRecipeFre(string recipeName)
        {

            if (string.IsNullOrEmpty(recipeName))
                return;
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString() && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" && a.AdditionInformationDisplay == recipeName).FirstOrDefault();
            if (item == null)
                return;

            if (item != null && item.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString())
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item);


        }
        /// <summary>
        /// 根据RecipeName统计累计膜厚
        /// </summary>
        /// <param name="recipeName"></param>
        /// <param name="thickness"></param>
        public void UpdateRecipeThickness(string recipeName, float thickness)
        {
            if (string.IsNullOrEmpty(recipeName) || thickness <= 0)
                return;
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Item == MaintenanceItemEnum.RecipeThickness.ToString() && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" && a.AdditionInformationDisplay == recipeName).FirstOrDefault();

            if (item == null)
                return;

            if (item != null && item.Item == MaintenanceItemEnum.RecipeThickness.ToString())
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, thickness);

        }



        /// <summary>
        /// 检查 RecipeStep 累计时间是否超限
        /// </summary>
        /// <param name="stepName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeStepTimeMoreThan(string stepName, out bool isPause)
        {

            var stepNo = stepName.Split(':').FirstOrDefault();
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values
                .Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunFreq}" && a.AdditionInformationDisplay == stepNo)
                .FirstOrDefault();


            CheckRecipeMoreThan(
                stepNo,
                Singleton<EquipmentManager>.Instance.ReatorStepRunTimeWarning.Set,
                Singleton<EquipmentManager>.Instance.ReatorStepRunTimeAlarm.Set,
                item,
                "HH:mm",
                out isPause);

        }

        /// <summary>
        /// RecipeStep 累计次数是否超限
        /// </summary>
        /// <param name="stepName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeStepFreqMoreThan(string stepName, out bool isPause)
        {

            var stepNo = stepName.Split(':').FirstOrDefault();
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values
                .Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunFreq}" && a.AdditionInformationDisplay == stepNo)
                .FirstOrDefault();


            CheckRecipeMoreThan(
                stepNo,
                Singleton<EquipmentManager>.Instance.ReatorStepRunFreqWarning.Set,
                Singleton<EquipmentManager>.Instance.ReatorStepRunFreqAlarm.Set,
                item,
                "times",
                out isPause);

        }

        /// <summary>
        ///  检查Recipe执行 累计次数是否超限
        /// </summary>
        /// <param name="recipeName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeExecuteFreqMoreThan(string recipeName, out bool isPause)
        {

            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values
                         .FirstOrDefault(a =>
                          a.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString() &&
                          a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" &&
                          a.AdditionInformationDisplay == recipeName);


            CheckRecipeMoreThan(
                recipeName,
                Singleton<EquipmentManager>.Instance.RecipeExecuteFreqWarning.Set,
                Singleton<EquipmentManager>.Instance.RecipeExecuteFreqAlarm.Set,
                item,
                "times",
                out isPause, true);
        }
        /// <summary>
        ///  检查Recipe执行 累计膜厚是否超限
        /// </summary>
        /// <param name="recipeName"></param>
        /// <param name="isPause"></param>
        public void CheckRecipeThicknessMoreThan(string recipeName, out bool isPause)
        {
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values
                       .FirstOrDefault(a =>
                        a.Item == MaintenanceItemEnum.RecipeThickness.ToString() &&
                        a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" &&
                        a.AdditionInformationDisplay == recipeName);


            CheckRecipeMoreThan(
                recipeName,
                Singleton<EquipmentManager>.Instance.RecipeThicknessWarning.Set,
                Singleton<EquipmentManager>.Instance.RecipeThicknessAlarm.Set,
                item,
                "Å",
                out isPause,true);
        }



        private void CheckRecipeMoreThan(
         string recipeName,
         Action<string> warningSetId,
         Action<string> alarmSetId,
         ScheduleMaintenanceDataItem item,
         string unit,
         out bool isPause,
         bool isEnableJobAutoStart = false)
        {
            isPause = false;

            if (string.IsNullOrEmpty(recipeName))
                return;

            if (item == null || !Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
                return;

            string message = $"{item.AdditionInformationDisplay} {item.CurrentValue} more than {item.StartValue} {unit}";
            string nullMessage = $"No recipe file associated, unable to trigger JobAutoStart";
            var warningAction = new AlarmReportItem(warningSetId, message);
            var alarmAction = new AlarmReportItem(alarmSetId, message);

            if (item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue && command != MaintenanceProcessingCommandEnum.None)
            {
                warningAction.Exec();
            }

            if (item.CurrentValue >= item.LimitValue)
            {
                ExecuteAlarm(alarmAction, ref isPause);
                if (isEnableJobAutoStart)
                {
                    switch (command)
                    {
                        case MaintenanceProcessingCommandEnum.JobAutoStart:
                            if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
                            {
                                ExecuteAlarm(new AlarmReportItem(alarmSetId, nullMessage), ref isPause);
                                return;
                            }
                            CheckToPostMessage((int)MSG.RunOtherRecipe, item.AssociationProcessRecipeName, "Process");
                            break;
                    }
                }

            }
        }
     
        private void ExecuteAlarm(AlarmReportItem alarmAction, ref bool isPause)
        {
            alarmAction.Exec();
            isPause = true;
        }
    }
}