using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Sorter.RT.EFEMs.Servers;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.BufferStations;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;


namespace Aitex.Sorter.RT.EFEMs.Tasks
{
    public class WafshTask : CheckImp, ITask
    {
        public WafshTask()
        {
        }
        public bool Execute(out string result, params string[] args)
        {
            string device = Args2Unit(args.Length > 0 ? args[0] : string.Empty);
            SystemServerModule entity = (SystemServerModule)GetEntity(DeviceName.System);
            if (entity == null)
            {
                result = PARAM_NG;
                return false;
            }

            if (!Check<NoReadyPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<NoInitCompletedPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<NoOriginCompletedPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<VacPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<AirPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<EMSPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<ErrorPolicy>(device, out result))
            {
                return false;
            }

            if (!Check<ErrorPolicy>(DeviceName.Robot, out result))
            {
                return false;
            }

            if (!Check<ErrorPolicy>(DeviceName.System, out result))
            {
                return false;
            }

            if (!Check<BusyPolicy>(device, out result))
            {
                return false;
            }

            if (!Check<HoldPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<RemovePolicy>(device, out result))
            {
                return false;
            }
            if (!Check<MaintenancePolicy>(device, out result))
            {
                return false;
            }
            if (!Check<LinkPolicy>(device, out result))
            {
                return false;
            }

            if (!Check<PowerDownPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<NoPosPolicy>(device, out result))
            {
                return false;
            }

            if (!Check<NoPodPolicy>(device, out result))
            {
                return false;
            }
            if (!Check<ClosePolicy>(device, out result))
            {
                return false;
            }

            if (ModuleHelper.IsLoadPort(ModuleHelper.Converter(device)))
            {
                if (Singleton<EfemEntity>.Instance.EfemDevice.IsMapLoadPortByRobot)
                {
                    if (Singleton<EfemEntity>.Instance.EfemDevice.IsError)
                    {
                        result = "ERROR";
                        return false;
                    }

                    if (!Singleton<EfemEntity>.Instance.EfemDevice.IsIdle)
                    {
                        LOG.Write($"RouteManager is Busy");

                        result = "BUSY";
                        return false;
                    }

                    if (!Singleton<EfemEntity>.Instance.EfemDevice.IsEnableMapWhileWaferOnArm)
                    {
                        if (WaferManager.Instance.CheckHasWafer(ModuleName.Robot, 0) ||
                            WaferManager.Instance.CheckHasWafer(ModuleName.Robot, 1))
                        {
                            EV.PostWarningLog("EFEM", "Can not map if robot has wafer");
                            result = "WAFER";
                            return false;
                        }
                    }

                    if (args.Length > 1)
                    {
                        if (int.TryParse(args[1], out int integerParameter))
                        {
                            _token = Singleton<EfemEntity>.Instance.EfemDevice.Invoke("MapWafer", device, integerParameter, Hand.Blade1);
                        }
                        else
                        {
                            _token = Singleton<EfemEntity>.Instance.EfemDevice.Invoke("MapWafer", device);
                        }
                    }
                    else
                    {
                        _token = Singleton<EfemEntity>.Instance.EfemDevice.Invoke("MapWafer", device);
                    }
                }
                else
                {
                    LoadPortServerModule lpEntity = (LoadPortServerModule)GetEntity(device);
                    if (lpEntity == null)
                    {
                        result = PARAM_NG;
                        return false;
                    }

                    if (!lpEntity.Map(out result))
                    {
                        return false;
                    }
                }
            }
            if (ModuleHelper.IsBuffer(ModuleHelper.Converter(device)))
            {
                if (Singleton<EfemEntity>.Instance.EfemDevice.IsError)
                {
                    result = "ERROR";
                    return false;
                }

                if (!Singleton<EfemEntity>.Instance.EfemDevice.IsIdle)
                {
                    LOG.Write($"RouteManager is Busy");

                    result = "BUSY";
                    return false;
                }
                if (WaferManager.Instance.CheckHasWafer(ModuleName.Robot, 0) ||
                    WaferManager.Instance.CheckHasWafer(ModuleName.Robot, 1))
                {
                    EV.PostWarningLog("EFEM", "Can not map if robot has wafer");
                    result = "WAFER";
                    return false;
                }
                var bufferStation = DEVICE.GetDevice<BufferStation>(device);

                if (args.Length > 1)
                {
                    if (int.TryParse(args[1], out int integerParameter))
                    {
                        _token = Singleton<EfemEntity>.Instance.EfemDevice.Invoke("MapWafer", bufferStation.Name, integerParameter, Hand.Blade1);
                    }
                    else
                    {
                        _token = Singleton<EfemEntity>.Instance.EfemDevice.Invoke("MapWafer", bufferStation.Name);
                    }
                }
                else
                {
                    _token = Singleton<EfemEntity>.Instance.EfemDevice.Invoke("MapWafer", bufferStation.Name);
                }

            }
            return true;
        }
        public bool? Monitor(out string result, params string[] args)
        {
            result = string.Empty;
            string device = Args2Unit(args.Length > 0 ? args[0] : string.Empty);

            if (ModuleHelper.IsLoadPort(ModuleHelper.Converter(device)))
            {
                if (Singleton<EfemEntity>.Instance.EfemDevice.IsMapLoadPortByRobot)
                {
                    if (Singleton<EfemEntity>.Instance.EfemDevice.IsError)
                    {
                        result = "ERROR";
                        return false;
                    }

                    if (Singleton<EfemEntity>.Instance.EfemDevice.IsIdle &&
                        Singleton<EfemEntity>.Instance.EfemDevice.CheckAcked(_token))
                    {
                        return true;
                    }
                }
                else
                {
                    LoadPortServerModule lpEntity = (LoadPortServerModule)GetEntity(device);
                    if (lpEntity.Error)
                    {
                        result = "ERROR";
                        return false;
                    }

                    if (lpEntity.IsStateIdle)
                    {
                        Singleton<EfemEntity>.Instance.SendMapEvent(DEVICE.GetDevice<LoadPort>(device));
                        return true;
                    }
                }



            }

            if (ModuleHelper.IsBuffer(ModuleHelper.Converter(device)))
            {
                if (Singleton<EfemEntity>.Instance.EfemDevice.IsError)
                {
                    result = "ERROR";
                    return false;
                }

                if (Singleton<EfemEntity>.Instance.EfemDevice.IsIdle &&
                    Singleton<EfemEntity>.Instance.EfemDevice.CheckAcked(_token))
                {
                    return true;
                }
            }


            return null;
        }
    }


}