PunkHPX8/PunkHPX8_RT/Dispatch/WaferTaskManager.cs

using Aitex.Core.Common;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.Common.SubstrateTrackings;
using PunkHPX8_RT.Modules;
using PunkHPX8_RT.Schedulers;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Markup;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.ToolLayout;
using PunkHPX8_RT.Devices.EFEM;
using Aitex.Core.RT.Device;
using MECF.Framework.RT.Core.Equipments;
using PunkHPX8_RT.Modules.VpwMain;

namespace PunkHPX8_RT.Dispatch
{
    public class WaferTaskManager : Singleton<WaferTaskManager>
    {
        #region 常量
        private const string SIDE_A = "SideA";
        private const string SIDE_B = "SideB";
        #endregion

        #region 内部变量
        /// <summary>
        /// FA回复
        /// </summary>
        private SchedulerFACallback _schedulerFACallback = new SchedulerFACallback();
        /// <summary>
        /// 任务锁
        /// </summary>
        private object _taskLocker = new object();
        /// <summary>
        /// 任务集合
        /// </summary>
        private List<WaferTask> _waferTaskList = new List<WaferTask>();
        /// <summary>
        /// Wafer task字典
        /// </summary>
        private ConcurrentDictionary<string, WaferTask> _waferTasksDic = new ConcurrentDictionary<string, WaferTask>();
        /// <summary>
        /// Wafer配对字典(key-自身WaferId,value-配对WaferId)
        /// </summary>
        private ConcurrentDictionary<string, string> _waferTaskMatchDic = new ConcurrentDictionary<string, string>();
        
        #endregion

        /// <summary>
        /// 初始化Task
        /// </summary>
        /// <param name="task"></param>
        public void InitializeTask(WaferTask task)
        {
            _waferTasksDic[task.WaferId] = task;
            lock(_taskLocker)
            {
                _waferTaskList.Add(task);
            }
        }
        /// <summary>
        /// 获取WaferTask
        /// </summary>
        /// <param name="waferId"></param>
        /// <returns></returns>
        public WaferTask GetWaferTask(string waferId)
        {
            return _waferTasksDic.ContainsKey(waferId) ? _waferTasksDic[waferId] : null;
        }
        /// <summary>
        /// 是否包含
        /// </summary>
        /// <param name="waferId"></param>
        /// <returns></returns>
        public bool Contains(string waferId)
        {
            return _waferTasksDic.ContainsKey(waferId);
        }
        /// <summary>
        /// 移除任务
        /// </summary>
        /// <param name="waferId"></param>
        public void RemoveWaferTask(string waferId)
        {
            if(_waferTasksDic.ContainsKey(waferId))
            {
                _waferTasksDic.TryRemove(waferId, out var task);
                task.Dispose();
                task.OnTaskComplete -= WaferTask_OnTaskComplete;
                LOG.WriteBackgroundLog(eEvent.EV_SCHEDULER, "Scheduler", $"remove wafer {waferId} task");
            }
            if(_waferTaskMatchDic.ContainsKey(waferId))
            {
                _waferTaskMatchDic.TryRemove(waferId,out var taskMath);
            }
            lock(_taskLocker)
            {
                int index = _waferTaskList.FindIndex(O => O.WaferId == waferId);
                if (index >= 0)
                {
                    _waferTaskList.RemoveAt(index);
                }
            }
        }
        /// <summary>
        /// 加载Wafer Task集合
        /// </summary>
        /// <returns></returns>
        public List<WaferTask> LoadWaferTaskList()
        {
            return _waferTaskList.ToList(); 
        }
        /// <summary>
        /// 检验是否可以创建Wafer Task
        /// </summary>
        /// <returns></returns>
        public bool CheckEnableCreateWaferTask()
        {
            lock (_taskLocker)
            {
                if (_waferTaskList.Count == 0)
                {
                    return true;
                }

                if (WaferManager.Instance.CheckHasWafer(ModuleName.Aligner1, 0))
                {
                    return false;
                }
                foreach (WaferTask item in _waferTaskList)
                {
                    //Wafer还未离开Aligner
                    if (item.CurrentSequenceIndex <= 1)
                    {
                        return false;
                    }
                }
                return true;
            }
        }

