FurnaceELK/Furnace/FurnaceRT/Equipments/PMs/RecipeExecutions/PreProcess.cs

using Aitex.Core.RT.Routine;
using MECF.Framework.Common.Equipment;
using System;
using Aitex.Core.RT.SCCore;
using FurnaceRT.Equipments.PMs.Routines;
using System.Collections.Generic;
using FurnaceRT.Equipments.Systems;
using Aitex.Core.Util;
using MECF.Framework.Common.SubstrateTrackings;
using System.Linq;

namespace FurnaceRT.Equipments.PMs.RecipeExecutions
{
    public class PreProcess : PMBaseRoutine, IRoutine
    {
        public enum Routine
        {
            ToReadyProcessState,
            Pump,
            PinDown,
        }

        private string _recipeName;
        private int _liftTimeout;
        private bool _isProcessRecipe;
        public PreProcess(ModuleName module, PMModule pm) : base(module, pm)
        {
            Module = module.ToString();
            Name = "PreProcess";

        }

        public void Init(string recipeName, bool isProcessRecipe = true)
        {
            _recipeName = recipeName;
            _isProcessRecipe = isProcessRecipe;
        }

        public override Result Start(params object[] objs)
        {
            RecipeHead recipeHead;
            List<RecipeStep> recipeSteps;
            Dictionary<int, List<RecipeStep>> abortRecipe;
            Dictionary<int, string> abortRecipeName;
            Dictionary<int, List<RecipeStep>> subRecipe;
            Dictionary<int, string> subRecipeName;
            string reason = string.Empty;


            if (_isProcessRecipe)
            {

                
            

                if (!RecipeParser.Parse(_recipeName, Module, out recipeHead, out recipeSteps, out reason, "Process"))
                {
                    PMModule.PreprocessStartFailedWarning.Set($"Load process recipe {_recipeName} failed, {reason}");
                    return Result.FAIL;
                }

                #region MyRegion

            

                var isScheduleMaintenance = SC.ContainsItem("System.EnableScheduleMaintenance") && SC.GetValue<bool>("System.EnableScheduleMaintenance");
                if (isScheduleMaintenance)
                {

                    var pm = (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule);

                    pm.GetAllDBRecord();

                    var wafers = WaferManager.Instance.GetWafers(ModuleName.PM1);
                    if (wafers != null && wafers.Count() > 0)
                    {
                        if (!pm.CheckDumyWafer(wafers))
                        {
                            return Result.FAIL;
                        };
                    }


                    pm.CheckRecipeThicknessMoreThan(_recipeName, out var isPause);
                    if (isPause)
                        return Result.FAIL;

                    pm.CheckRecipeExecuteFreqMoreThan(_recipeName, out var isPause1);
                    if (isPause1)
                        return Result.FAIL;


                    foreach (var item in recipeSteps)
                    {

                        pm.CheckRecipeStepFreqMoreThan(item.StepName, out var isPause2);
                        if (isPause2)
                            return Result.FAIL;

                        pm.CheckRecipeStepTimeMoreThan(item.StepName, out var isPause3);
                        if (isPause3)
                            return Result.FAIL;

                        pm.CheckRecipeStepGroupThicknessMoreThan(item.StepName, out var isPause4);
                        if (isPause4)
                            return Result.FAIL;

                    }

                }
                #endregion


                PMModule.RecipeRunningInfo.MainRecipeName = _recipeName;
                PMModule.RecipeRunningInfo.Head = recipeHead;
                PMModule.RecipeRunningInfo.RecipeStepList = recipeSteps;
            }



            Reset();

            Notify($"Start");

            return Result.RUN;
        }

        public override Result Monitor()
        {
            try
            {
                //ToReadyProcessState((int)Routine.ToReadyProcessState, PMModule, _liftTimeout);

                //ExecuteRoutine((int)Routine.Pump, _pumpRoutine);

                //MovePinDown((int)Routine.PinDown, PMModule, _liftTimeout);
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                return Result.FAIL;
            }

            return Result.DONE;
        }

        public override void Abort()
        {
        }


    }
}