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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.Event;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using FurnaceRT.FAs;
using Aitex.Core.Common;
using FabConnect.SecsGemInterface.Common;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.FAServices;
using static MECF.Framework.Common.FAServices.DataVariables;

namespace FurnaceRT.Equipments.PMs
{
    public class RecipeFACallback : IRecipeFACallback
    {
        private const string PM1RecipeStart = "RecipeStart";
        private const string PM1RecipeComplete = "RecipeComplete";
        private const string PM1RecipeStepStart = "RecipeStepStart";
        private const string PM1RecipeStepEnd = "RecipeStepEnd";
        private const string PM1RecipeFailed = "RecipeFailed";

        private const string PM2RecipeStart = "RecipeStart";
        private const string PM2RecipeComplete = "RecipeComplete";
        private const string PM2RecipeStepStart = "RecipeStepStart";
        private const string PM2RecipeStepEnd = "RecipeStepEnd";
        private const string PM2RecipeFailed = "RecipeFailed";

        private Dictionary<ModuleName, string> PMRecipeStart = new Dictionary<ModuleName, string>()
        {
            {ModuleName.PM1, PM1RecipeStart},
            {ModuleName.PM2, PM2RecipeStart},
        };

        private Dictionary<ModuleName, string> PMRecipeComplete = new Dictionary<ModuleName, string>()
        {
            {ModuleName.PM1, PM1RecipeComplete},
            {ModuleName.PM2, PM2RecipeComplete},
        };
        private Dictionary<ModuleName, string> PMRecipeStepStart = new Dictionary<ModuleName, string>()
        {
            {ModuleName.PM1, PM1RecipeStepStart},
            {ModuleName.PM2, PM2RecipeStepStart},
        };
        private Dictionary<ModuleName, string> PMRecipeStepEnd = new Dictionary<ModuleName, string>()
        {
            {ModuleName.PM1, PM1RecipeStepEnd},
            {ModuleName.PM2, PM2RecipeStepEnd},
        };
        private Dictionary<ModuleName, string> PMRecipeFailed = new Dictionary<ModuleName, string>()
        {
            {ModuleName.PM1, PM1RecipeFailed},
            {ModuleName.PM2, PM2RecipeFailed},
        };


        public RecipeFACallback()
        {
            EV.Subscribe(new EventItem("Event", PM1RecipeStart, PM1RecipeStart));
            EV.Subscribe(new EventItem("Event", PM1RecipeComplete, PM1RecipeComplete));
            EV.Subscribe(new EventItem("Event", PM1RecipeStepStart, PM1RecipeStepStart));
            EV.Subscribe(new EventItem("Event", PM1RecipeStepEnd, PM1RecipeStepEnd));
            EV.Subscribe(new EventItem("Event", PM1RecipeFailed, PM1RecipeFailed));

            EV.Subscribe(new EventItem("Event", UniversalEvents.RecipeAbnormalEnd, $"RecipeAbnormalEnd"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.AlarmConditionTriggerReset, $"AlarmConditionTriggerReset"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.AlarmConditionTriggerEnd, $"AlarmConditionTriggerEnd"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.AlarmConditionTriggerHold, $"AlarmConditionTriggerHold"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.AlarmConditionTriggerJumpStep, $"AlarmConditionTriggerJumpStep"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.AlarmConditionTriggerCallAlarmRecipe, $"AlarmConditionTriggerCallAlarmRecipe"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.AlarmConditionTriggerCallAbortRecipe, $"AlarmConditionTriggerCallAbortRecipe"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.LeakCheckTriggerReset, $"LeakCheckTriggerReset"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.LeakCheckTriggerEnd, $"LeakCheckTriggerEnd"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.LeakCheckTriggerHold, $"LeakCheckTriggerHold"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.LeakCheckTriggerJumpStep, $"LeakCheckTriggerJumpStep"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.LeakCheckTriggerCallAlarmRecipe, $"LeakCheckTriggerCallAlarmRecipe"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.LeakCheckTriggerCallAbortRecipe, $"LeakCheckTriggerCallAbortRecipe"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.ManualTriggerRecipeHold, $"ManualTriggerRecipeHold"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.ManualTriggerRecipeRelease, $"ManualTriggerRecipeRelease"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.ManualTriggerRecipeSkip, $"ManualTriggerRecipeSkip"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.ManualTriggerRecipeJump, $"ManualTriggerRecipeJump"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.ManualTriggerRecipeAbort, $"ManualTriggerRecipeAbort"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.RecipeTriggerReset, $"RecipeTriggerReset"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.RecipeTriggerEnd, $"RecipeTriggerEnd"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.RecipeTriggerHold, $"RecipeTriggerHold"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.RecipeTriggerLeakCheck, $"RecipeTriggerLeakCheck"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.RecipeTriggerJumpStep, $"RecipeTriggerJumpStep"));
            EV.Subscribe(new EventItem("Event", UniversalEvents.RecipeTriggerCallSubRecipe, $"RecipeTriggerCallSubRecipe"));


            //EV.Subscribe(new EventItem("Event", PM2RecipeStart, PM2RecipeStart));
            //EV.Subscribe(new EventItem("Event", PM2RecipeComplete, PM2RecipeComplete));
            //EV.Subscribe(new EventItem("Event", PM2RecipeStepStart, PM2RecipeStepStart));
            //EV.Subscribe(new EventItem("Event", PM2RecipeStepEnd, PM2RecipeStepEnd));
            //EV.Subscribe(new EventItem("Event", PM2RecipeFailed, PM2RecipeFailed));

        }