        /// <summary>
        /// 获取下一个执行的ProcessJob
        /// </summary>
        /// <param name="jobs"></param>
        /// <returns></returns>
        private ProcessJobInfo GetNextProcessJob(List<ProcessJobInfo> jobs, List<string> executedPPids)
        {
            try
            {
                bool isRunInParallelMode = SC.GetValue<bool>("Scheduler.IsRunInParallelMode");
                if (!isRunInParallelMode)
                {
                    return jobs[0];
                }
                else
                {
                    if (_waferTaskList.Count == 0)
                    {
                        return jobs[0];
                    }
                    WaferTask lastWaferTask = _waferTaskList[_waferTaskList.Count - 1];

                    string lastSequence = lastWaferTask.ProcessJobInfo.SequenceRecipe?.Ppid;
                    List<ProcessJobInfo> lastSamePjs = new List<ProcessJobInfo>();
                    List<ProcessJobInfo> otherPjs = new List<ProcessJobInfo>();
                    int lastIndex = jobs.FindIndex(O => O.SequenceRecipe?.Ppid == lastSequence);
                    int nextIndex = (lastIndex == -1 || lastIndex >= jobs.Count - 1) ? 0 : lastIndex + 1;
                    for (int i = nextIndex; i < jobs.Count; i++)
                    {
                        ProcessJobInfo processJobInfo = jobs[i];
                        if (processJobInfo.SequenceRecipe?.Ppid == lastSequence)
                        {
                            lastSamePjs.Add(processJobInfo);
                            continue;
                        }
                        if (executedPPids.Contains(processJobInfo.SequenceRecipe?.Ppid))
                        {
                            continue;
                        }
                        return processJobInfo;
                    }
                    for (int i = 0; i < lastIndex; i++)
                    {
                        ProcessJobInfo processJobInfo = jobs[i];
                        if (processJobInfo.SequenceRecipe?.Ppid == lastSequence)
                        {
                            lastSamePjs.Add(processJobInfo);
                            continue;
                        }
                        if (executedPPids.Contains(processJobInfo.SequenceRecipe?.Ppid))
                        {
                            continue;
                        }
                        return processJobInfo;
                    }
                    if (lastSamePjs.Count != 0)
                    {
                        return lastSamePjs[0];
                    }
                    return jobs[0];
                }
            }
            catch
            {
                return jobs[0];
            }
        }

