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", 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},
                {"ProcessWaferIdList",  _fdcwaferList},
                {"ProcessCarrierIDList",  _fdccridlst},
                {"ProcessLotIdList",  _fdcLotIds},
            });
        }

        public void RecipeFailed(string module, string recipeName)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);
            EV.Notify(PMRecipeFailed[moduleName], new SerializableDictionary<string, string>()
            {
                {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},
                {"ProcessWaferIdList",  _fdcwaferList},
                {"ProcessCarrierIDList",  _fdccridlst},
                {"ProcessLotIdList",  _fdcLotIds},
            });
        }

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


        public void RecipeHold(string module, string recipeName, string recipeStep)
        {
            EV.Notify(UniversalEvents.RecipeHold, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
                {"RecID",  recipeName},
            });
        }
        public void RecipeRelease(string module, string recipeName, string recipeStep)
        {
            EV.Notify(UniversalEvents.RecipeRelease, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
                    {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
            });
        }
        public void RecipeStepSkip(string module, string recipeName, string recipeStep)
        {
            EV.Notify(UniversalEvents.RecipeStepSkip, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
            {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
            });
        }

        public void RecipeStop(string module, string recipeName, string recipeStep)
        {
            EV.Notify(UniversalEvents.RecipeStop, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
            {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
            });
        }

        public void RecipeJumpStep(string module, string recipeName, string recipeStep, string jumpStpeId)
        {
            EV.Notify(UniversalEvents.RecipeJumpStep, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
             {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
                {DataName.StepId.ToString(),  jumpStpeId},
            });
        }
        public void RecipeAbort(string module, string recipeName, string recipeStep)
        {
            EV.Notify(UniversalEvents.RecipeAbort, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
                   {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
            });
        }

        public void RecipeJumpEnd(string module, string recipeName, string recipeStep, string jumpStpeId)
        {
            EV.Notify(UniversalEvents.RecipeJumpEnd, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
             {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
                {DataName.StepId.ToString(),  jumpStpeId},
            });
        }

        public void RecipeCallAlarmRecipe(string module, string recipeName, string recipeStep, string otherRecipeName)
        {
            EV.Notify(UniversalEvents.CallAlarmRecipe, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
              {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
                {DataName.CallRecipeID.ToString(),  otherRecipeName},
            });
        }
        public void RecipeCallAbortRecipe(string module, string recipeName, string recipeStep, string otherRecipeName)
        {
            EV.Notify(UniversalEvents.CallAbortRecipe, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
             {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
                 {DataName.CallRecipeID.ToString(),  otherRecipeName},
            });
        }
        public void RecipeRunResetRecipe(string module, string recipeName, string recipeStep, string otherRecipeName)
        {
            EV.Notify(UniversalEvents.RunResetRecipe, new SerializableDictionary<string, string>()
            {
                {DVIDName.RecipeID,  recipeName},
                {DataName.NewRecipeStepNumber.ToString(),  recipeStep},
             {DataName.CallRecipeID.ToString(),  otherRecipeName},
            });
        }
    }
}