using System;
using System.Diagnostics;
using SicModules.Cassettes;
using SicModules.PMs;
using SicRT.Equipments.Systems;

namespace SicRT.Modules.Schedulers
{
    public class SchedulerCassette : SchedulerModule
    {
        #region Variables

        private readonly CassetteModule _cass;

        private readonly PMModule _pm1, _pm2;
        
        /// <summary>
        /// 最后一次传盘动作是Pick还是Place。
        /// </summary>
        private TaskType _lastTransferAction;

        /// <summary>
        /// 最后一次传盘的槽位。
        /// </summary>
        private int _lastTransferSlot;

        #endregion
  
        #region Constructors

        public SchedulerCassette(ModuleName module) : base(module.ToString())
        {
            _module = module.ToString();
            _cass = Singleton<EquipmentManager>.Instance.Modules[module] as CassetteModule;
            _pm1 = Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule;
            _pm2 = Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM2] as PMModule;
        }

        #endregion

        #region Properties

        public override bool IsAvailable => IsOnline && _cass.IsIdle && CheckTaskDone();

        public override bool IsOnline => _cass.IsOnline;

        public override bool IsError => _cass.IsError;

        #endregion

        #region Methods

        public bool Monitor()
        {
            return true;
        }

        public override bool IsReadyForPlace(ModuleName robot, int slot)
        {
            return WaferManager.Instance.CheckNoWafer(_cass.Module, slot) && WaferManager.Instance.CheckNoTray(ModuleHelper.Converter(_cass.Module), slot);
        }

        public override bool IsReadyForPick(ModuleName robot, int slot)
        {
            return true;
        }

        /// <summary>
        /// Manual模式进入等待时调用此函数，_lastTransferAction被设置为 **TransferTarget**。
        /// </summary>
        /// <param name="robot"></param>
        /// <returns></returns>
        /// <exception cref="NotSupportedException"></exception>
        public override bool WaitTransfer(ModuleName robot)
        {
            _lastTransferSlot = -1;
            return base.WaitTransfer(robot);
        }

        /// <summary>
        /// AutoRun模式进入等待时调用此函数，_lastTransferAction被设置为 **Pick** 或 **Place** 。
        /// </summary>
        /// <param name="robot"></param>
        /// <param name="isPick"></param>
        /// <param name="slot"></param>
        /// <returns></returns>
        public bool WaitTransfer(ModuleName robot, bool isPick, int slot)
        {
            _lastTransferAction = isPick ? TaskType.Pick : TaskType.Place;
            _lastTransferSlot = slot;
            return base.WaitTransfer(robot);
        }

        
        public override bool StopWaitTransfer(ModuleName robot)
        {
            var ret = base.StopWaitTransfer(robot);
            if (ret)
            {
                // 当Wafer返回到Cassette时，触发警告，响蜂鸣器
                //! 注意：报警提示逻辑仅在AutoRun模式时生效，Manual模式没有此逻辑。
                // 如何区分AutoRun还是ManualRun？参考WaitTransfer()调用：
                //   1. 当调用WaitTransfer(ModuleName robot)是表示Manual模式
                //   2. 当调用WaitTransfer(ModuleName robot, bool isPick, int slot)表示AutoRun模式
                // WaitTransfer()两个重载中对_lastTransferAction的赋值不同，AutoRun模式_lastTransferAction为Pick或Place，而Manual模式为TransferTarget

                if (robot == ModuleName.WaferRobot
                    && _lastTransferAction == TaskType.Place
                    && WaferManager.Instance.CheckHasWafer(_module, _lastTransferSlot))
                {
                    //EV.PostMessage(Module.ToString(), EventEnum.PJ_DONE, _module, (_lastTransferSlot + 1).ToString());
                    OP.DoOperation("System.AlertJobDone", _module, _lastTransferSlot + 1);
                }
            }

            return ret;
        }

        public override void ResetTask()
        {
            base.ResetTask();
            _lastTransferAction = TaskType.None;
            _lastTransferSlot = -1;
        }

        public bool CheckTaskDone()
        {
            var taskSucceed = false;
            switch (_task)
            {
                case TaskType.None:
                    taskSucceed = true;
                    break;
            }

            return SuperCheckTaskDone(taskSucceed, _cass.IsIdle | _cass.IsError);
        }
        
        
        #endregion
        
    }
}