        /// <summary>
        /// 创建Wafer任务
        /// </summary>
        public void CreateWaferTask(List<ProcessJobInfo> processJobInfos)
        {
            int count = 0;
            string mateWaferTask = "";
            List<WaferInfo> wafers = new List<WaferInfo>();
            if (processJobInfos.Count == 0)
            {
                return;
            }
            List<string> excludes = new List<string>();
            ProcessJobInfo processJob = GetNextProcessJob(processJobInfos, excludes);
            if (processJob == null)
            {
                return;
            }
            for(int i=0; i<processJobInfos.Count;i++)
            {
                ProcessJobInfo processJobInfo = processJobInfos[i];
                if (processJobInfo.SequenceRecipe?.Ppid != processJob.SequenceRecipe?.Ppid)
                {
                    continue;
                }
                for(int j=0;j< processJobInfo.SlotWafers.Count; j++)
                {
                    var item = processJobInfo.SlotWafers[j];
                    if (WaferManager.Instance.CheckHasWafer(item.Item1, item.Item2))
                    {
                        WaferInfo waferInfo = WaferManager.Instance.GetWafer(item.Item1, item.Item2);
                        if (waferInfo != null && waferInfo.ProcessState == EnumWaferProcessStatus.Idle)
                        {
                            if (!Contains(waferInfo.WaferID))
                            {
                                if (count == 0)
                                {
                                    wafers.Add(waferInfo);
                                    count++;
                                }
                                else
                                {
                                    wafers.Add(waferInfo);
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            List<VpwCellEntity> vpwCellEntities = SchedulerSequenceManager.Instance.GetAvaibleVpwList(processJob.SequenceRecipe.SubstrateSize, false);
            if (vpwCellEntities.Count == 0)
            {
                return;
            }

            SequenceRecipe sequenceRecipe = processJob.SequenceRecipe;
            if (wafers.Count == 1)
            {
                WaferInfo dummyWaferInfo = GetDummyWafer(sequenceRecipe.SubstrateSize);
                if (dummyWaferInfo == null)
                {
                    return;
                }
                CreateWaferTaskSchedulerSequence(wafers[0], sequenceRecipe, "", vpwCellEntities[0].Module);
                mateWaferTask = wafers[0].WaferID;
                CreateDummyWaferTaskSchedulerSequence(sequenceRecipe, dummyWaferInfo, mateWaferTask, vpwCellEntities.Count == 1 ? vpwCellEntities[0].Module : vpwCellEntities[1].Module);
                _waferTaskMatchDic[wafers[0].WaferID] = dummyWaferInfo.WaferID; 
                LOG.WriteLog(eEvent.EV_SEQUENCE, "Scheduler", $"wafer {wafers[0].WaferID} match {dummyWaferInfo.WaferID}");
                _waferTaskMatchDic[dummyWaferInfo.WaferID] = wafers[0].WaferID;
                LOG.WriteLog(eEvent.EV_SEQUENCE, "Scheduler", $"wafer {dummyWaferInfo.WaferID} match {wafers[0].WaferID}");
            }
            else if (wafers.Count >= 2)
            {
                CreateWaferTaskSchedulerSequence(wafers[0], sequenceRecipe, "",vpwCellEntities[0].Module);
                mateWaferTask = wafers[0].WaferID;
                CreateWaferTaskSchedulerSequence(wafers[1], sequenceRecipe, mateWaferTask, vpwCellEntities.Count == 1 ? vpwCellEntities[0].Module : vpwCellEntities[1].Module);
                _waferTaskMatchDic[wafers[0].WaferID] = wafers[1].WaferID;
                _waferTaskMatchDic[wafers[1].WaferID] = wafers[0].WaferID;
            }
        }

        /// <summary>
        /// 获取Dummy Wafer
        /// </summary>
        /// <param name="waferSize"></param>
        /// <returns></returns>
        private WaferInfo GetDummyWafer(int waferSize)
        {
            List<string> dummmys= DummyCasseteItemManager.Instance.InstalledModules;

            foreach(string item in dummmys)
            {
                if (Enum.TryParse(item, out ModuleName dummyModule))
                {
                    DummyDevice dummyDevice= Singleton<RouteManager>.Instance.EFEM.GetDummyDevice(dummyModule - ModuleName.Dummy1);
                    if ((int)dummyDevice.WaferSize != waferSize)
                    {
                        continue;
                    }
                    int maxSlot = dummyDevice.MaxSlotNumber;
                    for (int i = 0; i < maxSlot; i++)
                    {
                        if (WaferManager.Instance.CheckHasWafer(item, i))
                        {
                            return WaferManager.Instance.GetWafer(dummyModule, i);
                        }
                    }
                }
            }
            return null;
        }
        /// <summary>
        /// 创建WaferTask SchedulerSequence
        /// </summary>
        /// <param name="waferInfo"></param>
        /// <param name="pufModuleName"></param>
        /// <param name="waferHolderInfo"></param>
        /// <param name="sequenceRecipe"></param>
        private void CreateWaferTaskSchedulerSequence(WaferInfo waferInfo, SequenceRecipe sequenceRecipe, string mateWafeTask,ModuleName vpwModule)
        {
            List<SchedulerSequence> sequences = SchedulerSequenceManager.Instance.AnalyWaferAllSchedulerSequence(waferInfo,vpwModule,sequenceRecipe);
            WaferTask waferTask = new WaferTask(waferInfo, sequences);
            if (!string.IsNullOrEmpty(mateWafeTask))
            {
                waferTask.MateWaferTask = mateWafeTask;
            }
            waferTask.OnTaskComplete += WaferTask_OnTaskComplete;
            LOG.WriteLog(eEvent.EV_SEQUENCE, "Scheduler", $"Create wafer {waferInfo.WaferID} task");
            InitializeTask(waferTask);
        }
        /// <summary>
        /// 创建Dummy Wafer Task 调度工序
        /// </summary>
        /// <param name="waferInfo"></param>
        /// <param name="pufModuleName"></param>
        /// <param name="mateWaferTask"></param>
        private void CreateDummyWaferTaskSchedulerSequence(SequenceRecipe sequenceRecipe,WaferInfo waferInfo,string mateWaferTask,ModuleName vpwModuleName)
        {
            List<SchedulerSequence> sequences = SchedulerSequenceManager.Instance.AnalyDummyWaferAllSchedulerSequence(sequenceRecipe,vpwModuleName,waferInfo);
            
            WaferTask waferTask = new WaferTask(waferInfo,sequences);
            if (!string.IsNullOrEmpty(mateWaferTask))
            {
                waferTask.MateWaferTask = mateWaferTask;
            }
            LOG.WriteLog(eEvent.EV_SEQUENCE, "Scheduler", $"Create Dummy wafer {waferInfo.WaferID} task");
            waferTask.OnTaskStart += WaferTask_OnTaskStart;
            waferTask.OnTaskComplete += WaferTask_OnTaskComplete;
            InitializeTask(waferTask);
        }
        /// <summary>
        /// 任务开始
        /// </summary>
        /// <param name="id"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void WaferTask_OnTaskStart(string id)
        {
            WaferInfo waferInfo = WaferManager.Instance.GetWaferByWaferId(id);
            if (waferInfo != null && waferInfo.WaferType == WaferType.Production)
            {
                ModuleName moduleName = (ModuleName)waferInfo.OriginStation;
                if (ModuleHelper.IsLoadPort(moduleName))
                {
                    CycleManager.Instance.UpdateCycleWaferCount(moduleName.ToString());
                }
                _schedulerFACallback.JobWaferStart(JobProcesser.Instance.GetControlJobInfoByProcessJob(waferInfo.ProcessJob),
                    waferInfo.SequenceName, waferInfo.OriginSlot);
            }
        }

        /// <summary>
        ///  Wafer task完成事件
        /// </summary>
        /// <param name="id"></param>
        private void WaferTask_OnTaskComplete(string id)
        {
            WaferInfo waferInfo=WaferManager.Instance.GetWaferByWaferId(id);
            if (waferInfo != null&&waferInfo.WaferType==WaferType.Production)
            {
                ModuleName moduleName = (ModuleName)waferInfo.OriginStation;
                if (ModuleHelper.IsLoadPort(moduleName))
                {
                    CycleManager.Instance.UpdateCycleWaferCount(moduleName.ToString());
                }
                _schedulerFACallback.JobWaferEnd(JobProcesser.Instance.GetControlJobInfoByProcessJob(waferInfo.ProcessJob), 
                    waferInfo.SequenceName, waferInfo.OriginSlot);
            }
            RemoveWaferTask(id);
        }
        /// <summary>
        /// 检验所有task是否完成
        /// </summary>
        /// <returns></returns>
        public bool CheckAllTaskComplete()
        {
            return _waferTaskList.Count == 0;
        }
        /// <summary>
        /// 暂停
        /// </summary>
        public void PauseAllTask()
        {
            List<WaferTask> waferTasks = _waferTaskList.ToList();
            foreach(WaferTask item in waferTasks)
            {
                item.Pause();
            }
        }
        /// <summary>
        /// 恢复所有任务
        /// </summary>
        public void ResumeAllTask()
        {
            List<WaferTask> waferTasks = _waferTaskList.ToList();
            foreach (WaferTask item in waferTasks)
            {
                item.Resume();
            }
        }
        /// <summary>
        /// 恢复所有任务
        /// </summary>
        public void RemoveAllTask()
        {
            List<WaferTask> waferTasks = _waferTaskList.ToList();
            foreach (WaferTask item in waferTasks)
            {
                RemoveWaferTask(item.WaferId);
            }
        }
        /// <summary>
        /// 根据WaferId获取配对另一个WaferId
        /// </summary>
        /// <param name="waferId"></param>
        /// <returns></returns>
        public string GetMatchWaferIdByWaferId(string waferId)
        {
            return _waferTaskMatchDic.ContainsKey(waferId) ? _waferTaskMatchDic[waferId] : "";
        }
        /// <summary>
        /// 检验Wafer存在匹配的wafer任务(wafer是单片任务还是双片任务)
        /// </summary>
        /// <param name="waferId"></param>
        /// <returns></returns>
        public string CheckWaferHasMatch(string waferId)
        {
            if (_waferTaskMatchDic.ContainsKey(waferId))
            {
                return _waferTaskMatchDic[waferId];
            }
            else
            {
                return "";
            }
        }
    }
}