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

namespace PunkHPX8_RT.Schedulers
{
    public class SchedulerWaferHolderTimeManager : Singleton<SchedulerWaferHolderTimeManager>
    {
        #region
        /// <summary>
        /// WaferHolder 模块时间轴字点
        /// </summary>
        private Dictionary<string, SchedulerWaferHolderTime> _waferHolderTimeDic = new Dictionary<string, SchedulerWaferHolderTime>();
        #endregion
        
        /// <summary>
        /// 返回调度字典
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, SchedulerWaferHolderTime> GetWaferHolderTimeDic()
        {
            return _waferHolderTimeDic;
        }

        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="module"></param>
        /// <param name="schedulerIndex"></param>
        /// <param name="schedulerStartTime"></param>
        /// <param name="processTimeLength"></param>
        public void AddWaferHolderTime(string waferHolderId, string module,ModuleType moduleType, int schedulerIndex, DateTime schedulerStartTime, int processTimeLength)
        {
            SchedulerWaferHolderTime schedulerWaferHolderTime = null;
            if (_waferHolderTimeDic.ContainsKey(waferHolderId))
            {
                schedulerWaferHolderTime = _waferHolderTimeDic[waferHolderId];
            }
            else
            {
                schedulerWaferHolderTime = new SchedulerWaferHolderTime();
                schedulerWaferHolderTime.WaferHolderId = waferHolderId;
                schedulerWaferHolderTime.ModuleTimes = new List<SchedulerWaferHolderModuleTime>();
                _waferHolderTimeDic[waferHolderId] = schedulerWaferHolderTime;
            }

            SchedulerWaferHolderModuleTime moduleTime = schedulerWaferHolderTime.ModuleTimes.Find(O => O.Module == module && O.SchedulerIndex == schedulerIndex);
            if (moduleTime == null)
            {
                moduleTime = new SchedulerWaferHolderModuleTime();
                moduleTime.Module = module;
                moduleTime.SchedulerIndex = schedulerIndex;
                moduleTime.ScheduleStartTime = schedulerStartTime;
                moduleTime.ProcessTimeLength = processTimeLength;
                moduleTime.ModuleType = moduleType;
                schedulerWaferHolderTime.ModuleTimes.Add(moduleTime);
            }
        }
        /// <summary>
        /// 是否包含
        /// </summary>
        /// <param name="waferHolder"></param>
        /// <returns></returns>
        public bool Contained(string waferHolder)
        {
            return _waferHolderTimeDic.ContainsKey(waferHolder);
        }
        /// <summary>
        /// 移除
        /// </summary>
        /// <param name="waferHolderId"></param>
        public void RemoveWaferHolderTime(string waferHolderId)
        {
            if (_waferHolderTimeDic.ContainsKey(waferHolderId))
            {
                _waferHolderTimeDic.Remove(waferHolderId);
            }
        }

        /// <summary>
        /// 写Dryer调度时间轴日志
        /// </summary>
        public void WriteSchedulerTimeLog(string waferHolderId)
        {
            if (!_waferHolderTimeDic.ContainsKey(waferHolderId))
            {
                return;
            }
            SchedulerWaferHolderTime waferHolderTime = _waferHolderTimeDic[waferHolderId];
            List<SchedulerWaferHolderModuleTime> schedulerWaferHolderModuleTimes= waferHolderTime.ModuleTimes.OrderBy(O => O.SchedulerIndex).ToList();
            foreach (var item in schedulerWaferHolderModuleTimes)
            {
                DateTime startTime = item.ScheduleStartTime;
                if (item.StartTime != DateTime.MinValue)
                {
                    startTime = item.StartTime;
                }
                DateTime endTime = startTime.AddSeconds(item.ProcessTimeLength);
                LOG.WriteLog(eEvent.EV_SCHEDULER, "System", $"wafer shuttle {waferHolderId} scheduler {item.SchedulerIndex} module {item.Module} start time {startTime} end time {endTime} processLength {item.ProcessTimeLength} s");
            }
        }
        /// <summary>
        /// 移除所有WaferHolder dryer时间轴
        /// </summary>
        public void RemoveAllWaferHolderDryerCell(string waferHolderId)
        {
            List<string> waferHolderIds = _waferHolderTimeDic.Keys.ToList();
        }
        /// <summary>
        /// 移除其他WaferHolder后续的cell时间轴
        /// </summary>
        /// <param name="waferHolderId"></param>
        public void RemoveOtherWaferHolderAfterCell(string waferHolderId,bool isRemoveCurrentSequence)
        {
        }
        /// <summary>
        /// 计算调度Sequence时长
        /// </summary>
        /// <param name="sequence"></param>
        /// <returns></returns>
        private int CalculateSequenceProcessTime(SchedulerSequence sequence)
        {
            int transporterTransferSeconds = SC.GetValue<int>("Transporter.TransporterTransferSeconds");
            if (sequence.ModuleType == ModuleType.Transporter)
            {
                return transporterTransferSeconds;
            }
            else if (sequence.ModuleType == ModuleType.Metal)
            {
                if(sequence.Recipe is DepRecipe)
                {
                    DepRecipe depRecipe = (DepRecipe)sequence.Recipe;
                    return depRecipe.CalculateRecipeTotalTime();
                }
            }
            else if (sequence.ModuleType == ModuleType.Rinse)
            {
                if(sequence.Recipe is QdrRecipe)
                {
                    QdrRecipe qdrRecipe = (QdrRecipe)sequence.Recipe;
                    return qdrRecipe.CalculateRunRecipeTime();
                }
            }
            else if (sequence.ModuleType == ModuleType.Dryer)
            {
                if(sequence.Recipe is HvdRecipe)
                {
                    HvdRecipe hvdRecipe = (HvdRecipe)sequence.Recipe;
                    return hvdRecipe.DryTime;
                }
            }
            return 0;
        }
        /// <summary>
        /// 移除模块时间轴
        /// </summary>
        /// <param name="moduleType"></param>
        /// <param name="module"></param>
        /// <param name="waferHolderId"></param>
        /// <param name="sequenceIndex"></param>
        private void RemoveModuleTime(ModuleType moduleType,string module,string waferHolderId,int sequenceIndex)
        {
            switch (moduleType)
            {
                case ModuleType.Metal:
                    SchedulerMetalTimeManager.Instance.RemoveMetalStartTime(module, waferHolderId, sequenceIndex);
                    break;
                case ModuleType.Rinse:
                    SchedulerQdrTimeManager.Instance.RemoveQdrStartTime(module, waferHolderId, sequenceIndex);
                    break;
                case ModuleType.Dryer:
                    SchedulerDryerTimeManager.Instance.RemoveDryerStartTime(module, waferHolderId, sequenceIndex);
                    break;
                case ModuleType.Transporter:
                    if (module == ModuleName.Transporter1.ToString())
                    {
                        SchedulerTransporterTimeManager.Instance.RemoveTransporterStartTime(module, waferHolderId, sequenceIndex);
                    }
                    break;
                default:
                    break;
            }
        }
        
