using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Schedulers;
using Aitex.Core.Common;
using CyberX8_Core;
using Aitex.Core.RT.Fsm;

namespace CyberX8_RT.Schedulers
{
    public class WaferMoveArgs : EventArgs
    {
        public ModuleName SrcModule
        {
            get; set;
        }

        public int SrcSlot
        {
            get; set;
        }

        public ModuleName DstModule
        {
            get; set;
        }

        public int DstSlot
        {
            get; set;
        }

        public WaferMoveArgs(ModuleName sourceModule, int sourceSlot, ModuleName dstModule, int dstSlot)
        {
            SrcModule = sourceModule;
            SrcSlot = sourceSlot;
            DstModule = dstModule;
            DstSlot = dstSlot;
        }
    }
    public class SchedulerModule
    {
        public enum TaskType
        {
            None,

            PrepareTransfer,
            Pick,
            Place,
            PickAndPlace,
            PostTransfer,

            Preprocess,
            Process,
            PostProcess,

            IdlePurgeProcess,
            IdleCleanProcess,
            PreJobProcess,
            CompleteJobProcess,

            OpenCover,
            CloseCover,

            Load,
            Unload,

            Align,

            TransferTarget,

            Cooling,

            Heating,

            Map,

            Goto,
            Flip,
        }

        public ModuleName Module
        {
            get { return ModuleHelper.Converter(_module); }
        }
        public virtual bool IsAvailable { get; }
        public virtual bool IsOnline { get; }
        public virtual bool IsIdle { get; }
        public virtual bool IsError { get; private set; }

        public int InTransferSlot
        {
            get
            {
                return _inTransferSlot;
            }
        }

        protected string _module;

        protected TaskType _task = TaskType.None;

        protected EnumTransferType _inTransferType; 

        protected int _inTransferSlot;

        protected ModuleName _inProcessRobot;

        protected RState _state=RState.End;
        public Dictionary<int, long> WaferArriveTicks { get; set; }

        public EventHandler<WaferMoveArgs> EventWaferArrived;
        public EventHandler<WaferMoveArgs> EventWaferLeaved;
        
        public SchedulerModule(string module)
        {
            _module = module;
            WaferArriveTicks = new Dictionary<int, long>();
            WaferArriveTicks[3] = WaferArriveTicks[2] = WaferArriveTicks[1] = WaferArriveTicks[0] = DateTime.Now.Ticks;
        }
        protected void LogTaskStart(TaskType cmd, string message)
        {
            LOG.Write(eEvent.EV_SCHEDULER, ModuleName.System, $"Task start:{_module}, {cmd}, {message}");
        }
        protected void LogTaskDone(TaskType cmd, string message)
        {
            LOG.Write(eEvent.EV_SCHEDULER, ModuleName.System, $"Task done:{_module}, {cmd}, {message}");
        }
        public virtual void ResetTask()
        {
            _task = TaskType.None;
            _state=RState.End;
        }


        public virtual bool IsReadyForPick(ModuleName robot, int slot, Hand blade)
        {
            return true;
        }

        public virtual bool IsReadyForPlace(ModuleName robot, int slot, Hand blade)
        {
            return true;
        }

        public virtual bool Align(float time)
        {
            return true;
        }

        /// <summary>
        /// 检验前置条件 
        /// </summary>
        /// <param name="sequenceIndex"></param>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public virtual bool CheckPrecondition(List<SchedulerSequence> schedulerSequences,int sequenceIndex,object parameter,string materialId,ref string reason)
        {
            return true;
        }
        /// <summary>
        /// 执行
        /// </summary>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public virtual bool RunProcess(object recipe,object parameter,List<SchedulerSyncModuleMessage> syncMessages)
        {
            return true;
        }
        /// <summary>
        /// 同步触发另外实体的动作
        /// </summary>
        /// <param name="moduleEntities"></param>
        protected virtual void SynchorinzeModuleMessages(List<SchedulerSyncModuleMessage> moduleMessages)
        {
            if (moduleMessages == null)
            {
                return;
            }
            foreach (SchedulerSyncModuleMessage moduleEntity in moduleMessages)
            {
                IModuleEntity entity = moduleEntity.ModuleEntity;
                entity.Invoke(moduleEntity.ModuleMsg);
            }
        }
        /// <summary>
        /// 监控执行
        /// </summary>
        /// <returns></returns>
        public virtual bool MonitorProcess(SchedulerSequence schedulerSequence, bool hasMatchWafer)
        {
            return true;
        }
        /// <summary>
        /// 获取可用资源
        /// </summary>
        /// <returns></returns>
        public virtual bool GetAvaibleMaterial(int sequenceIndex,object parameter)
        {
            return true;
        }
    }

}