using Aitex.Core.Common;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.VariantTypes;
using FurnaceRT.Equipments.Systems;
using MECF.Framework.Common.CommonData.EnumData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Utilities;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace FurnaceRT.Equipments.PMs
{
    public partial class PMModule
    {

        private void InitScheduleMaintenance()
        {

            new ScheduleMaintenanceData(MaintenanceItemEnum.SDCarrierUseFreq.ToString(), "Times", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferThickness.ToString(), "Å", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDUsableDummyWafer.ToString(), "Sheets", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDBufferRackStayTime.ToString(), "h:m", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferUserTime.ToString(), "h:m", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");


            new ScheduleMaintenanceData(MaintenanceItemEnum.FDCarrierUseFreq.ToString(), "Times", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferThickness.ToString(), "Å", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDUsableDummyWafer.ToString(), "Sheets", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDBufferRackStayTime.ToString(), "h:m", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
            new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferUserTime.ToString(), "h:m", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");


            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatRecipeThickness1.ToString(), "Å", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatTCUseTime.ToString(), "h:m", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatCKDUseTime.ToString(), "h:m", "Boat");
            new ScheduleMaintenanceData(MaintenanceItemEnum.BoatPUMPUseTime.ToString(), "h:m", "Boat");



            new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime1.ToString(), "h:m", "Conditioning");
            new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime2.ToString(), "h:m", "Conditioning");

            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeExecuteFreq.ToString(), "Times", "Reactor.Recipe", "Select Recipe");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness.ToString(), "Å", "Reactor.Recipe", "Select Recipe");


            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq1.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq2.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq3.ToString(), "Times", "Reactor.StepRunFreq", "Step ID");


            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime1.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime2.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime3.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime4.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime5.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime6.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime7.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime8.ToString(), "h:m", "Reactor.StepRunTime", "Step ID");



            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness1_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness2_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness3_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness4_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness5_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness6_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness7_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");
            new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness8_Step.ToString(), "Å", "Reactor.StepThickness", "Step Group");


        }

        public void MaintenanceProcessingCommandExec(string maintenanceProcessing, AlarmReportItem alarmReportItem)
        {
            if (Enum.TryParse<MaintenanceProcessingCommandEnum>(maintenanceProcessing, out var command))
            {
                switch (command)
                {
                    case MaintenanceProcessingCommandEnum.None:
                        break;
                    case MaintenanceProcessingCommandEnum.AlarmReport:
                        alarmReportItem?.Exec();
                        break;
                    case MaintenanceProcessingCommandEnum.JobProhibition:
                        break;
                    case MaintenanceProcessingCommandEnum.JobManualStart:
                        break;
                    case MaintenanceProcessingCommandEnum.JobAutoStart:
                        break;
                }
            }
        }

        #region Carrier/Wafer

        public void UpdateSEDWafer()
        {
            var ccc = BinarySerializer<Dictionary<ModuleName, Dictionary<int, WaferInfo>>>.FromStream("WaferManager");
            if (ccc == null)
                return;


            List<WaferInfo> waferInfos = new List<WaferInfo>();


            foreach (var moduleWafers in ccc)
            {
                waferInfos.AddRange(moduleWafers.Value.Select(a => a.Value));
            }
            if (waferInfos.Any(a => a.WaferType == WaferType.ED))
            {

                var maxEDUseCount = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseCount);
                var maxEDUseThick = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseThick);
                var maxEDUseTime = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseTime);


                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDCarrierUseFreq.ToString(), out var FDCarrierUseFreq))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDCarrierUseFreq.Item, maxEDUseCount);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDWaferThickness.ToString(), out var FDWaferThickness))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDWaferThickness.Item, maxEDUseThick);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.FDWaferUserTime.ToString(), out var FDWaferUserTime))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(FDWaferUserTime.Item, maxEDUseTime);
            }
            if (waferInfos.Any(a => a.WaferType == WaferType.SD))
            {

                var maxSDUseCount = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseCount);
                var maxSDUseThick = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseThick);
                var maxSDUseTime = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseTime);
                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDCarrierUseFreq.ToString(), out var SDCarrierUseFreq))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDCarrierUseFreq.Item, maxSDUseCount);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDWaferThickness.ToString(), out var SDWaferThickness))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDWaferThickness.Item, maxSDUseThick);

                if (Singleton<ScheduleMaintenanceDataManager>.Instance.Item.TryGetValue(MaintenanceItemEnum.SDWaferUserTime.ToString(), out var SDWaferUserTime))
                    Singleton<ScheduleMaintenanceDataManager>.Instance.SetValue(SDWaferUserTime.Item, maxSDUseTime);
            }

        }
        #endregion


        #region DataItemEnum.Reactor 模块

        /// <summary>
        /// 根据RecipeStep +StepGroup统计  累计膜厚
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepGroupThickness(string stepName, float thickness)
        {
            if (string.IsNullOrEmpty(stepName) || thickness <= 0)
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();
            var list = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values
                .Where(a => !string.IsNullOrEmpty(a.AdditionInformationDisplaySupplement))
                .Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepThickness}")
                .Where(a => a.AdditionInformationDisplaySupplement.Split(',').Contains(stepNo))
                .ToList();
            if (list == null || list.Count == 0)
                return;

            foreach (var item in list)
            {
                if (item == null)
                    continue;
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, thickness);


                if (item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue)
                    MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.ReatorStepThicknessWarning.Set, $"more than {item.StartValue} Å"));

                if (item.CurrentValue >= item.LimitValue)
                    MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.ReatorStepThicknessAlarm.Set, $"more than {item.LimitValue} Å"));

            }
        }
        /// <summary>
        /// 根据RecipeStep统计 Step执行Time 累计时间
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepRunTime(string stepName, double stepTime)
        {
            if (string.IsNullOrEmpty(stepName) || stepTime <= 0)
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();
            var list = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunTime}" && a.AdditionInformationDisplay == stepNo).ToList();
            if (list == null || list.Count == 0)
                return;
            foreach (var item in list)
            {
                if (item == null)
                    continue;
                var data = Math.Round(stepTime, 1, MidpointRounding.AwayFromZero);
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, (float)data);



            }

        }
        /// <summary>
        /// 根据RecipeStep统计 Step执行 累计次数
        /// </summary>
        /// <param name="recipeName"></param>
        public void UpdateRecipeStepFre(string stepName)
        {
            if (string.IsNullOrEmpty(stepName))
                return;
            var stepNo = stepName.Split(':').FirstOrDefault();
            var list = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.StepRunFreq}" && a.AdditionInformationDisplay == stepNo).ToList();
            if (list == null || list.Count == 0)
                return;
            foreach (var item in list)
            {
                if (item == null)
                    continue;
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item);


                if (item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue)
                    MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.ReatorStepRunFreqWarning.Set, $"more than {item.StartValue} times"));

                if (item.CurrentValue >= item.LimitValue)
                    MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.ReatorStepRunFreqAlarm.Set, $"more than {item.LimitValue} times"));

            }

        }
        /// <summary>
        /// 根据RecipeName统计 Recipe执行 累计次数
        /// </summary>
        /// <param name="processRecipeName"></param>
        public void UpdateRecipeFre(string recipeName)
        {

            if (string.IsNullOrEmpty(recipeName))
                return;
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString() && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" && a.AdditionInformationDisplay == recipeName).FirstOrDefault();
            if (item == null)
                return;
         
            if (item != null && item.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString())
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item);


        }
        /// <summary>
        /// 根据RecipeName统计累计膜厚
        /// </summary>
        /// <param name="recipeName"></param>
        /// <param name="thickness"></param>
        public void UpdateRecipeThickness(string recipeName, float thickness)
        {
            if (string.IsNullOrEmpty(recipeName) || thickness <= 0)
                return;
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Item == MaintenanceItemEnum.RecipeThickness.ToString() && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" && a.AdditionInformationDisplay == recipeName).FirstOrDefault();

            if (item == null)
                return;

            if (item != null && item.Item == MaintenanceItemEnum.RecipeThickness.ToString())
                Singleton<ScheduleMaintenanceDataManager>.Instance.Increase(item.Item, thickness);

        }


        #endregion

        #region 检查是否超过设定值

        public bool CheckRecipeExecuteFreqMoreThan(string recipeName)
        {

            if (string.IsNullOrEmpty(recipeName))
                return false;
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Item == MaintenanceItemEnum.RecipeExecuteFreq.ToString() && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" && a.AdditionInformationDisplay == recipeName).FirstOrDefault();
            if (item == null)
                return false;

            if (item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue)
            {
                MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.RecipeExecuteFreqWarning.Set, $"more than {item.StartValue} times"));
                return false;
            }

            if (item.CurrentValue >= item.LimitValue)
            {
                MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.RecipeExecuteFreqAlarm.Set, $"more than {item.LimitValue} times"));
                return true;
            }
            return false;
        }
        public bool CheckRecipeThicknessMoreThan(string recipeName)
        {
            if (string.IsNullOrEmpty(recipeName))
                return false;
            var item = Singleton<ScheduleMaintenanceDataManager>.Instance.Item.Values.Where(a => a.Item == MaintenanceItemEnum.RecipeThickness.ToString() && a.Path == $"{DataItemEnum.Reactor}.{ReactorsEnum.Recipe}" && a.AdditionInformationDisplay == recipeName).FirstOrDefault();

            if (item == null)
                return false;

            if (item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue)
            {
                MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.RecipeThicknessWarning.Set, $"more than {item.StartValue} Å"));
                return false;
            }

            if (item.CurrentValue >= item.LimitValue)
            {
                MaintenanceProcessingCommandExec(item.MaintenanceProcessing, new AlarmReportItem(Singleton<EquipmentManager>.Instance.RecipeThicknessAlarm.Set, $"more than {item.LimitValue} Å"));
                return true;
            }

            return false;
        }
        #endregion
    }
}