using System;
using Aitex.Core.RT.Device;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Sorter.RT.EFEMs.Servers.ABS;

namespace Aitex.Sorter.RT.EFEMs.Servers
{
    [Flags]
    public enum ErrorCheckList1
    {
        VAC      = 0x0001,
        AIR      = 0x0002,
        STALL    = 0x0004,
        TIMEOUT  = 0x0008,

        LIMIT    = 0x0010,
        SENSOR   = 0x0020,
        POSITION = 0x0040,
        EMS      = 0x0080,

        COMM     = 0x0100,
        COMM2    = 0x0200,
        VACON    = 0x0400,
        VACOFF   = 0x0800,

        CLAMPON  = 0x1000,
        CLAMPOF  = 0x2000,

    };

    [Flags]
    public enum ErrorCheckList2
    {
        RRTWAF   = 0x0001,
        CRSWAF   = 0x0002,
        THICKWAF = 0x0004,
        THINWAF  = 0x0008,

        DBLWAF  = 0x0010,
        BAOWAF  = 0x0020,
        COMMAND = 0x0040,
        PODNG   = 0x0080,            //Pod abnormal load error

        PODMISMATCH = 0x0100,       //Pod type mismatch
        VAC_S       = 0x0200,       //Chucking sensor abnormal
        CLAMP_S     = 0x0400,       //Clamp sensor abnormal 
        SAFTY       = 0x0800,       //Hand/finger pinch sensor reaction

        LOCKNG = 0x1000,            //FOUP lock disabled
        UNLOCKNG = 0x2000,          //FOUP unlock disabled
        L_KEY_LK = 0x4000,          //Latch key lock failure 
        L_KEY_UL = 0x8000,          //Latch key unlock failure 
    };

    [Flags]
    public enum ErrorCheckList3
    {
        MAP_S       = 0x0001,            //Mapping sensor abnormal
        MAP_S1      = 0x0002,            //Mapping sensor preparation disabled
        MAP_S2      = 0x0004,            //Mapping sensor containing disabled
        WAFLOST     = 0x0008,            //Wafer fall Disabled

        ALIGNNG     = 0x0010,           //Alignment failure 
        DRIVER      = 0x0020,            //Driver abnormal
        DRPOWERDOWN = 0x0040,            //Drive power off
        HARDWARE    = 0x0080,          //Hardware failure 

        INTERNAL     = 0x0100,          // Internal error 
        E84_TIMEOUTx = 0x0200,          //E84 timeout
        E84_CS_VALID = 0x0400,          //E84_CS_VALID  E84CS_0, CS_1, VALIDerror
        READFAIL     = 0x0800,      //Reading error 
        PODNG = 0x1000,
        PODMISMATCH = 0x2000,
        VAC_S = 0x4000,
        CLAMP_S = 0x8000,
    };



    public interface IPolicy
    {
        bool Check(string device, out string reason);
    }

    public class CheckImp
    {
        protected ErrorCheckList1 flag1 = 0;
        protected ErrorCheckList2 flag2 = 0;
        protected ErrorCheckList3 flag3 = 0;

        protected int LoadPortQuantity = DeviceDefineManager.Instance.GetValue<int>("LoadPortQuantity") ?? 0;
        
        protected int LoadLockQuantity = DeviceDefineManager.Instance.GetValue<int>("LoadLockQuantity") ?? 0;

        protected bool AlignerInstalled = DeviceDefineManager.Instance.GetValue<bool>("AlignerInstalled") ?? false;
        protected bool CoolingBufferInstalled = DeviceDefineManager.Instance.GetValue<bool>("CoolingBufferInstalled") ?? false;


        protected bool RobotIsSingleArm = DeviceDefineManager.Instance.GetValue<bool>("RobotIsSingleArm") ?? false;



        public const string PARAM_NG = "PARAM_NG";

        protected int _token;

        public bool HasInfoMessage { get; set; }

        public CheckImp()
        {
            HasInfoMessage = true;
        }

