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 SicRT.Modules;
using SicRT.Modules.Schedulers;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using SicRT.Equipments.Systems;
using Mainframe.TMs;

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

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

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

        }

        private TMModuleBase _tmRobot = null;
 
        private Hand _taskHand;

        private Hand _taskSwapPickHand;
        private Hand _taskSwapPlaceHand;
        private int _taskSwapPickSlot;
        private int _taskSwapPlaceSlot;

        public SchedulerTMRobot() : base(ModuleName.TMRobot.ToString())
        {
            _tmRobot = Singleton<EquipmentManager>.Instance.Modules[ModuleName.TMRobot] as TMModuleBase;
        }
 

        public bool IsReadyForPick(Hand blade)
        {
            return WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)blade);
        }

        public bool IsReadyForPlace(Hand blade)
        {
            return WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)blade);
        }
 

        public bool Pick(ModuleName target, int slot, Hand hand)
        {
            _task = TaskType.Pick;
            _taskHand = hand;
            LogTaskStart(_task,$"{target}.{slot + 1}=>{Module}.{hand}");
            return _tmRobot.Pick(target, hand, slot, out string reason);
        }

        public bool Place(ModuleName target, int slot, Hand hand)
        {
            _task = TaskType.Place;
            _taskHand = hand;
            LogTaskStart(_task, $"{Module}.{hand}=>{target}.{slot + 1}");
            return _tmRobot.Place(target, hand, slot, out string reason);
        }

        //public bool PickAndPlace(ModuleName target, int pickSlot, int placeSlot, Hand pickHand, Hand placeHand)
        //{
        //    _task = TaskType.PickAndPlace;
        //    _taskSwapPickHand = pickHand;
        //    _taskSwapPlaceHand = placeHand;
        //    _taskSwapPickSlot = pickSlot;
        //    _taskSwapPlaceSlot = placeSlot;
        //    LogTaskStart(_task, $" {target}.{pickSlot + 1}=>{Module}.{pickHand} && {Module}.{placeHand}=>{target}.{placeSlot + 1}");
        //    return _tmRobot.PickAndPlace(target, pickSlot, placeSlot, pickHand, placeHand);
        //}

        public bool Goto(ModuleName chamber, int slot, Hand hand)
        {
            return true;
        }

        public bool Monitor()
        {
            return true;
        }

        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.Pick:
                    if (_taskHand == Hand.Both)
                    {
                        ret = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)Hand.Blade1)
                              && WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)Hand.Blade2);
                    }
                    else
                    {
                        ret = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)_taskHand);
                    }

                    break;
                case TaskType.Place:
                    if (_taskHand == Hand.Both)
                    {
                        ret = WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)Hand.Blade1)
                              && WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)Hand.Blade2);
                    }
                    else
                    {
                        ret = WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)_taskHand);
                    }
                    break;
                case TaskType.PickAndPlace:
                    ret = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)_taskSwapPickHand) 
                          && WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)_taskSwapPlaceHand);
                    break;
            }

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

            return ret;
        }
    }


}