using Aitex.Core.Util;

namespace Aitex.Sorter.RT.EFEMs.Servers.ABS
{

    /// <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 (Singleton<EfemEntity>.Instance.EfemDevice.CheckVacuumError())
            {
                reason = string.Format("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 (DeviceModel.SensorMainAirErrorForRobot.Value || DeviceModel.SensorMainAirErrorForLoadport.Value)
            //{
            //    reason = string.Format("AIR");
            //    return false;
            //}
            return true;
        }
    }

    /// <summary>
    /// Motor Stall - Controller detected motor stall.
    /// (1) If a wafer is on the finger or aligner, confirm that the wafer is not  misaligned.
    ///     If the wafer is misaligned, retrieve the wafer.
    /// (2) After(1) is confirmed, send "SET: ERROR/CLEAR;", "MOV:INIT;" and
    ///    "MOV:ORGSH;" messages to EFEM to recover.
    /// Note: If this error occurs again, maintenance for mechanical and electric
    /// sections is required.
    /// </summary>
    public class StallPolicy : CheckImp, IPolicy
    {
        public StallPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("STALL");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// LIMIT Limit error
    /// </summary>
    public class LIMITPolicy : CheckImp, IPolicy
    {
        public LIMITPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("LIMIT");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// SENSOR Sensor abnormal
    /// </summary>
    public class SENSORPolicy : CheckImp, IPolicy
    {
        public SENSORPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("SENSOR");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// POSITION Position error
    /// </summary>
    public class POSITIONPolicy : CheckImp, IPolicy
    {
        public POSITIONPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("POSITION");
                return false;
            }
            return true;
        }
    }