        public bool CheckError(string device, out string reason)
        {
            reason = "UNDEFINITION";

            #region Check flag1
            if (flag1.HasFlag(ErrorCheckList1.VAC))
            {
                if (!Check<Aitex.Sorter.RT.EFEMs.Servers.VacPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.AIR))
            {
                if (!Check<Aitex.Sorter.RT.EFEMs.Servers.AirPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.STALL))
            {
                if (!Check<StallPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag1.HasFlag(ErrorCheckList1.LIMIT))
            {
                if (!Check<LIMITPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.SENSOR))
            {
                if (!Check<SENSORPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.POSITION))
            {
                if (!Check<POSITIONPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.EMS))
            {
                if (!Check<Aitex.Sorter.RT.EFEMs.Servers.EMSPolicy>(device, out reason))
                {
                    return false;
                }
            }
            
            if (flag1.HasFlag(ErrorCheckList1.COMM))
            {
                if (!Check<COMMPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.COMM2))
            {
                if (!Check<COMM2Policy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.VACON))
            {
                if (!Check<VACONPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.VACOFF))
            {
                if (!Check<VACOFPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag1.HasFlag(ErrorCheckList1.CLAMPON))
            {
                if (!Check<CLAMPONPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.CLAMPOF))
            {
                if (!Check<CLAMPOFPolicy>(device, out reason))
                {
                    return false;
                }
            }

            #endregion

            #region Check flag2
            if (flag2.HasFlag(ErrorCheckList2.RRTWAF))
            {
                if (!Check<PRTWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.CRSWAF))
            {
                if (!Check<CRSWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.THICKWAF))
            {
                if (!Check<THICKWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.THINWAF))
            {
                if (!Check<THINWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag2.HasFlag(ErrorCheckList2.DBLWAF))
            {
                if (!Check<DBLWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.BAOWAF))
            {
                if (!Check<BOWWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.COMMAND))
            {
                if (!Check<COMMANDPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.PODNG))
            {
                if (!Check<PODNGPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag2.HasFlag(ErrorCheckList2.PODMISMATCH))
            {
                if (!Check<PODMISMATCHPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.VAC_S))
            {
                if (!Check<VAC_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.CLAMP_S))
            {
                if (!Check<CLAMP_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.SAFTY))
            {
                if (!Check<SAFTYPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag2.HasFlag(ErrorCheckList2.LOCKNG))
            {
                if (!Check<LOCKNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.UNLOCKNG))
            {
                if (!Check<UNLOCKNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.L_KEY_LK))
            {
                if (!Check<L_KEY_LKPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.L_KEY_UL))
            {
                if (!Check<L_KEY_ULPolicy>(device, out reason))
                {
                    return false;
                }
            }
            #endregion

            #region Check flag3
            if (flag3.HasFlag(ErrorCheckList3.MAP_S))
            {
                if (!Check<MAP_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.MAP_S1))
            {
                if (!Check<MAP_S1Policy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.MAP_S2))
            {
                if (!Check<MAP_S2Policy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.WAFLOST))
            {
                if (!Check<WAFLOSTPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag3.HasFlag(ErrorCheckList3.ALIGNNG))
            {
                if (!Check<ALIGNNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.PODNG))
            {
                if (!Check<PODNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.PODMISMATCH))
            {
                if (!Check<PODMISMATCHPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.VAC_S))
            {
                if (!Check<VAC_SPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag3.HasFlag(ErrorCheckList3.CLAMP_S))
            {
                if (!Check<CLAMP_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.DRIVER))
            {
                if (!Check<DRIVERPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.DRPOWERDOWN))
            {
                if (!Check<DRPOWERDOWNPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.HARDWARE))
            {
                if (!Check<HARDWAREPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag3.HasFlag(ErrorCheckList3.INTERNAL))
            {
                if (!Check<INTERNALPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.E84_TIMEOUTx))
            {
                if (!Check<E84_TIMEOUTxPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.E84_CS_VALID))
            {
                if (!Check<E84_CS_VALIDPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.READFAIL))
            {
                if (!Check<READFAILPolicy>(device, out reason))
                {
                    return false;
                }
            }
            #endregion

            return false;
        }

        public bool Check<T>(string device, out string reason) where T : class, IPolicy, new()
        {
            reason = string.Empty;
            
            return Singleton<T>.Instance.Check(device, out reason);
        }

        protected string Args2Unit(string args)
        {
            string unit = string.Empty;
            if (string.IsNullOrEmpty(args) || args.StartsWith("ALL") || args.StartsWith("SYSTEM"))
            {
                unit = DeviceName.System;
            }
            else if (args.StartsWith("ROB"))
            {
                unit = DeviceName.Robot;
            }
            else if (args.StartsWith("ALIGN"))
            {
                if (this.AlignerInstalled)
                    unit = DeviceName.Aligner;
                else if (this.CoolingBufferInstalled)
                {
                    if (args.EndsWith("ALIGN"))
                    {
                        unit = DeviceName.CoolingBuffer1;
                    }
                    else if (args.EndsWith("ALIGN2"))
                    {
                        unit = DeviceName.CoolingBuffer2;
                    }
                }
            }
            else if (args.Equals("P1") && LoadPortQuantity > 0)
            {
                unit = DeviceName.LP1;

            }
            else if (args.Equals("P2") && LoadPortQuantity > 1)
            {
                unit = DeviceName.LP2;

            }
            else if (args.Equals("P3") && LoadPortQuantity > 2)
            {
                unit = DeviceName.LP3;

            }
            else if (args.Equals("P4") && LoadPortQuantity > 3)
            {
                unit = DeviceName.LP4;
            }
            else if (args.Equals("P5") && LoadPortQuantity > 4)
            {
                unit = DeviceName.LP5;
            }
            else if (args.Equals("P6") && LoadPortQuantity > 5)
            {
                unit = DeviceName.LP6;
            }
            else if (args.Equals("P7") && LoadPortQuantity > 6)
            {
                unit = DeviceName.LP7;
            }
            else if (args.Equals("P8") && LoadPortQuantity > 7)
            {
                unit = DeviceName.LP8;
            }
            else if (args.Equals("P9") && LoadPortQuantity > 8)
            {
                unit = DeviceName.LP9;
            }
            else if (args.Equals("P10") && LoadPortQuantity > 9)
            {
                unit = DeviceName.LP10;
            }
            else if ( (args.Equals("LLA") || args.StartsWith("LLLA")) && LoadLockQuantity >0)
            {
                unit = DeviceName.LoadlockA;
            }
            else if ((args.Equals("LLB") || args.StartsWith("LLLB")) && LoadLockQuantity > 1)
            {
                unit = DeviceName.LoadlockB;
            }
            else if (args.Equals("LLC") && LoadLockQuantity > 2)
            {
                unit = DeviceName.LoadlockC;
            }
            else if (args.Equals("LLD") && LoadLockQuantity > 3)
            {
                unit = DeviceName.LoadlockD;
            }
            else if (args.Equals("STOWER"))
            {
                unit = DeviceName.SignalTower;
            }
            else if (args.Equals("SHORN"))
            {
                unit = DeviceName.SignalHorn;
            }
            else if (args.Equals("BF1"))
            {
                unit = DeviceName.Buffer1;
            }
            else if (args.Equals("BF2"))
            {
                unit = DeviceName.Buffer2;
            }
            else if (args.Equals("BF3"))
            {
                unit = DeviceName.Buffer3;
            }
            else if (args.Equals("BF4"))
            {
                unit = DeviceName.Buffer4;
            }
            return unit;
        }

        protected bool CheckIsPort(string device)
        {
            return device==DeviceName.LP1 || device == DeviceName.LP2 || device == DeviceName.LP3 || device == DeviceName.LP4;
        }

        protected bool CheckIsTower(string device)
        {
            return  device == DeviceName.SignalTower;
        }

        protected bool CheckIsShorn(string device)
        {
            return device == DeviceName.SignalHorn;
        }
        protected IServerModule GetEntity(string name)
        {
            return Singleton<EfemServerModule>.Instance.GetModule(name);
        }
    }



}