PunkHPX8/PunkHPX8_RT/Schedulers/SchedulerQdrTimeManager.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 SchedulerQdrTimeManager: Singleton<SchedulerQdrTimeManager>
    {
        #region 内部变量
        private ConcurrentDictionary<string, List<SchedulerTime>> _qdrScheduleTimeDic = new ConcurrentDictionary<string, List<SchedulerTime>>();
        #endregion

        /// <summary>
        /// 重置
        /// </summary>
        /// <param name="modules"></param>
        /// <returns></returns>
        public List<ModuleName> ResetModuleOrder(List<string> modules,SchedulerModulePartTime qdrPartTime)
        {
            List<SchedulerModuleUse> schedulerModuleUses = new List<SchedulerModuleUse>();
            foreach (string module in modules)
            {
                SchedulerModuleUse moduleUse = new SchedulerModuleUse();
                moduleUse.ModuleName = (ModuleName)Enum.Parse(typeof(ModuleName),module);
                int partUsedCount = qdrPartTime.GetModuleUsedCount(module);
                moduleUse.Used = _qdrScheduleTimeDic.ContainsKey(module.ToString()) ? _qdrScheduleTimeDic[module].Count+partUsedCount : 0+ partUsedCount;
                schedulerModuleUses.Add(moduleUse);
            }
            List<ModuleName> results = schedulerModuleUses.OrderBy(O => O.Used).Select(O => O.ModuleName).ToList();
            return results;
        }
        /// <summary>
        /// 按照计划时间排序
        /// </summary>
        /// <param name="modules"></param>
        /// <returns></returns>
        public List<ModuleName> ResetModuleOrderBySchedulerEndTime(List<string> modules,SchedulerModulePartTime partTime)
        {
            List<SchedulerModuleEndTime> schedulerModuleUses = new List<SchedulerModuleEndTime>();
            foreach (string module in modules)
            {
                SchedulerModuleEndTime moduleEndTime = new SchedulerModuleEndTime();
                moduleEndTime.ModuleName = (ModuleName)Enum.Parse(typeof(ModuleName), module);
                if (_qdrScheduleTimeDic.ContainsKey(module))
                {
                    List<SchedulerTime> schedulerTimes = _qdrScheduleTimeDic[module].OrderBy(O => O.ScheduleStartTime).ToList();
                    SchedulerTime lastSchedulerTime = schedulerTimes.Last();

                    DateTime lastSchedulerEndTime = lastSchedulerTime.ScheduleStartTime.AddSeconds(lastSchedulerTime.ProcessTimeLength);
                    DateTime partEndTime = partTime.GetLastSchedulerTime(module);
                    if (partEndTime > lastSchedulerEndTime)
                    {
                        moduleEndTime.SchedulerEndTime = partEndTime;
                    }
                    else
                    {
                        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="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 (_qdrScheduleTimeDic.ContainsKey(module.Module.ToString()))
                {
                    List<SchedulerTime> schedulerTimes = _qdrScheduleTimeDic[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="metal"></param>
        /// <returns></returns>
        public SchedulerTime GetLastSchedulerTime(string metal)
        {
            if (_qdrScheduleTimeDic.ContainsKey(metal))
            {
                List<SchedulerTime> schedulerTimes = _qdrScheduleTimeDic[metal].OrderBy(O=>O.ScheduleStartTime).ToList();
                if (schedulerTimes.Count != 0)
                {
                    return schedulerTimes.Last();
                }
                else
                {
                    return null;
                }
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="qdr"></param>
        /// <param name="waferHolderId"></param>
        /// <param name="schedulerStartTime"></param>
        /// <param name="processTimeLength"></param>
        public void AddQdrScheduler(string qdr,string waferHolderId,int schedulerIndex,DateTime schedulerStartTime,int processTimeLength,bool writeQdrLog=true)
        {
            if (!_qdrScheduleTimeDic.ContainsKey(qdr))
            {
                SchedulerTime qdrTime = new SchedulerTime();
                qdrTime.WaferHolderId = waferHolderId;
                qdrTime.ScheduleStartTime = schedulerStartTime;
                qdrTime.ProcessTimeLength = processTimeLength;
                qdrTime.SchedulerIndex = schedulerIndex;
                List<SchedulerTime> schedulerQdrTimes = new List<SchedulerTime>();
                schedulerQdrTimes.Add(qdrTime);
                _qdrScheduleTimeDic.TryAdd(qdr, schedulerQdrTimes);
            }
            else
            {
                List<SchedulerTime> schedulerQdrTimes = _qdrScheduleTimeDic[qdr];
                if(schedulerQdrTimes.Find(O=>O.WaferHolderId==waferHolderId&&O.SchedulerIndex==schedulerIndex) == null)
                {
                    SchedulerTime qdrTime = new SchedulerTime();
                    qdrTime.WaferHolderId = waferHolderId;
                    qdrTime.ScheduleStartTime = schedulerStartTime;
                    qdrTime.ProcessTimeLength = processTimeLength;
                    qdrTime.SchedulerIndex = schedulerIndex;
                    schedulerQdrTimes.Add(qdrTime);
                }
            }
            if (writeQdrLog)
            {
                WriteQdrSchedulerTimeLog();
            }

            LOG.WriteLog(eEvent.INFO_RINSE, qdr, $"add wafer shuttle {waferHolderId} scheduler {schedulerIndex} qdr {qdr} in scheduler time");
        }
        /// <summary>
        /// 写Qdr调度时间轴日志
        /// </summary>
        /// <param name="key"></param>
        /// <param name="schedulerQdrTime"></param>
        public void WriteQdrSchedulerTimeLog()
        {
            List<string> keys = _qdrScheduleTimeDic.Keys.ToList();
            foreach (string key in keys)
            {
                List<SchedulerTime> schedulerQdrTimes = _qdrScheduleTimeDic[key].OrderBy(O=>O.ScheduleStartTime).ToList();
                foreach (SchedulerTime item in schedulerQdrTimes)
                {
                    DateTime startTime = item.ScheduleStartTime;
                    DateTime endTime = startTime.AddSeconds(item.ProcessTimeLength);
                    LOG.WriteLog(eEvent.INFO_RINSE, key, $"wafer shuttle {item.WaferHolderId} scheduler {item.SchedulerIndex} qdr {key}  start time {startTime} end time {endTime} processLength {item.ProcessTimeLength} s");
                }
            }
        }
        /// <summary>
        /// 更新QDR实际启动时间
        /// </summary>
        /// <param name="qdr"></param>
        /// <param name="startTime"></param>
        public void UpdateQdrStartTime(string qdr,string waferHolderId,int schedulerIndex,DateTime startTime)
        {
            if (_qdrScheduleTimeDic.ContainsKey(qdr))
            {
                List<SchedulerTime> schedulerQdrTimes= _qdrScheduleTimeDic[qdr];
                SchedulerTime schedulerQdrTime=schedulerQdrTimes.Find(O=>O.WaferHolderId==waferHolderId&&O.SchedulerIndex==schedulerIndex);
                if (schedulerQdrTime != null)
                {
                    schedulerQdrTime.StartTime = startTime;
                    if (schedulerQdrTime.StartTime > schedulerQdrTime.ScheduleStartTime)
                    {
                        LOG.WriteLog(eEvent.INFO_RINSE, qdr, $"wafer shuttle {waferHolderId} scheduler {schedulerIndex} qdr {qdr} start time {startTime} after scheduler start time {schedulerQdrTime.ScheduleStartTime}");
                        double interSeconds = schedulerQdrTime.StartTime.Subtract(schedulerQdrTime.ScheduleStartTime).TotalSeconds;
                        schedulerQdrTime.ScheduleStartTime = schedulerQdrTime.StartTime;
                        SchedulerPlatingCellTimeManager.Instance.DelayPlatingCellSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        DelayQdrSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        SchedulerDryerTimeManager.Instance.DelayDryerSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        SchedulerTransporterTimeManager.Instance.DelayTransporterSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                        SchedulerWaferHolderTimeManager.Instance.DelayWaferHolderSchedulerStartTime(waferHolderId, schedulerIndex, interSeconds);
                    }
                    LOG.WriteLog(eEvent.INFO_RINSE, qdr, $"update wafer shuttle {waferHolderId} scheduler {schedulerIndex} qdr {qdr} start time {startTime}");
                }
            }
        }
        /// <summary>
        /// 延后qdr后续时间
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="schedulerIndex"></param>
        /// <param name="seconds"></param>
        public void DelayQdrSchedulerStartTime(string waferHolderId, int schedulerIndex, double seconds)
        {
            List<string> keys = _qdrScheduleTimeDic.Keys.ToList();
            foreach (string key in keys)
            {
                List<SchedulerTime> schedulerTimes = _qdrScheduleTimeDic[key];
                List<SchedulerTime> postSchedulerTimes = schedulerTimes.FindAll(O => O.WaferHolderId == waferHolderId && O.SchedulerIndex > schedulerIndex);
                foreach (SchedulerTime schedulerTime in postSchedulerTimes)
                {
                    schedulerTime.ScheduleStartTime = schedulerTime.ScheduleStartTime.AddSeconds(seconds);
                }
            }
        }
        /// <summary>
        /// 移除
        /// </summary>
        /// <param name="qdr"></param>
        public void RemoveQdrStartTime(string qdr,string waferHolderId,int schedulerIndex)
        {
            if (_qdrScheduleTimeDic.ContainsKey(qdr))
            {
                List<SchedulerTime> schedulerQdrTimes = _qdrScheduleTimeDic[qdr]; 
                SchedulerTime schedulerQdrTime = schedulerQdrTimes.Find(O => O.WaferHolderId == waferHolderId && O.SchedulerIndex == schedulerIndex);
                if (schedulerQdrTime != null)
                {
                    LOG.WriteLog(eEvent.INFO_RINSE, qdr, $"remove wafer shuttle {waferHolderId} scheduler {schedulerIndex} qdr {qdr} in scheduler time");
                    schedulerQdrTimes.Remove(schedulerQdrTime);
                }
                if (schedulerQdrTimes.Count == 0)
                {
                    _qdrScheduleTimeDic.TryRemove(qdr, out schedulerQdrTimes);
                    LOG.WriteLog(eEvent.INFO_RINSE, qdr, $"delete wafer shuttle {waferHolderId} scheduler {schedulerIndex} qdr {qdr} in scheduler time");
                }
            }
        }
        /// <summary>
        /// 检验QDR是否冲突
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="schedulerStartTime"></param>
        /// <param name="processTimeLength"></param>
        /// <returns></returns>
        public (bool conflict,string waferHolderId,int schedluerIndex) CheckQdrConflict(string qdr,string waferHolderId, DateTime schedulerStartTime, int processTimeLength)
        {
            if (!_qdrScheduleTimeDic.ContainsKey(qdr))
            {
                return (false, "", -1);
            }
            List<SchedulerTime> schedulerQdrTimes= _qdrScheduleTimeDic[qdr];

            foreach(SchedulerTime item in schedulerQdrTimes)
            {
                if (item.WaferHolderId == waferHolderId)
                {
                    continue;
                }
                //if (WaferHolderManager.Instance.HasWaferHolder(qdr))
                //{
                //    WaferHolderInfo waferHolderInfo = WaferHolderManager.Instance.GetWaferHolder(qdr);
                //    if (waferHolderInfo!=null)
                //    {
                //        WaferHolderTask waferHolderTask= WaferHolderTaskManager.Instance.GetWaferHolderTaskByWaferHolderId(waferHolderInfo.Id);
                //        if (waferHolderTask != null)
                //        {
                //            return (true, waferHolderInfo.Id, waferHolderTask.GetCurrentSchedulerIndex());
                //        }
                //        return (true, "", -1);
                //    }
                //    return (true, "", -1);
                //}
                bool result=CheckQdrTimeConflict(item,schedulerStartTime, processTimeLength);
                if (result)
                {
                    return (true,item.WaferHolderId,item.SchedulerIndex);
                }
            }
            return (false, "", -1);
        }
        /// <summary>
        /// 判定时间是否冲突
        /// </summary>
        /// <param name="schedulerQdrTime"></param>
        /// <param name="schedulerStartTime"></param>
        /// <param name="processTimeLength"></param>
        /// <returns></returns>
        private bool CheckQdrTimeConflict(SchedulerTime schedulerQdrTime, DateTime schedulerStartTime, int processTimeLength)
        {
            int transporterTransferSeconds = SC.GetValue<int>("Transporter.TransporterTransferSeconds");
            DateTime schedulerEndTime = schedulerStartTime.AddSeconds(processTimeLength);
            DateTime qdrEndTime = schedulerQdrTime.ScheduleStartTime.AddSeconds(schedulerQdrTime.ProcessTimeLength);
            DateTime qdrStartTime= schedulerQdrTime.ScheduleStartTime;

            if (schedulerStartTime > qdrEndTime.AddSeconds(transporterTransferSeconds))
            {
                return false;
            }

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