using System;
using System.Text.RegularExpressions;
using System.Threading;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using EFEM.RT.Devices;
using EFEM.RT.Modules;
using EFEM.RT.Tasks;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.LoadPortBase;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots.RobotBase;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.BufferStations;
using Aitex.Core.RT.SCCore;

namespace EFEM.RT
{
    /// <summary>
    /// Communication establish is not completed
    /// </summary>
    public class InitNoReadyPolicy : CheckImp, IPolicy
    {
        public InitNoReadyPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            var isReady = Singleton<EfemEntity>.Instance.IsCommunicationOk;
            if (!isReady)
            {
                reason =  "NOREADY";
                return false;
            }
            return true;
        }
    }
    
    /// <summary>
    /// Communication establish is not completed
    /// </summary>
    public class NoReadyPolicy : CheckImp, IPolicy
    {
        public NoReadyPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            
            //var isReady = DATA.Poll("Efem.IsCommunicationReady");
            var isReady = Singleton<EfemEntity>.Instance.IsCommunicationOk;
            if (!isReady)
            {
                reason =  "NOREADY";
                return false;
            }
            return true;
        }
    }
    /// <summary>
    /// NOINITCMPL No Initialize Completed - EFEM is not initialized.
    /// </summary>
    public class NoInitCompletedPolicy : CheckImp, IPolicy
    {
        public NoInitCompletedPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (device == DeviceName.SignalTower)
            {
                return true;
            }
            var entity = GetEntity(device);
            if (entity == null)
            {
                 return true;
            }
            if (!entity.Initialized)
            {
                reason = "NOINITCMPL";
                return false;
            }
            return true;
        }
    }
    /// <summary>
    /// NOORGCMPL No Origin Search Completed - Robot origin search is not performed.
    /// </summary>
    public class NoOriginCompletedPolicy : CheckImp, IPolicy
    {
        public NoOriginCompletedPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            IServerModule entity = GetEntity(device);
            if (entity == null)
            {
                return true;
            }
            if (!entity.OriginSearched)
            {
                reason = "NOORGCMPL";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// Insufficient vacuum source pressure
    /// </summary>
    public class VacPolicy : CheckImp, IPolicy
    {
        public VacPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            //if (!DeviceModel.SensorVACPressureSW.Value)
            //{
            //    reason = "VAC";
            //    return false;
            //}
            return true;
        }
    }


    /// <summary>
    /// AIR Insufficient air source pressure
    /// </summary>
    public class AirPolicy : CheckImp, IPolicy
    {
        public AirPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (device == DeviceName.SignalTower)
            {
                return true;
            }
            if (!Enum.TryParse(device, out ModuleName moduleName))
            {
                reason = PARAM_NG;
                return false;
            }

            if (ModuleHelper.IsLoadPort(moduleName))
            {
                var sensor = DEVICE.GetDevice<IoSensor>("SensorAirPressureErrorForLoadport");
                if (sensor == null || sensor.Value)
                {
                    return true;
                }
                reason = "AIR";
                return false;
            }

            if (moduleName == ModuleName.Robot || moduleName == ModuleName.System)
            {
                var sensor = DEVICE.GetDevice<IoSensor>("SensorAirPressureErrorForRobot");
                if (sensor == null || sensor.Value)
                {
                    return true;
                }
                reason = "AIR";
                return false;
            }

            reason = "";
            return true;
            
        }
    }

    /// <summary>
    /// EMS Stop made by EMS message
    /// </summary>
    public class EMSPolicy : CheckImp, IPolicy
    {
        public EMSPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (Singleton<RouteManager>.Instance.IsEMSStop)
            {
                reason = "EMS";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// ERROR Error stop
    /// </summary>
    public class ErrorPolicy : CheckImp, IPolicy
    {
        public ErrorPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;

            //if (device == "Robot")
            //{
            //    IServerModule entity = GetEntity(device);

            //    if ((!DeviceModel.SensorRobotError.Value) || entity.Error)
            //    {
            //        reason = "ERROR";
            //        return false;
            //    }

            //}
            if (ModuleHelper.IsLoadPort((ModuleName)Enum.Parse(typeof(ModuleName),device)))
            {
                IServerModule entity = GetEntity(device);

                if (entity.Error)
                {
                    reason = "ERROR";
                    return false;
                }

            }
            if (Singleton<RouteManager>.Instance.IsError)
            {
                reason = "ERROR";
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// BUSY Busy (Transfer system is in use)
    /// </summary>
    public class BusyPolicy : CheckImp, IPolicy
    {
        public BusyPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (device == DeviceName.SignalTower)
            {
                return true;
            }
            IServerModule entity = GetEntity(device);
            if (entity.Busy || entity.InUsed)
            {
                if(entity.Busy)
                    LOG.Write($"BusyPolicy {device} is Busy");

                if (entity.InUsed)
                    LOG.Write($"BusyPolicy {device} is InUsed");
                reason = "BUSY";
                return false;
            }
            return true;
        }
    }

    public class InitBusyPolicy : CheckImp, IPolicy
    {
        public InitBusyPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (device == DeviceName.SignalTower)
            {
                return true;
            }
            IServerModule entity = GetEntity(device);
            if (entity is RobotServerModule)
            {
                if ((entity.Busy || entity.InUsed) && (!entity.Error)  )
                {
                    if (entity.Busy  )
                    {
                        LOG.Write($"BusyPolicy {device} is Busy");
                    }

                    if (entity.InUsed)
                    {
                        LOG.Write($"BusyPolicy {device} is InUsed");
                    }
                    reason = "BUSY";
                    return false;
                }
            }
            else if (entity.Busy || entity.InUsed)
            {
                if (entity.Busy)
                    LOG.Write($"BusyPolicy {device} is Busy");

                if (entity.InUsed)
                    LOG.Write($"BusyPolicy {device} is InUsed");
                reason = "BUSY";
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// NOLINK    Communication with unit is not established
    /// </summary>
    public class LinkPolicy : CheckImp, IPolicy
    {
        public LinkPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (device == DeviceName.SignalTower)
            {
                return true;
            }
            IServerModule entity = GetEntity(device);
            if (!entity.IsLinkOk)
            {
                reason = "NOLINK";
                return false;
            }
            return true;
        }
    }
    /// <summary>
    /// REMOVE Port is not available
    /// </summary>
    public class RemovePolicy : CheckImp, IPolicy
    {
        public RemovePolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (device == DeviceName.SignalTower)
            {
                return true;
            }
            if (ModuleHelper.IsLoadPort((ModuleName)Enum.Parse(typeof(ModuleName),device)))
            {
                string pattern = "[1-9]\\d*";
                Regex rgx = new Regex(pattern);
                var match = int.Parse(rgx.Match(device).ToString());
                if (match > LoadPortQuantity)
                {
                    reason = "REMOVE";
                    return false;
                }
            }
            IServerModule entity = GetEntity(device);
            if (entity == null||entity.Disabled)
            {
                reason = "REMOVE";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// CMPL    Operation made by message is completed
    /// </summary>
    public class CMPLPolicy : CheckImp, IPolicy
    {
        public CMPLPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            IServerModule entity = GetEntity(device);
            if (!entity.Busy)
            {
                reason = "CMPL";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// CLOSE Pod is closed
    /// </summary>    
    public class ClosePolicy : CheckImp, IPolicy
    {
        public ClosePolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;

            if (ModuleHelper.IsLoadPort(ModuleHelper.Converter(device)))
            {
                LoadPortBaseDevice _device = DEVICE.GetDevice<LoadPortBaseDevice>(device);
                if (_device.DockState == FoupDockState.Undocked)
                {
                    reason = "CLOSE";
                    return false;
                }
            }
                
            return true;
        }
    }
   
    /// <summary>
    /// CLOSE Pod is closed
    /// </summary>    
    public class DisablePolicy : CheckImp, IPolicy
    {
        public DisablePolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;

            if (SC.ContainsItem($"System.{device}Disable"))
            {
                if (SC.GetValue<bool>($"System.{device}Disable"))
                {
                    reason = "Disable";
                    return false;
                }
            }

            return true;
        }
    }

    /// <summary>
    /// NOMAPCMPL Wafer mapping is not completed
    /// </summary>    
    public class NoWaferMappingCompletedPolicy : CheckImp, IPolicy
    {
        public NoWaferMappingCompletedPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;

            if (ModuleHelper.IsLoadPort(ModuleHelper.Converter(device)))
            {
                LoadPortBaseDevice loadPort = DEVICE.GetDevice<LoadPortBaseDevice>(device);
                if (!loadPort.IsMapped)
                {
                    reason = "NOMAPCMPL";
                    return false;
                }
            }
            if (ModuleHelper.IsBuffer(ModuleHelper.Converter(device)))
            {
                var loadPort = DEVICE.GetDevice<BufferStation>(device);
                if (loadPort.IsNeedMap && !loadPort.IsMapped)
                {
                    reason = "NOMAPCMPL";
                    return false;
                }
            }

            return true;
        }
    }


    /// <summary>
    /// NONPOD No necessary pod
    /// </summary>    
    public class NoPodPolicy : CheckImp, IPolicy
    {
        public NoPodPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (device == DeviceName.SignalTower)
            {
                return true;
            }
            if(ModuleHelper.IsLoadPort(ModuleHelper.Converter(device)))
            {
                LoadPortBaseDevice lp = DEVICE.GetDevice<LoadPortBaseDevice>(device);

                //var openCassette = lp as OpenStageWithWaferSizeLoadPort;
                //if (openCassette!=null && openCassette.IsWaferProtrude)
                //{
                //    reason = "PROTRUTION";
                //    return false;
                //}
                // if (lp.CassetteState != LoadportCassetteState.Normal)
               //var Pod = device.Equals("LP1") ? DeviceModel.SensorSMIF1PODPRESENT.Value : DeviceModel.SensorSMIF2PODPRESENT.Value;
               if (!(lp.IsPresent && lp.IsPlacement))
                {
                    reason = "NONPOD";
                    return false;
                }
            }
            
            return true;
        }
    }

    /// <summary>
    /// POD    Unnecessary pod has already existed
    /// </summary>    
    public class PodPolicy : CheckImp, IPolicy
    {
        public PodPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;

            if (ModuleHelper.IsLoadPort(ModuleHelper.Converter(device)))
            {
                //LoadPort _device = DEVICE.GetDevice<LoadPort>(device);

                //if (_device.CassetteState == LoadportCassetteState.Normal)
                //{
                //    reason = "POD";
                //    return false;
                //}

                LoadPortBaseDevice lp = DEVICE.GetDevice<LoadPortBaseDevice>(device);
 
                if (lp.IsPlacement && lp.IsPresent)
                {
                    reason = "POD";
                    return false;
                }
            }
                
            return true;
        }
    }


    /// <summary>
    /// Not in motion
    /// </summary>    
    public class NoMovingPolicy : CheckImp, IPolicy
    {
        public NoMovingPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;

            IServerModule entity = GetEntity(device);
            if (!entity.Busy)
            {
                reason = "NOTINMOTION";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// HOLD Hold
    /// </summary>    
    public class HoldPolicy : CheckImp, IPolicy
    {
        public HoldPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            bool isHold = (bool)DATA.Poll(ModuleName.System.ToString(), ParamName.IsHold);
            if (isHold)
            {
                reason = "HOLD";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    ///NOHOLD Not being held ○
    /// </summary>    
    public class NoHoldPolicy : CheckImp, IPolicy
    {
        public NoHoldPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            bool isHold = (bool)DATA.Poll(ModuleName.System.ToString(), ParamName.IsHold);
            if (!isHold)
            {
                reason = "NOHOLD";
                return false;
            }
            return true;
        }
    }
    /// <summary>
    ///LLCLOSE LL door is closed
    /// </summary>    
    public class LLDoorClosedPolicy : CheckImp, IPolicy
    {
        public LLDoorClosedPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            //if (DeviceModel.SensorVaccumError.Value)
            {
                reason = "LLCLOSE";
                return false;
            }
            return true;
        }
    }


    /// <summary>
    ///LLNOEXTEND Finger cannot be inserted into LL
    /// </summary>    
    public class LLNoExtenedPolicy : CheckImp, IPolicy
    {
        public LLNoExtenedPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            //if (DeviceModel.SensorVaccumError.Value)
            {
                reason = "LLNOEXTEND";
                return false;
            }
            return true;
        }
    }


    /// <summary>
    ///MAINTENANCE Key switch is set to "Mainte"
    /// </summary>    
    public class MaintenancePolicy : CheckImp, IPolicy
    {
        public MaintenancePolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (Singleton<RouteManager>.Instance.IsMaintenanceMode || !Singleton<EfemEntity>.Instance.IsOnlineMode)
            {
                reason = "MAINTENANCE";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    ///ARMEXTEND Finger is being inserted in pod
    /// </summary>    
    public class ArmExtendPolicy : CheckImp, IPolicy
    {
        public ArmExtendPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            IServerModule entity = GetEntity(DeviceName.Robot);
            RobotBaseDevice robot = DEVICE.GetDevice<RobotBaseDevice>(DeviceName.Robot);
            if (entity.Busy && (robot.Blade1Target == ModuleHelper.Converter(device) || robot.Blade2Target == ModuleHelper.Converter(device)))
            {
                reason = "ARMEXTEND";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    ///DRPOWERDOWN Drive power error
    /// </summary>    
    public class PowerDownPolicy : CheckImp, IPolicy
    {
        public PowerDownPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (Singleton<RouteManager>.Instance.IsMaintenanceMode && !Singleton<RouteManager>.Instance.IsFFUOk)
            {
                reason = "DRPOWERDOWN";
                return false;
            }
            return true;
        }
    }

    /// <summary>
    ///NOPOS Inoperable position
    /// </summary>    
    public class NoPosPolicy : CheckImp, IPolicy
    {
        public NoPosPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            IServerModule entity = GetEntity(device);
            if (ModuleHelper.IsLoadLock((ModuleName)Enum.Parse(typeof(ModuleName),device)))
            {
                var loadPort = DEVICE.GetDevice<LoadPortBaseDevice>(ModuleName.LP1.ToString());
                if (loadPort.DoorState == FoupDoorState.Close && loadPort.ClampState == FoupClampState.Open)
                {
                    reason = "NOPOS";
                    return false;
                }
            }
            return true;
        }
    }
    /// <summary>
    ///NoFuncPolicy Inoperable position
    /// </summary>    
    public class NoFuncPolicy : CheckImp, IPolicy
    {
        public NoFuncPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (Singleton<RouteManager>.Instance.IsMaintenanceMode || !Singleton<EfemEntity>.Instance.IsOnlineMode)//?
            {
                reason = "NOFUNC";
                return false;
            }
            return true;
        }
    }
 
}