        public void RecipeComplete(string module, string recipeName)
        {

            ModuleName moduleName = ModuleHelper.Converter(module);
            var wafers = WaferManager.Instance.GetWafers(ModuleName.PM1);
            List<string> fdcwafers = new List<string>();
            List<string> fdcCarriers = new List<string>();
            List<string> fdcLotIds = new List<string>();
            if (wafers != null)
            {
                foreach (var wafer in wafers)
                {
                    if (!(fdcCarriers.Contains(wafer.OriginCarrierID)))
                    {
                        fdcCarriers.Add(wafer.OriginCarrierID);
                    }

                    if (!(fdcwafers.Contains(wafer.WaferID)))
                    {
                        fdcwafers.Add(wafer.WaferID);
                    }
                    if (!(fdcLotIds.Contains(wafer.LotId)))
                    {
                        fdcLotIds.Add(wafer.LotId);
                    }
                }
            }
            SECsDataItem _fdccridlst = new SECsDataItem(SECsFormat.List);
            foreach (var fdcid in fdcCarriers)
            {
                _fdccridlst.Add("CRID", fdcid, SECsFormat.Ascii);
            }

            SECsDataItem _fdcwaferList = new SECsDataItem(SECsFormat.List);
            foreach (var fdcid in fdcwafers)
            {
                _fdcwaferList.Add("CRID", fdcid, SECsFormat.Ascii);
            }

            SECsDataItem _fdcLotIds = new SECsDataItem(SECsFormat.List);
            foreach (var fdcid in fdcLotIds)
            {
                _fdcLotIds.Add("CRID", fdcid, SECsFormat.Ascii);
            }

            EV.Notify(PMRecipeComplete[moduleName], new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.StationName,  module},
                {DataVariables.ProcessWaferIdList,  _fdcwaferList},
                {DataVariables.ProcessCarrierIDList,  _fdccridlst},
                {DataVariables.ProcessLotIdList,  _fdcLotIds},
            });
        }

        public void RecipeFailed(string module, string recipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(PMRecipeFailed[moduleName], new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.StationName,  module},
            });
        }

        public void RecipeStart(string module, string recipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            var wafers = WaferManager.Instance.GetWafers(ModuleName.PM1);
            List<string> fdcwafers = new List<string>();
            List<string> fdcCarriers = new List<string>();
            List<string> fdcLotIds = new List<string>();
            if (wafers != null)
            {
                foreach (var wafer in wafers)
                {
                    if (!(fdcCarriers.Contains(wafer.OriginCarrierID)))
                    {
                        fdcCarriers.Add(wafer.OriginCarrierID);
                    }

                    if (!(fdcwafers.Contains(wafer.WaferID)))
                    {
                        fdcwafers.Add(wafer.WaferID);
                    }
                    if (!(fdcLotIds.Contains(wafer.LotId)))
                    {
                        fdcLotIds.Add(wafer.LotId);
                    }
                }
            }
            SECsDataItem _fdccridlst = new SECsDataItem(SECsFormat.List);
            foreach (var fdcid in fdcCarriers)
            {
                _fdccridlst.Add("CRID", fdcid, SECsFormat.Ascii);
            }

            SECsDataItem _fdcwaferList = new SECsDataItem(SECsFormat.List);
            foreach (var fdcid in fdcwafers)
            {
                _fdcwaferList.Add("CRID", fdcid, SECsFormat.Ascii);
            }

            SECsDataItem _fdcLotIds = new SECsDataItem(SECsFormat.List);
            foreach (var fdcid in fdcLotIds)
            {
                _fdcLotIds.Add("CRID", fdcid, SECsFormat.Ascii);
            }

            EV.Notify(PMRecipeStart[moduleName], new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.StationName,  module},
                {DataVariables.ProcessWaferIdList,  _fdcwaferList},
                {DataVariables.ProcessCarrierIDList,  _fdccridlst},
                {DataVariables.ProcessLotIdList,  _fdcLotIds},
            });
        }

        public void RecipeStepEnd(string module, string recipeName, int stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(PMRecipeStepEnd[moduleName], new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.StationName,  module},
                {DVIDName.RecipeStepNumber,  (stepNumber+1).ToString()},
            });
        }

        public void RecipeStepStart(string module, string recipeName, int stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(PMRecipeStepStart[moduleName], new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.StationName,  module},
                {DVIDName.RecipeStepNumber,  (stepNumber+1).ToString()},
            });
        }
        #region 子事件上报

        public void AlarmConditionTriggerReset(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            EV.Notify(UniversalEvents.AlarmConditionTriggerReset, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }
        public void AlarmConditionTriggerEnd(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.AlarmConditionTriggerEnd, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void AlarmConditionTriggerHold(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.AlarmConditionTriggerHold, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void AlarmConditionTriggerJumpStep(string module, string recipeName, string stepNumber, string stepId)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.AlarmConditionTriggerJumpStep, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DataVariables.StepId, stepId},
            });
        }
        public void AlarmConditionTriggerCallAlarmRecipe(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.AlarmConditionTriggerCallAlarmRecipe, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }
        public void AlarmConditionTriggerCallAbortRecipe(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.AlarmConditionTriggerCallAbortRecipe, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }

        public void LeakCheckTriggerReset(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.LeakCheckTriggerReset, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void LeakCheckTriggerEnd(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.LeakCheckTriggerEnd, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void LeakCheckTriggerHold(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.LeakCheckTriggerHold, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void LeakCheckTriggerJumpStep(string module, string recipeName, string stepNumber, string stepId)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.LeakCheckTriggerJumpStep, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DataVariables.StepId, stepId},
            });
        }

        public void LeakCheckTriggerCallAlarmRecipe(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.LeakCheckTriggerCallAlarmRecipe, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }

        public void LeakCheckTriggerCallAbortRecipe(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.LeakCheckTriggerCallAbortRecipe, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }
        public void ManualTriggerRecipeHold(string module, string recipeName, string stepNumber )
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.ManualTriggerRecipeHold, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }

        public void ManualTriggerRecipeRelease(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.ManualTriggerRecipeRelease, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void ManualTriggerRecipeSkip(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.ManualTriggerRecipeSkip, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void ManualTriggerRecipeJump(string module, string recipeName, string stepNumber, string stepId)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.ManualTriggerRecipeJump, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber,stepNumber},
                {DataVariables.StepId, stepId},
            });
        }
        public void ManualTriggerRecipeAbort(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.ManualTriggerRecipeAbort, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }

        public void RecipeTriggerReset(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.RecipeTriggerReset, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }
        public void RecipeTriggerEnd(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.RecipeTriggerEnd, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }

        public void RecipeTriggerHold(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.RecipeTriggerHold, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void RecipeTriggerLeakCheck(string module, string recipeName, string stepNumber)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.RecipeTriggerLeakCheck, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
            });
        }
        public void RecipeTriggerJumpStep(string module, string recipeName, string stepNumber, string stepId)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.RecipeTriggerJumpStep, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                 {DataVariables.StepId, stepId},
            });
        }

        public void RecipeTriggerCallSubRecipe(string module, string recipeName, string stepNumber, string otherRecipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(UniversalEvents.RecipeTriggerCallSubRecipe, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DVIDName.RecipeStepNumber, stepNumber},
                {DVIDName.RecipeName, otherRecipeName},
            });
        }
        public void RecipeAbnormalEnd(string module, string recipeName, string stepNumber)
        {
            EV.Notify(UniversalEvents.RecipeAbnormalEnd, new SerializableDictionary<string, object>()
            {
                {DVIDName.RecipeID,  recipeName }
            });
        }

        #endregion

    }
}