PunkHPX8/PunkHPX8_RT/Schedulers/SchedulerDryerTimeManager.cs

using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using PunkHPX8_RT.Dispatch;
using MECF.Framework.Common.Equipment;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PunkHPX8_RT.Schedulers
{
    public class SchedulerDryerTimeManager: Singleton<SchedulerDryerTimeManager>
    {
        #region 内部变量
        private ConcurrentDictionary<string, List<SchedulerTime>> _dryerScheduleTimeDic = new ConcurrentDictionary<string, List<SchedulerTime>>();
        #endregion
        /// <summary>
        /// 按照用量排序
        /// </summary>
        /// <param name="modules"></param>
        /// <returns></returns>
        public List<ModuleName> ResetModuleOrderByUsed(List<IModuleEntity> modules)
        {
            List<SchedulerModuleUse> schedulerModuleUses= new List<SchedulerModuleUse>();
            foreach (IModuleEntity module in modules)
            {
                SchedulerModuleUse moduleUse = new SchedulerModuleUse();
                moduleUse.ModuleName = module.Module;
                moduleUse.Used = _dryerScheduleTimeDic.ContainsKey(module.Module.ToString()) ? _dryerScheduleTimeDic[module.Module.ToString()].Count : 0;
                schedulerModuleUses.Add(moduleUse);
            }
            List<ModuleName> results= schedulerModuleUses.OrderBy(O => O.Used).Select(O => O.ModuleName).ToList();
            return results;
        }
        /// <summary>
        /// 获取最后的时间轴对象
        /// </summary>
        /// <param name="dryer"></param>
        /// <returns></returns>
        public SchedulerTime GetLastSchedulerTime(string dryer)
        {
            if (_dryerScheduleTimeDic.ContainsKey(dryer))
            {
                List<SchedulerTime> schedulerTimes = _dryerScheduleTimeDic[dryer].OrderBy(O=>O.ScheduleStartTime).ToList();
                if (schedulerTimes.Count != 0)
                {
                    return schedulerTimes.Last();
                }
                else
                {
                    return null;
                }
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 按照计划时间排序
        /// </summary>
        /// <param name="modules"></param>
        /// <returns></returns>
        public List<ModuleName> ResetModuleOrderBySchedulerEndTime(List<IModuleEntity> modules)
        {
            List<SchedulerModuleEndTime> schedulerModuleUses = new List<SchedulerModuleEndTime>();
            foreach (IModuleEntity module in modules)
            {
                SchedulerModuleEndTime moduleEndTime = new SchedulerModuleEndTime();
                moduleEndTime.ModuleName = module.Module;
                if (_dryerScheduleTimeDic.ContainsKey(module.Module.ToString()))
                {
                    List<SchedulerTime> schedulerTimes = _dryerScheduleTimeDic[module.Module.ToString()].OrderBy(O=>O.ScheduleStartTime).ToList();
                    SchedulerTime lastSchedulerTime = schedulerTimes.Last();
                    DateTime lastSchedulerEndTime = lastSchedulerTime.ScheduleStartTime.AddSeconds(lastSchedulerTime.ProcessTimeLength);
                    moduleEndTime.SchedulerEndTime = lastSchedulerEndTime;
                }
                else
                {
                    moduleEndTime.SchedulerEndTime = DateTime.MinValue;
                }
                schedulerModuleUses.Add(moduleEndTime);
            }
            List<ModuleName> results = schedulerModuleUses.OrderBy(O => O.SchedulerEndTime).Select(O => O.ModuleName).ToList();
            return results;
        }
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="dryer"></param>
        /// <param name="waferHolderId"></param>
        /// <param name="schedulerStartTime"></param>
        /// <param name="processTimeLength"></param>
        public void AddDryerScheduler(string dryer,string waferHolderId,int schedulerIndex,DateTime schedulerStartTime,int processTimeLength,bool writeDryerLog=true)
        {
            if (!_dryerScheduleTimeDic.ContainsKey(dryer))
            {
                SchedulerTime dryerTime = new SchedulerTime();
                dryerTime.WaferHolderId = waferHolderId;
                dryerTime.ScheduleStartTime = schedulerStartTime;
                dryerTime.ProcessTimeLength = processTimeLength;
                dryerTime.SchedulerIndex = schedulerIndex;
                List<SchedulerTime> schedulerDryerTimes = new List<SchedulerTime>();
                schedulerDryerTimes.Add(dryerTime);
                _dryerScheduleTimeDic.TryAdd(dryer, schedulerDryerTimes);
            }
            else
            {
                List<SchedulerTime> schedulerDryerTimes = _dryerScheduleTimeDic[dryer];
                if(schedulerDryerTimes.Find(O=>O.WaferHolderId==waferHolderId&&O.SchedulerIndex==schedulerIndex) == null)
                {
                    SchedulerTime dryerTime = new SchedulerTime();
                    dryerTime.WaferHolderId = waferHolderId;
                    dryerTime.ScheduleStartTime = schedulerStartTime;
                    dryerTime.ProcessTimeLength = processTimeLength;
                    dryerTime.SchedulerIndex = schedulerIndex;
                    schedulerDryerTimes.Add(dryerTime);
                }
            }
            if (writeDryerLog)
            {
                WriteDryerSchedulerTimeLog();
            }

            LOG.WriteLog(eEvent.INFO_RINSE, dryer, $"add wafer shuttle {waferHolderId} scheduler {schedulerIndex} dryer {dryer} in scheduler time");
        }
        /// <summary>
        /// 写Dryer调度时间轴日志
        /// </summary>
        public void WriteDryerSchedulerTimeLog()
        {
            List<string> keys = _dryerScheduleTimeDic.Keys.ToList();
            foreach (string key in keys)
            {
                List<SchedulerTime> schedulerDryerTimes = _dryerScheduleTimeDic[key].OrderBy(O => O.ScheduleStartTime).ToList();
                foreach (SchedulerTime item in schedulerDryerTimes)
                {
                    DateTime startTime = item.ScheduleStartTime;
                    DateTime endTime = startTime.AddSeconds(item.ProcessTimeLength);
                    LOG.WriteLog(eEvent.INFO_DRYER, key, $"wafer shuttle {item.WaferHolderId} scheduler {item.SchedulerIndex} dryer {key} start time {startTime} end time {endTime} processLength {item.ProcessTimeLength} s");
                }
            }
        }
        /// <summary>
        /// 更新Dryer实际启动时间
        /// </summary>
        /// <param name="dryer"></param>
        /// <param name="startTime"></param>
        public void UpdateDryerStartTime(string dryer,string waferHolderId,int schedulerIndex,DateTime startTime)
        {
            if (_dryerScheduleTimeDic.ContainsKey(dryer))
            {
                List<SchedulerTime> schedulerDryerTimes= _dryerScheduleTimeDic[dryer];
                SchedulerTime schedulerDryerTime=schedulerDryerTimes.Find(O=>O.WaferHolderId==waferHolderId&&O.SchedulerIndex==schedulerIndex);
                if (schedulerDryerTime != null)
                {
                    schedulerDryerTime.StartTime = startTime;
                    if (schedulerDryerTime.StartTime > schedulerDryerTime.ScheduleStartTime)
                    {
                        LOG.WriteLog(eEvent.INFO_DRYER, dryer, $"wafer shuttle {waferHolderId} scheduler {schedulerIndex} dryer {dryer} start time {startTime} after scheduler start time {schedulerDryerTime.ScheduleStartTime}");
                        double interSeconds = schedulerDryerTime.StartTime.Subtract(schedulerDryerTime.ScheduleStartTime).TotalSeconds;
                        schedulerDryerTime.ScheduleStartTime = schedulerDryerTime.StartTime;
                        SchedulerMetalTimeManager.Instance.DelayMetalSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        SchedulerQdrTimeManager.Instance.DelayQdrSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        DelayDryerSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        SchedulerTransporterTimeManager.Instance.DelayTransporterSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        SchedulerWaferHolderTimeManager.Instance.DelayWaferHolderSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                    }
                    LOG.WriteLog(eEvent.INFO_DRYER, dryer, $"update wafer shuttle {waferHolderId} scheduler {schedulerIndex} dryer {dryer} start time {startTime}");
                }
            }
        }
        /// <summary>
        /// 延后metal后续时间
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="schedulerIndex"></param>
        /// <param name="seconds"></param>
        public void DelayDryerSchedulerStartTime(string waferHolderId, int schedulerIndex, double seconds)
        {
            List<string> keys = _dryerScheduleTimeDic.Keys.ToList();
            foreach (string key in keys)
            {
                List<SchedulerTime> schedulerTimes = _dryerScheduleTimeDic[key];
                List<SchedulerTime> postSchedulerTimes = schedulerTimes.FindAll(O => O.WaferHolderId == waferHolderId && O.SchedulerIndex > schedulerIndex);
                foreach (SchedulerTime schedulerTime in postSchedulerTimes)
                {
                    schedulerTime.ScheduleStartTime = schedulerTime.ScheduleStartTime.AddSeconds(seconds);
                }
            }
            WriteDryerSchedulerTimeLog();
        }
        /// <summary>
        /// 移除
        /// </summary>
        /// <param name="dryer"></param>
        public void RemoveDryerStartTime(string dryer,string waferHolderId,int schedulerIndex)
        {
            if (_dryerScheduleTimeDic.ContainsKey(dryer))
            {
                List<SchedulerTime> schedulerDryerTimes = _dryerScheduleTimeDic[dryer]; 
                SchedulerTime schedulerDryerTime = schedulerDryerTimes.Find(O => O.WaferHolderId == waferHolderId && O.SchedulerIndex == schedulerIndex);
                if (schedulerDryerTime != null)
                {
                    LOG.WriteLog(eEvent.INFO_RINSE, dryer, $"remove wafer shuttle {waferHolderId} scheduler {schedulerIndex} dryer {dryer} in scheduler time");
                    schedulerDryerTimes.Remove(schedulerDryerTime);
                }
                if (schedulerDryerTimes.Count == 0)
                {
                    _dryerScheduleTimeDic.TryRemove(dryer, out schedulerDryerTimes);
                    LOG.WriteLog(eEvent.INFO_RINSE, dryer, $"delete wafer shuttle {waferHolderId} scheduler {schedulerIndex} dryer {dryer} in scheduler time");
                }
            }
        }
        /// <summary>
        /// 检验Dryer是否冲突
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="schedulerStartTime"></param>
        /// <param name="processTimeLength"></param>
        /// <returns></returns>
        public (bool conflict,string waferHolderId,int schedluerIndex) CheckDryerConflict(string dryer,string waferHolderId, DateTime schedulerStartTime, int processTimeLength)
        {
            if (!_dryerScheduleTimeDic.ContainsKey(dryer))
            {
                return (false, "", -1);
            }
            List<SchedulerTime> schedulerDryerTimes= _dryerScheduleTimeDic[dryer];
            foreach(SchedulerTime item in schedulerDryerTimes)
            {
                if (item.WaferHolderId == waferHolderId)
                {
                    continue;
                }
                bool result=CheckDryerTimeConflict(item,schedulerStartTime, processTimeLength);
                if (result)
                {
                    return (true,item.WaferHolderId,item.SchedulerIndex);
                }
            }
            return (false, "", -1);
        }
        /// <summary>
        /// 判定时间是否冲突
        /// </summary>
        /// <param name="schedulerDryerTime"></param>
        /// <param name="schedulerStartTime"></param>
        /// <param name="processTimeLength"></param>
        /// <returns></returns>
        private bool CheckDryerTimeConflict(SchedulerTime schedulerDryerTime, DateTime schedulerStartTime, int processTimeLength)
        {
            int transporterTransferSeconds = SC.GetValue<int>("Transporter.TransporterTransferSeconds");
            DateTime schedulerEndTime = schedulerStartTime.AddSeconds(processTimeLength);
            DateTime dryerEndTime = schedulerDryerTime.ScheduleStartTime.AddSeconds(schedulerDryerTime.ProcessTimeLength);
            DateTime dryerStartTime= schedulerDryerTime.ScheduleStartTime;
            
            if (schedulerStartTime > dryerEndTime.AddSeconds(transporterTransferSeconds))
            {
                return false;
            }

            if (schedulerEndTime.AddSeconds(transporterTransferSeconds) < dryerStartTime)
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 计算Dryer调度预计开始时间
        /// </summary>
        /// <param name="depRecipeTimeLength"></param>
        /// <returns></returns>
        public DateTime CalculateDryerSchedulerStartTime(DateTime dateTime)
        {
            int transporterTransferSeconds = SC.GetValue<int>("Transporter.TransporterTransferSeconds");
            //Transporter传输时间
            return dateTime.AddSeconds(transporterTransferSeconds);
        }
        /// <summary>
        /// 清除所有
        /// </summary>
        public void RemoveAll()
        {
            List<string> keys = _dryerScheduleTimeDic.Keys.ToList();
            foreach (string key in keys)
            {
                List<SchedulerTime> schedulerTimes = _dryerScheduleTimeDic[key];
                schedulerTimes.Clear();
            }
            _dryerScheduleTimeDic.Clear();
            LOG.Write(eEvent.INFO_RINSE,"System", "Remove all dryer scheduler time");
        }
    }
}