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.Fsm;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadLocks;
using Mainframe.LLs;
using SicRT.Equipments;
using SicRT.Equipments.Systems;
using SicRT.Modules.Schedulers;
using MECF.Framework.Common.Device.Bases;

namespace SicRT.Scheduler
{
    public class SchedulerLoadLock : SchedulerModule  
    {
        public override bool IsAvailable
        {
            get
            {
                return _ll.IsIdle && _ll.IsOnline && CheckTaskDone();
            }
        }

        public override bool IsOnline
        {
            get 
            {
                return _ll.IsOnline;
            }
        }

        public override bool IsError
        {
            get 
            { 
                return _ll.IsError;
            }
        }

        private LoadLockModuleBase _ll = null;

        private ModuleName _taskRobot;
        private int _taskSlot;
        private int _entityTaskToken = (int)FSM_MSG.NONE;

        public SchedulerLoadLock(ModuleName module) : base(module.ToString())
        {
            _module = module.ToString();
            _ll = Singleton<EquipmentManager>.Instance.Modules[module] as LoadLockModuleBase;
        }

        public override bool PrepareTransfer(ModuleName robot, EnumTransferType type,  int slot)
        {
            _task = TaskType.PrepareTransfer;
            _taskRobot = robot;
            _taskSlot = slot;

            LogTaskStart(_task, $"{robot} {type} slot {slot + 1}");

            return _ll.PrepareTransfer(robot, Hand.Blade1, slot, type, out _);
        }

        internal bool CheckAtAtm()
        {
            SicLoadLock deviceLL = DEVICE.GetDevice<SicLoadLock>($"{_module}.{_module}");

            return deviceLL.CheckAtm();
        }
        internal bool CheckAtVacuum()
        {
            SicLoadLock deviceLL = DEVICE.GetDevice<SicLoadLock>($"{_module}.{_module}");

            return deviceLL.CheckVacuum();
        }
        internal void SetJobStatue()
        {
            SicLoadLock deviceLL = DEVICE.GetDevice<SicLoadLock>($"{_module}.{_module}");
            deviceLL.SetJobDoneStatus();
        }

        public override bool IsReadyForPick(ModuleName robot, int slot)
        {
            return _ll.CheckReadyForTransfer(robot, Hand.Blade1, slot, EnumTransferType.Pick, out _) 
                   && WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_module), slot); 
        }

        public override bool IsReadyForPlace(ModuleName robot, int slot)
        {
            return _ll.CheckReadyForTransfer(robot, Hand.Blade1, slot, EnumTransferType.Place, out _)
                   && WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(_module), slot);
        }
       

        public bool Vent()
        {
            _task = TaskType.Vent;

            _entityTaskToken = _ll.InvokeVent();

            LogTaskStart(_task, $"{Module} vent to ATM");

            return _entityTaskToken != (int)FSM_MSG.NONE;
        }

        public bool Pump()
        {
            _task = TaskType.Pump;
            _entityTaskToken = _ll.InvokePump();

            LogTaskStart(_task, $"{Module} pump to Vaccum");

            return _entityTaskToken != (int)FSM_MSG.NONE;

        }

        public bool Purge()
        {
            _task = TaskType.Purge;
            _entityTaskToken = _ll.InvokePurge();

            LogTaskStart(_task, $"{Module} purge for new job");

            return _entityTaskToken != (int)FSM_MSG.NONE;
        }

        public bool Monitor()
        {
            return true;
        }
 
        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.PrepareTransfer:
                    ret = _ll.CheckAcked(_entityTaskToken);//  && _ll.CheckReadyForTransfer(_taskRobot, Hand.Blade1, _taskSlot, EnumTransferType.Place, out _);
                    break;
                case TaskType.Cooling:
                    ret = _ll.CheckAcked(_entityTaskToken);
                    break;
                case TaskType.Vent:
                    ret = _ll.CheckAcked(_entityTaskToken);
                    break; 
                case TaskType.Pump:
                    ret = _ll.CheckAcked(_entityTaskToken);
                    break;
                case TaskType.Purge:
                    ret = _ll.CheckAcked(_entityTaskToken);
                    break;

            }

            if (ret && _task != TaskType.None)
            {
                LogTaskDone(_task,"");
                _task = TaskType.None;
            }

            return ret;
        }

    }


}