using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Sorter.Common;
using CyberX8_RT.Devices;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using CyberX8_Core;
using Aitex.Core.RT.Log;
using Aitex.Core.Common;
using Aitex.Core.Util;
using MECF.Framework.Common.Schedulers;
using System.Collections.Generic;
using CyberX8_RT.Devices.EFEM;
using MECF.Framework.Common.Utilities;

namespace CyberX8_RT.Modules.EFEM
{
    class EfemHomeRoutine : ModuleRoutineBase, IRoutine
    {
        private enum HomeStep
        {
            SetHomeSpeed,
            HomeAll,
            InitAligner,
            CheckWaferPresence,
            DummyMap,
            CheckDummyMap,
            SetRobotSpeed,
            End,
        }

        private enum HomeModuleStep
        {
            SetHomeSpeed,
            Home,
            HomeAxes,
            SetRobotSpeed,
            End,
        }

        private int _homeTimeout = 30 * 1000;
        ModuleName _targetModule;
        EfemBase _efem;
        int _defaultSpeed = SC.GetValue<int>("EFEM.DefaultMoveSpeedInPercent");
        int _homeSpeed = SC.GetValue<int>("EFEM.DefaultHomeSpeedInPercent");
        
        bool _isLP1Unable = SC.GetValue<bool>("EFEM.IsLoadPort1Unable");
        bool _isLP2Unable = SC.GetValue<bool>("EFEM.IsLoadPort2Unable");
        bool _isLP3Unable = SC.GetValue<bool>("EFEM.IsLoadPort3Unable");
        private 
        Hand _hand = Hand.Blade1;
        private EfemMapDummyRoutine _mapDummyRoutine;
        
        public EfemHomeRoutine(EfemBase efem) : base(ModuleName.EfemRobot)
        {
            _efem = efem;
            _mapDummyRoutine = new EfemMapDummyRoutine(efem);
        }

        public RState Start(params object[] objs)
        {
            if (WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, (int)_hand))
            {
                LOG.Write(eEvent.ERR_EFEM_ROBOT, Module, $"Efem robot arm{_hand} already has a wafer, cannot do the home action");
                return RState.Failed;
            }
            _isLP1Unable = SC.GetValue<bool>("EFEM.IsLoadPort1Unable");
            _isLP2Unable = SC.GetValue<bool>("EFEM.IsLoadPort2Unable");
            _isLP3Unable = SC.GetValue<bool>("EFEM.IsLoadPort3Unable");
            
            _defaultSpeed = SC.GetValue<int>("EFEM.DefaultMoveSpeedInPercent");
            _homeSpeed = SC.GetValue<int>("EFEM.DefaultHomeSpeedInPercent");
            
            _targetModule = (ModuleName)objs[0];
            _homeTimeout = SC.GetValue<int>($"EFEM.HomeTimeout") * 1000;
            return Runner.Start(Module, $"Home {_targetModule}");
        }

        public RState Monitor()
        {

            if(_targetModule == ModuleName.EFEM)
            {
                Runner.Run(HomeStep.SetHomeSpeed,            SetHomeSpeed,           IsStepComplete,         _delay_5s)
                    .Run(HomeStep.HomeAll,          HomeAll,   IsStepComplete, _homeTimeout)
                    //.Run(HomeStep.InitAligner,                     () => { return HomeModule(ModuleName.Aligner1); },IsStepComplete, _homeTimeout)
                    .Run(HomeStep.CheckWaferPresence,      CheckWaferPresence,     VerifyWaferPresence,    _delay_5s)
                    .Run(HomeStep.DummyMap, StartMapDummy,_delay_1ms)
                    .WaitWithStopCondition(HomeStep.CheckDummyMap,()=>CommonFunction.CheckRoutineEndState(_mapDummyRoutine),
                        ()=>CommonFunction.CheckRoutineStopState(_mapDummyRoutine))
                    .Run(HomeStep.SetRobotSpeed,           SetRobotSpeed,          IsStepComplete,         _delay_5s)
                    .End(HomeStep.End,                     NullFun,                                        _delay_1ms);
            }
            else
            {
                Runner.Run(HomeModuleStep.SetHomeSpeed, SetHomeSpeed,        IsStepComplete, _delay_5s)
                    .Run(HomeModuleStep.Home,           HomeModule,         IsStepComplete,     _homeTimeout)
                    .Run(HomeModuleStep.SetRobotSpeed,  SetRobotSpeed,      IsStepComplete, _delay_5s)
                    .End(HomeModuleStep.End,        NullFun,            _delay_50ms);
            }
            return Runner.Status;
        }