    /// <summary>
    /// Emergency stop
    /// </summary>
    public class EMSPolicy : CheckImp, IPolicy
    {
        public EMSPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("EMS");
                return false;
            }
            return true;
        }
    }



    /// <summary>
    ///  Controller Communication 
    ///  Error occurred in communication  between the controllers of the unit.
    /// </summary>
    public class COMMPolicy : CheckImp, IPolicy
    {
        public COMMPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("COMM");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// COMM2   Module Communication Error
    /// Error occurred in communication between modules.
    /// </summary>
    public class COMM2Policy : CheckImp, IPolicy
    {
        public COMM2Policy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("COMM2");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// VACON   Vacuum ON Error - Load port failed to perform chucking of  FOUP door when opening FOUP.
    /// </summary>
    public class VACONPolicy : CheckImp, IPolicy
    {
        public VACONPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("VACON");
                return false;
            }
            return true;
        }
    }

    
    /// <summary>
    ///VACOF   Vacuum OFF error - Vacuum solenoid valve at the load port failed.
    /// </summary>
    public class VACOFPolicy : CheckImp, IPolicy
    {
        public VACOFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("VACOF");
                return false;
            }
            return true;
        }
    }



    /// <summary>
    ///CLAMPON   Aligner Clamp On Error - Aligner failed clamping wafer when   placing wafer on the aligner.
    ///          Robot Clamp ON Error - Robot failed clamping wafer when picking up the wafer.   
    /// </summary>
    public class CLAMPONPolicy : CheckImp, IPolicy
    {
        public CLAMPONPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("CLAMPON");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    ///CLAMPOF
    ///Clamp Off Error - Clamp cylinder of the robot failed
    ///Clamp sensor of the robot failed
    ///Clamp cylinder of the aligner failed
    ///Clamp sensor of the aligner failed.
    /// </summary>
    public class CLAMPOFPolicy : CheckImp, IPolicy
    {
        public CLAMPOFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("CLAMPOF");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// PRTWAF  Found Wafer Protrude - Wafer protrusion is detected.
    /// </summary>
    public class PRTWAFPolicy : CheckImp, IPolicy
    {
        public PRTWAFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("PRTWAF");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// COMMAND
    /// Command Error - Command error occurred in the communication between controllers.
    /// </summary>
    public class COMMANDPolicy : CheckImp, IPolicy
    {
        public COMMANDPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("COMMAND");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// PODNG
    /// Pod No-Good Position - FOUP is not properly placed.
    /// </summary>
    public class PODNGPolicy : CheckImp, IPolicy
    {
        public PODNGPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("PODNG");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// PODMISMATCH
    /// Pod Type Mismatch - Carrier other than FOUP is place on the load port.
    /// No cover is on FOUP on the load port.
    /// </summary>
    public class PODMISMATCHPolicy : CheckImp, IPolicy
    {
        public PODMISMATCHPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("PODMISMATCH");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// VAC_S
    /// Vacuum Sensor Error - Chucking sensor on the load port shows  abnormality.
    /// </summary>
    public class VAC_SPolicy : CheckImp, IPolicy
    {
        public VAC_SPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("VAC_S");
                return false;
            }
            return true;
        }
    }



    /// <summary>
    /// CLAMP_S
    /// Clamp Sensor Error - Clamp sensor in the robot shows  abnormality.
    /// Clamp sensor in the aligner shows abnormality.
    /// </summary>
    public class CLAMP_SPolicy : CheckImp, IPolicy
    {
        public CLAMP_SPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("CLAMP_S");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// SAFTY
    /// Safety Sensor Active - Finger pinch detecting sensor is activated during load port operation.
    /// </summary>
    public class SAFTYPolicy : CheckImp, IPolicy
    {
        public SAFTYPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("SAFTY");
                return false;
            }
            return true;
        }
    }

    
    /// <summary>
    /// LOCKNG
    /// FOUP Lock Fail - FOUP clamp failure on the load port
    /// </summary>
    public class LOCKNGPolicy : CheckImp, IPolicy
    {
        public LOCKNGPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("LOCKNG");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// UNLOCKNG
    /// FOUP Unlock Fail - FOUP unclamp failure on the load port.
    /// </summary>
    public class UNLOCKNGPolicy : CheckImp, IPolicy
    {
        public UNLOCKNGPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("UNLOCKNG");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// L_KEY_LK
    /// Latch-Key Lock Fail - Latch key is not properly returned when FOUP is closed on the load port.
    /// </summary>
    public class L_KEY_LKPolicy : CheckImp, IPolicy
    {
        public L_KEY_LKPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("L_KEY_LK");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// L_KEY_UL
    /// Latch-Key Unlock Fail - Latch key is not properly turned when  FOUP is opened on the load port.
    /// </summary>
    public class L_KEY_ULPolicy : CheckImp, IPolicy
    {
        public L_KEY_ULPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("L_KEY_UL");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// MAP_S
    /// Mapping Sensor Error - Mapping sensor shows abnormality on    the load port.
    /// </summary>
    public class MAP_SPolicy : CheckImp, IPolicy
    {
        public MAP_SPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("MAP_S");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// MAP_S1
    /// Mapping Sensor Error1- Load port failed preparation for mapping  sensor.
    /// </summary>
    public class MAP_S1Policy : CheckImp, IPolicy
    {
        public MAP_S1Policy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("MAP_S1");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// MAP_S2
    /// Mapping Sensor Error2- Load port failed containing of mapping  sensor.
    /// </summary>
    public class MAP_S2Policy : CheckImp, IPolicy
    {
        public MAP_S2Policy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("MAP_S2");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// WAFLOST    Wafer Lost - Wafer presence on the robot finger is lost.
    /// Wafer presence on the aligner is lost.
    /// </summary>
    public class WAFLOSTPolicy : CheckImp, IPolicy
    {
        public WAFLOSTPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("WAFLOST");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    ///ALIGNNG   Alignment Fail - Wafer alignment failed.
    /// </summary>
    public class ALIGNNGPolicy : CheckImp, IPolicy
    {
        public ALIGNNGPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("ALIGNNG");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    ///DRIVER Driver Abnormal - Motor control driver shows abnormality.
    ///Driver abnormality is shown due to drive power failure while motor is operating.
    /// </summary>
    public class DRIVERPolicy : CheckImp, IPolicy
    {
        public DRIVERPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("DRIVER");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    ///DRPOWERDOWN
    ///Driver Power Down - Motion is stopped due to drive power failure.
    /// </summary>
    public class DRPOWERDOWNPolicy : CheckImp, IPolicy
    {
        public DRPOWERDOWNPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("DRPOWERDOWN");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    ///HARDWARE   Hardware Error - Hardware malfunction occurred on any  single unit.
    /// </summary>
    public class HARDWAREPolicy : CheckImp, IPolicy
    {
        public HARDWAREPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("HARDWARE");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// INTERNAL
    /// Internal Error - Internal error occurred at the section where each unit inside EFEM PC iscontrolled. 
    /// </summary>
    public class INTERNALPolicy : CheckImp, IPolicy
    {
        public INTERNALPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("INTERNAL");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// CRSWAF Found Cross Wafer- Cross wafer is detected during wafer mapping.
    /// </summary>
    public class CRSWAFPolicy : CheckImp, IPolicy
    {
        public CRSWAFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("CRSWAF");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    /// THICKWAF Found Thick Wafer- Thicker wafer than the standard is detected during wafer mappi
    /// </summary>
    public class THICKWAFPolicy : CheckImp, IPolicy
    {
        public THICKWAFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("THICKWAF");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// THINWAF Found Thin wafer- Thinner wafer than the standard isdetected during wafer mapping. 
    /// </summary>
    public class THINWAFPolicy : CheckImp, IPolicy
    {
        public THINWAFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("THINWAF");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// DBLWAF Found Double Wafer- Two or more wafers in one slot ar detected during wafer mapping.    /// 
    /// </summary>
    public class DBLWAFPolicy : CheckImp, IPolicy
    {
        public DBLWAFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("DBLWAF");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// BOWWAF Found Bow Wafer- Front bow wafer is detected during wafer mapping.   
    /// </summary>
    public class BOWWAFPolicy : CheckImp, IPolicy
    {
        public BOWWAFPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("BOWWAF");
                return false;
            }
            return true;
        }
    }

    /// <summary>
    /// E84_TIMEOUTx E84 Timeout- E84 automated transfer sequence timeout occurred.    /// 
    /// </summary>
    public class E84_TIMEOUTxPolicy : CheckImp, IPolicy
    {
        public E84_TIMEOUTxPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("E84_TIMEOUTx");
                return false;
            }
            return true;
        }
    }


    /// <summary>
    ///E84_CS_VALID E84 Signal Error
    /// CS_0,CS_1,VALID signals are changed while E84 automated transfer sequence is processing. 
    /// </summary>
    public class E84_CS_VALIDPolicy : CheckImp, IPolicy
    {
        public E84_CS_VALIDPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("E84_CS_VALID");
                return false;
            }
            return true;
        }
    }



    /// <summary>
    ///READFAIL ID Read Fail- ID reading failed
    /// </summary>
    public class READFAILPolicy : CheckImp, IPolicy
    {
        public READFAILPolicy()
        {
        }

        public bool Check(string device, out string reason)
        {
            reason = string.Empty;
            if (false)
            {
                reason = string.Format("READFAIL");
                return false;
            }
            return true;
        }
    }

}