        /// <summary>
        /// 所有WaferHolder重新调度
        /// </summary>
        public void ResetScheduler(string waferHolderId,DateTime startTime)
        {
            List<string> waferHolderIds = _waferHolderTimeDic.Keys.ToList();
            List<SchedulerWaferHolderTime> schedulerWaferHolderTimes = new List<SchedulerWaferHolderTime>();
            foreach(var key in waferHolderIds)
            {
                //过滤已经到了Dryer的WaferShuttle
                if (key != waferHolderId)
                {
                }

                SchedulerWaferHolderTime schedulerWaferHolderTime = _waferHolderTimeDic[key];
                schedulerWaferHolderTimes.Add(schedulerWaferHolderTime);
            }
            List<SchedulerWaferHolderTime> resetWaferHolderTimeLst= schedulerWaferHolderTimes.OrderBy(O => O.ResProcessLength).ToList();
            foreach(SchedulerWaferHolderTime item in resetWaferHolderTimeLst) 
            {
                SchedulerWaferHolderModuleTime moduleTime= item.ModuleTimes.Find(O => O.SchedulerIndex == item.LastSequenceIndex);
                if (moduleTime == null)
                {
                    continue;
                }
                DateTime dateTime = DateTime.MinValue;
                if (waferHolderId == item.WaferHolderId)
                {
                    dateTime = startTime;
                }
                else
                {
                    dateTime=moduleTime.ScheduleStartTime.AddSeconds(moduleTime.ProcessTimeLength);
                }
                ResetSchedulerWaferHolder(item.WaferHolderId,dateTime,item.LastSequenceIndex+1);
            }
        }
        /// <summary>
        /// 重新调度
        /// </summary>
        /// <param name="waferHolderId"></param>
        private void ResetSchedulerWaferHolder(string waferHolderId,DateTime startTime,int sequenceIndex)
        {
        }
        /// <summary>
        /// 清除所有数据
        /// </summary>
        public void RemoveAllWaferHolder()
        {
            List<string> keys = _waferHolderTimeDic.Keys.ToList();
            foreach (string item in keys)
            {
                SchedulerWaferHolderTime moduleTime = _waferHolderTimeDic[item];
                moduleTime.Dispose();
            }
            _waferHolderTimeDic.Clear();
        }

        /// <summary>
        /// 延后metal后续时间
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="schedulerIndex"></param>
        /// <param name="seconds"></param>
        public void DelayWaferHolderSchedulerStartTime(string waferHolderId, int schedulerIndex, double seconds)
        {
            if (_waferHolderTimeDic.ContainsKey(waferHolderId))
            {
                SchedulerWaferHolderTime waferHolderTime = _waferHolderTimeDic[waferHolderId];
                List<SchedulerWaferHolderModuleTime> moduleTimes = waferHolderTime.ModuleTimes.FindAll(O => O.SchedulerIndex >= schedulerIndex);
                foreach (var item in moduleTimes)
                {
                    item.ScheduleStartTime = item.ScheduleStartTime.AddSeconds(seconds);
                }
                WriteSchedulerTimeLog(waferHolderId);
            }
        }
        /// <summary>
        /// 获取WaferHolder模块调度起始时间
        /// </summary>
        /// <param name="waferHolderId"></param>
        /// <param name="module"></param>
        /// <param name="schedulerIndex"></param>
        /// <returns></returns>
        public DateTime GetWaferHolderModuleSchedulerStartTime(string waferHolderId,string module,int schedulerIndex)
        {
            if (!_waferHolderTimeDic.ContainsKey(waferHolderId))
            {
                return DateTime.MinValue;
            }
            SchedulerWaferHolderTime waferHolderTime = _waferHolderTimeDic[waferHolderId];
            SchedulerWaferHolderModuleTime waferHolderModuleTime= waferHolderTime.ModuleTimes.Find(O => O.SchedulerIndex == schedulerIndex && O.Module == module);
            if (waferHolderModuleTime == null)
            {
                return DateTime.MinValue;
            }
            return waferHolderModuleTime.ScheduleStartTime;
        }
    }
}