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;
using MECF.Framework.Common.ToolLayout;

namespace MECF.Framework.Common.Equipment
{
    /// <summary>
    /// 在框架中，Module指具备放置Wafer的单元
    /// </summary>
    [DataContract]
    [Serializable]
    public enum ModuleName
    {
        [EnumMember]
        Unknown=9999,
        [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,
        [EnumMember]
        Robot,
 
        [EnumMember]
        PMA,

        [EnumMember]
        PMB, 

        [EnumMember]
        PMC,

        [EnumMember]
        PMD,

        [EnumMember]
        PME,

        [EnumMember]
        PMF,

        [EnumMember]
        VPA,
        [EnumMember]
        SRD1,
        [EnumMember]
        SRD2,
        [EnumMember]
        PUF1,
        [EnumMember]
        PUF2,
        [EnumMember]
        Dummy1,
        [EnumMember]
        Dummy2,
        [EnumMember]
        Loader1,
        [EnumMember]
        Dryer1,
        [EnumMember]
        Dryer2,
        [EnumMember]
        Dryer3,
        [EnumMember]
        Prewet1,
        [EnumMember]
        Rinse1,
        [EnumMember]
        Rinse2,
        [EnumMember]
        Rinse3,
        [EnumMember]
        Rinse4,
        [EnumMember]
        Rinse5,
        [EnumMember]
        Rinse6,
        [EnumMember]
        Metal1,
        [EnumMember]
        Metal2,
        [EnumMember]
        Metal3,
        [EnumMember]
        Metal4,
        [EnumMember]
        Metal5,
        [EnumMember]
        Metal6,
        [EnumMember]
        Metal7,
        [EnumMember]
        Metal8,
        [EnumMember]
        Metal9,
        [EnumMember]
        Metal10,
        [EnumMember]
        Metal11,
        [EnumMember]
        Metal12,
        [EnumMember]
        Metal13,
        [EnumMember]
        Metal14,
        [EnumMember]
        Metal15,
        [EnumMember]
        Metal16,
        [EnumMember]
        Linmot,
        [EnumMember]
        Transporter1,
        [EnumMember]
        Transporter2,
        [EnumMember]
        Buffer1,
        [EnumMember]
        Buffer2,
        [EnumMember]
        Buffer3,
        [EnumMember]
        Buffer4,
        [EnumMember]
        Buffer5,
        [EnumMember]
        Buffer6,
        [EnumMember]
        Buffer7,
        [EnumMember]
        Buffer8,
        [EnumMember]
        Buffer9,
        [EnumMember]
        Buffer10,
        [EnumMember]
        Buffer11,
        [EnumMember]
        Buffer12,
        [EnumMember]
        Buffer13,
        [EnumMember]
        Buffer14,
        [EnumMember]
        Buffer15,
        [EnumMember]
        Buffer16,
        [EnumMember]
        Buffer17,
        [EnumMember]
        Buffer18,
        [EnumMember]
        Buffer19,
        [EnumMember]
        Buffer20,
        [EnumMember]
        Reservoir1,
        [EnumMember]
        Reservoir2,
        [EnumMember]
        Reservoir3,
        [EnumMember]
        Reservoir4,
        [EnumMember]
        Reservoir5
    }

    /// <summary>
    /// 模块类型
    /// </summary>
    public enum ModuleType
    {
        None,
        LoadPort,
        EfemRobot,
        Aligner,
        SRD,
        PUF,
        Loader,
        Buffer,
        Dryer,
        Rinse,
        Prewet,
        Metal,
        Dummy,
        Transporter,
        Reservoir
    }
    public static class ModuleHelper
    {
        public static bool IsPrewet(ModuleName unit)
        {
            return unit == ModuleName.Prewet1;
        }
        public static bool IsSRD(ModuleName unit)
        {
            return unit == ModuleName.SRD1 || unit == ModuleName.SRD2;
        }
        public static bool IsPUF(ModuleName unit)
        {
            return unit == ModuleName.PUF1 || unit == ModuleName.PUF2;
        }

        public static bool IsMetal(ModuleName unit)
        {
            return (int)unit >= (int)ModuleName.Metal1 && (int)unit <= (int)ModuleName.Metal16;
        }
        public static bool IsDry(ModuleName unit)
        {
            return (int)unit >= (int)ModuleName.Dryer1 && (int)unit <= (int)ModuleName.Dryer3;
        }
        public static bool IsReservoir(ModuleName unit)
        {
            return (int)unit >= (int)ModuleName.Reservoir1 && (int)unit <= (int)ModuleName.Reservoir5;
        }
        public static bool IsRinse(ModuleName unit)
        {
            return (int)unit >= (int)ModuleName.Rinse1 && (int)unit <= (int)ModuleName.Rinse6;
        }
        public static bool IsBuffer(ModuleName unit)
        {
            return (int)unit>=(int)ModuleName.Buffer1&&(int)(unit)<=(int)ModuleName.Buffer19;

        }
        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 IsDummy(ModuleName unit)
        {
            return unit == ModuleName.Dummy1 || unit == ModuleName.Dummy2;
        }
        public static bool IsAligner(ModuleName unit)
        {
            return unit == ModuleName.Aligner || unit == ModuleName.Aligner1 || unit == ModuleName.Aligner2  ;
        }

        public static bool IsEFEMRobot(ModuleName unit)
        {
            return unit == ModuleName.EfemRobot;
        }

        public static bool IsVPA(ModuleName unit)
        {
            return unit == ModuleName.VPA;
        }
        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);
            return ToolLayoutConfigManager.Instance.IsInstalled(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);

        }
    }

}