using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Log;

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,

        // TM robot
        [EnumMember]
        TMRobot,

        //buffers
        [EnumMember]
        Buffer,

        [EnumMember]
        Cooling1,

        [EnumMember]
        Cooling2,

        //[EnumMember]
        //Buffer1,

        //[EnumMember]
        //Buffer2,

        [EnumMember]
        Buffer3,

        //PMs
        [EnumMember]
        PMA1,

        [EnumMember]
        PMA2,

        [EnumMember]
        PMB1,

        [EnumMember]
        PMB2,

        [EnumMember]
        PMC1,

        [EnumMember]
        PMC2,

        [EnumMember]
        PMD1,

        [EnumMember]
        PMD2,
 
        [EnumMember]
        Robot,
 
        [EnumMember]
        PMA,

        [EnumMember]
        PMB, 

        [EnumMember]
        PMC,

        [EnumMember]
        PMD,

        [EnumMember]
        PME,

        [EnumMember]
        PMF,
    }

    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.PMA1
                   || unit == ModuleName.PMA2
                   || unit == ModuleName.PMB1
                   || unit == ModuleName.PMB2
                   || unit == ModuleName.PMC1
                   || unit == ModuleName.PMC2
                   || unit == ModuleName.PMD1
                   || unit == ModuleName.PMD2
                   || unit == ModuleName.PMA
                   || unit == ModuleName.PMB
                   || unit == ModuleName.PMC
                   || unit == ModuleName.PMD
                   || unit == ModuleName.PME
                   || unit == ModuleName.PMF;
        }
 
        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 bool IsTM(ModuleName unit)
        {
            return unit == ModuleName.TM;
        }

        public static bool IsTMRobot(ModuleName unit)
        {
            return unit == ModuleName.TMRobot;
        }

        public static bool IsEFEMRobot(ModuleName unit)
        {
            return unit == ModuleName.EfemRobot;
        }
        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];
        }

        private static List<ModuleName> _lstModules = new List<ModuleName>();
        private static readonly object _lock = new object();
        public static bool IsInstalled(ModuleName module)
        {
            if (_lstModules.Count == 0)
            {
                LoadModules();
            }

            return _lstModules.Contains(module);
        }
        public static void LoadModules()
        {
            lock (_lock)
            {
                try
                {
                    string moduleString = SC.GetStringValue("System.InstalledModules");
                    var modules = moduleString.Split(',');
                    foreach (var mod in modules)
                    {
                        var module = Converter(mod.Trim());
                        _lstModules.Add(module);
                    }
                }

                catch (Exception e)
                {
                    LOG.WriteExeption("Loading intalled module error, please check the config item: System.InstalledModules", e);
                }

            }
        }
    }

    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);

        }
    }

}