using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.Equipment
{
    /// <summary>
    /// 在框架中，Module指具备放置Wafer的单元
    /// </summary>
    [DataContract]
    [Serializable]
    public enum ModuleName
    {
        [EnumMember]
        System = 0,

        [EnumMember]
        LP1,

        [EnumMember]
        LP2,

        [EnumMember]
        LP3,

        [EnumMember]
        LP4,

        [EnumMember]
        LP5,

        [EnumMember]
        LP6,

        [EnumMember]
        LP7,

        [EnumMember]
        LP8,

        [EnumMember]
        LP9,

        [EnumMember]
        LP10,

        //robot modules
        //[EnumMember]
        //Robot,

        [EnumMember]
        VaccumRobot,

        [EnumMember]
        LoadRobot,

        [EnumMember]
        EfemRobot,

        //[EnumMember]
        //TMRobot,

        //upenders
        [EnumMember]
        Upender,

        //efem
        [EnumMember]
        EFEM,

        //aligners
        [EnumMember]
        Aligner,

        [EnumMember]
        Aligner1,

        [EnumMember]
        Aligner2,

        //load locks
        [EnumMember]
        LL1,

        [EnumMember]
        LL2,

        [EnumMember]
        LL3,

        [EnumMember]
        LL4,


        //load locks
        [EnumMember]
        LLA,

        [EnumMember]
        LLB,

        [EnumMember]
        LLC,

        [EnumMember]
        LLD,

        [EnumMember]
        VCE1,

        [EnumMember]
        VCE2,

        //transfer modules
        [EnumMember]
        TM,

        //buffers
        [EnumMember]
        Buffer,

        [EnumMember]
        Cooling1,

        [EnumMember]
        Cooling2,

        //[EnumMember]
        //Buffer1,

        //[EnumMember]
        //Buffer2,

        [EnumMember]
        Buffer3,

        //PMs
        [EnumMember]
        PM1,

        [EnumMember]
        PM2,

        [EnumMember]
        PM3,

        [EnumMember]
        PM4,

        [EnumMember]
        PM5,

        [EnumMember]
        PM6,

        [EnumMember]
        PM7,

        [EnumMember]
        PM8,
 
        [EnumMember]
        Robot,
 
        [EnumMember]
        PMA,

        [EnumMember]
        PMB,
    }

    public static class ModuleHelper
    {
        public static bool IsBuffer(ModuleName unit)
        {
            return false;

        }
        public static bool IsLoadPort(ModuleName unit)
        {
            return unit == ModuleName.LP1
                   || unit == ModuleName.LP2
                   || unit == ModuleName.LP3
                   || unit == ModuleName.LP4
                   || unit == ModuleName.LP5
                   || unit == ModuleName.LP6
                   || unit == ModuleName.LP7
                   || unit == ModuleName.LP8
                   || unit == ModuleName.LP9
                   || unit == ModuleName.LP10;
        }
 
        public static bool IsPm(string unit)
        {
            return IsPm(ModuleHelper.Converter(unit));
        }
        public static bool IsPm(ModuleName unit)
        {
            return unit == ModuleName.PM1
                   || unit == ModuleName.PM2
                   || unit == ModuleName.PM3
                   || unit == ModuleName.PM4
                   || unit == ModuleName.PM5
                   || unit == ModuleName.PM6
                   || unit == ModuleName.PM7
                   || unit == ModuleName.PM8
                   || unit == ModuleName.PMA
                   || unit == ModuleName.PMB;
        }
 
        public static bool IsLoadLock(string unit)
        {
            return IsLoadLock(ModuleHelper.Converter(unit));
        }

        public static bool IsAligner(ModuleName unit)
        {
            return unit == ModuleName.Aligner || unit == ModuleName.Aligner1 || unit == ModuleName.Aligner2  ;
        }

        public static bool IsCooling(ModuleName unit)
        {
            return  unit == ModuleName.Cooling1 || unit == ModuleName.Cooling2;
        }

        public static bool IsLoadLock(ModuleName unit)
        {
            return unit == ModuleName.LLA
                   || unit == ModuleName.LLB
                   || unit == ModuleName.LL1
                   || unit == ModuleName.LL2
                   || unit == ModuleName.LL3
                   || unit == ModuleName.LL4
                   || unit == ModuleName.LLC
                   || unit == ModuleName.LLD;
        }
        public static string GetAbbr(ModuleName module)
        {
            switch (module)
            {
                case ModuleName.Aligner: return "PA";
                case ModuleName.Robot: return "RB";
                default: return module.ToString();
            }
        }

        public static ModuleName Converter(string module)
        {
            return (ModuleName) Enum.Parse(typeof(ModuleName), module);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index">0 based</param>
        /// <returns></returns>
        public static ModuleName GetLoadPort(int index)
        {
            ModuleName[] lps = new ModuleName[]
            {
                ModuleName.LP1, ModuleName.LP2, ModuleName.LP3, ModuleName.LP4, ModuleName.LP5,
                ModuleName.LP6, ModuleName.LP7, ModuleName.LP8, ModuleName.LP9, ModuleName.LP10,
            };
            return lps[index];
        }
    }

    public class ModuleNameString
    {
        public const string System = "System";

        public const string LDULD = "LDULD";
        public const string BufferOut = "BufferOut";
        public const string BufferIn = "BufferIn";
        public const string Dryer = "Dryer";
        public const string QDR = "QDR";
        public const string Robot = "Robot";
        public const string Handler = "Handler";

        public static ModuleName ToEnum(string value)
        {
            return (ModuleName)Enum.Parse(typeof(ModuleName), value, true);

        }
    }

}