using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using Venus_RT.Modules.VCE;
using Venus_RT.Scheduler;

namespace Venus_RT.Modules.Schedulers
{
    public class SchedulerLoadPort : SchedulerModule
    {
        public override bool IsAvailable
        {
            get { return IsIdle && IsLoaded && CheckTaskDone(); }

        }

        public override bool IsOnline
        {
            get { return _isVenus ? _vceEntity.IsOnline : _entity.IsOnline; }

        }

        public override bool IsError
        {
            get { return _isVenus ? _vceEntity.IsError : _entity.IsError; }

        }

        public override bool IsIdle
        {
            get { return _isVenus ? _vceEntity.IsIdle : _entity.IsIdle; }
        }

        public bool IsLoaded
        {
            get { return _isVenus ? _vceEntity.VCEDevice[Module].IsLoaded : _entity.EfemDevice[Module].IsLoaded; }
        }

        private EfemEntity _entity = null;
        private VceEntity _vceEntity = null;
        private bool _isVenus = RtInstance.ConfigType == Venus_Core.ConfigType.VenusSE || RtInstance.ConfigType == Venus_Core.ConfigType.VenusDE; 

        public SchedulerLoadPort(ModuleName module) : base(module.ToString())
        {
            _module = module.ToString();
            switch (RtInstance.ConfigType)
            {
                case Venus_Core.ConfigType.VenusSE:
                    _vceEntity = Singleton<RouteManager>.Instance.VCE;
                    break;
                case Venus_Core.ConfigType.VenusDE:
                    if (module == ModuleName.LP2)
                        _vceEntity = Singleton<RouteManager>.Instance.VCEB;
                    else
                        _vceEntity = Singleton<RouteManager>.Instance.VCEA;
                    break;
                default:
                    _entity = Singleton<RouteManager>.Instance.EFEM;
                    break;
            }
        }

        public bool Load()
        {
            //_busy = true;
            //_entity.Load(_chamber);
            return true;
        }

        public bool Unload()
        {
            //_busy = true;
            //_entity.Unloaded(_chamber);
            return true;
        }


        public bool Monitor()
        {
            return true;
        }


        public override bool IsReadyForPick(ModuleName robot, int slot, Hand blade)
        {
            return _entity.IsPrepareTransferReady(Module, EnumTransferType.Pick, slot)
                   && WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_module), slot);
        }

        public override bool IsReadyForPlace(ModuleName robot, int slot, Hand blade)
        {
            return _entity.IsPrepareTransferReady(Module, EnumTransferType.Place, slot)
                   && WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(_module), slot);
        }

        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.PrepareTransfer:
                    ret = _entity.IsPrepareTransferReady(ModuleName.EfemRobot, EnumTransferType.Pick, 0);
                    break;
            }

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

            return ret;
        }

        internal bool CheckReadyRunJob()
        {
            return _entity.CheckReadyRunNewJob(this.Module);
        }

        internal bool CheckReadyTransfer()
        {
            return _entity.CheckReadyTransfer(this.Module);
        }

        internal bool CheckPlaced()
        {
            return _entity.CheckPlaced(this.Module);
        }


        public void NoteJobStart()
        {
            _entity.NoteJobStart(ModuleHelper.Converter(_module));
        }

        public void NoteJobComplete()
        {
        }
    }
}