        private bool StartMapDummy()
        {
            return _mapDummyRoutine.Start() == RState.Running;
        }

        public void Abort()
        {

        }

        private bool IsStepComplete()
        {

            if (_efem.Status == RState.End)
            {
                return true;
            }
            else if (_efem.Status == RState.Failed)
            {
                Runner.Stop($"Efem home failed: {_efem.Status}");
                return true;
            }
            else
                return false;
        }

        private bool HomeAll()
        {
            return _efem.HomeAll();
        }

        private bool HomeModule()
        {
            return _efem.Home(_targetModule);
        }
        private bool CheckWaferPresence()
        {
            return _efem.CheckWaferPresence();
        }

        private bool SetHomeSpeed()
        {
            return _efem.SetRobotSpeed(ModuleName.EfemRobot, _homeSpeed);
        }

        private bool SetRobotSpeed()
        {
            return _efem.SetRobotSpeed(ModuleName.EfemRobot, _defaultSpeed);
        }

        private bool VerifyWaferPresence()
        {
            if (_efem.Status == RState.End)
            {
                var waferPresence = _efem.GetWaferPresence();
                //000/111 upperArmWafer, lowerArmWafer, alignerWafer1, 
                //if (waferPresence.Length != 3)
                //{
                //    LOG.Write(eEvent.ERR_EFEM_ROBOT, Module, $"EFEM Track wafer present return invalid value, Wafer Presence:{waferPresence}, should be 3 characters");
                //    return false;
                //}

               

                //aligner2
                //if (waferPresence[3] == '1')
                //{
                //    if (WaferManager.Instance.CheckNoWafer(ModuleName.Aligner2, 0))
                //    {
                //        WaferManager.Instance.CreateWafer(ModuleName.Aligner2, 0, WaferStatus.Normal);
                //    }
                //}
                //else
                //{
                //    if (WaferManager.Instance.CheckHasWafer(ModuleName.Aligner2, 0))
                //    {
                //        LOG.Write(eEvent.ERR_EFEM_ROBOT, Module, $" {ModuleName.Aligner2} has wafer information, while EFEM return empty, manually delete if really no wafer");
                //    }
                //}

                //cooling1
                //if (waferPresence[4] == '1')
                //{
                //    if (WaferManager.Instance.CheckNoWafer(ModuleName.Cooling1, 0))
                //    {
                //        WaferManager.Instance.CreateWafer(ModuleName.Cooling1, 0, WaferStatus.Normal);
                //    }
                //}
                //else
                //{
                //    if (WaferManager.Instance.CheckHasWafer(ModuleName.Cooling1, 0))
                //    {
                //        LOG.Write(eEvent.ERR_EFEM_ROBOT, Module, $" {ModuleName.Cooling1} has wafer information, while EFEM return empty, manually delete if really no wafer");
                //    }
                //}

                //cooling2
                //if (waferPresence[5] == '1')
                //{
                //    if (WaferManager.Instance.CheckNoWafer(ModuleName.Cooling2, 0))
                //    {
                //        WaferManager.Instance.CreateWafer(ModuleName.Cooling2, 0, WaferStatus.Normal);
                //    }
                //}
                //else
                //{
                //    if (WaferManager.Instance.CheckHasWafer(ModuleName.Cooling2, 0))
                //    {
                //        LOG.Write(eEvent.ERR_EFEM_ROBOT, Module, $" {ModuleName.Cooling2} has wafer information, while EFEM return empty, manually delete if really no wafer");
                //    }
                //}
                return true;
            }
            else if (_efem.Status == RState.Failed||_efem.Status==RState.Timeout)
            {
                LOG.Write(eEvent.ERR_EFEM_ROBOT, Module, $"Efem StateTrack failed: {_efem.Status}");
                return false;
            }
            else
                return false;
        }

    }
}