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;

namespace CyberX8_RT.Modules.EFEM
{
    class EfemHomeRoutine : ModuleRoutineBase, IRoutine
    {
        private enum HomeStep
        {
            ClearError,
            SetHomeSpeed,
            InitRobot,
            InitLP1,
            InitLP2,
            InitLP3,
            InitAligner,
            CheckWaferPresence,
            SetDummy1Size,
            MapDummy1,
            SetDummy2Size,
            MapDummy2,
            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 int _waferSize = SC.GetValue<int>("System.WaferSize");
        bool _isDummy1Install = ModuleHelper.IsInstalled(ModuleName.Dummy1);
        bool _isDummy2Install = ModuleHelper.IsInstalled(ModuleName.Dummy2);
        Hand _hand = Hand.Blade1;
        
        public EfemHomeRoutine(EfemBase efem) : base(ModuleName.EfemRobot)
        {
            _efem = 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.ClearError,            ClearError,             IsStepComplete,         _delay_5s)
                    .Run(HomeStep.SetHomeSpeed,            SetHomeSpeed,           IsStepComplete,         _delay_5s)
                    .Run(HomeStep.InitRobot,                       () => { return HomeModule(ModuleName.EfemRobot); },   IsStepComplete, _homeTimeout)
                    .RunIf(HomeStep.InitLP1,        !_isLP1Unable, () => { return HomeModule(ModuleName.LP1); },     IsStepComplete, _homeTimeout)
                    .RunIf(HomeStep.InitLP2,        !_isLP2Unable, () => { return HomeModule(ModuleName.LP2); },     IsStepComplete, _homeTimeout)
                    .RunIf(HomeStep.InitLP3,        !_isLP3Unable, () => { return HomeModule(ModuleName.LP3); },     IsStepComplete, _homeTimeout)
                    .Run(HomeStep.InitAligner,                     () => { return HomeModule(ModuleName.Aligner1); },IsStepComplete, _homeTimeout)
                    .Run(HomeStep.CheckWaferPresence,      CheckWaferPresence,     VerifyWaferPresence,    _delay_5s)
                    .RunIf(HomeStep.SetDummy1Size, _isDummy1Install, () => { return SetWaferSize(ModuleName.Dummy1); }, CheckSetSizeDone, _delay_5s)
                    .RunIf(HomeStep.MapDummy1,     _isDummy1Install, () => { return Map(ModuleName.Dummy1); }, CheckMapDone, _homeTimeout)
                    .RunIf(HomeStep.SetDummy2Size, _isDummy2Install, () => { return SetWaferSize(ModuleName.Dummy2); }, CheckSetSizeDone, _delay_5s)
                    .RunIf(HomeStep.MapDummy2,     _isDummy2Install, () => { return Map(ModuleName.Dummy2); }, CheckMapDone, _homeTimeout)
                    .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.HomeAxes,       HomeModuleAxes,     IsStepComplete,     _homeTimeout)
                    .Run(HomeModuleStep.SetRobotSpeed,  SetRobotSpeed,      IsStepComplete, _delay_5s)
                    .End(HomeModuleStep.End,        NullFun,            _delay_50ms);
            }
            return Runner.Status;
        }

        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 CheckSetSizeDone()
        {
            if (_efem.Status == RState.End)
            {
                return true;
            }
            else if (_efem.Status != RState.Running)
            {
                LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, Module, $"Efem SetDummySize failed: {_efem.Status}");
                return true;
            }

            return false;
        }
        private bool CheckMapDone()
        {
            if (_efem.Status == RState.End)
            {
                return true;
            }
            else if (_efem.Status == RState.Failed)
            {
                LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, Module, $"Efem MapDummy failed: {_efem.Status}");
                return true;
            }

            return false;
        }

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

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

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

        private bool Map(ModuleName mod)
        {
            return _efem.Map(mod);
        }

        private bool SetWaferSize(ModuleName mod)
        {

            return _efem.SetWaferSize(mod, _waferSize);

        }

        private bool HomeModule(ModuleName mod)
        {
            return _efem.Home(mod);
        }

        private bool GetWaferSize(ModuleName mod)
        {
            return _efem.GetWaferSize(mod);
        }

        private bool HomeAllAxes()
        {
            return _efem.OriginalSearch(ModuleName.EFEM);
        }

        private bool HomeModuleAxes()
        {
            return _efem.OriginalSearch(_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;
        }

    }
}