using System;
using Aitex.Core.Common;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Sorter.RT.EFEMs.Servers;
using MECF.Framework.Common.Equipment;


namespace Aitex.Sorter.RT.EFEMs.Tasks
{
    public class RobotImp : CheckImp
    {
        public RobotImp()
        {
        }

        public bool ParseMoveTarget(string args, out ModuleName target, out int slot)
        {
            target = ModuleName.System;
            slot = 1;
            if (args.StartsWith("ALIGN") )
            {
                if (AlignerInstalled)
                {
                    target = ModuleName.Aligner;
                    slot = 1;
                    return true;
                }
                else if(CoolingBufferInstalled)
                {
                    if(args.Equals("ALIGN2"))
                    {
                        target = ModuleName.CoolingBuffer2;
                        slot = 1;
                        return true;
                    }
                    else if (args.Equals("ALIGN"))
                    {
                        target = ModuleName.CoolingBuffer1;
                        slot = 1;
                        return true;
                    }

                }
      
            }
            else if (args.StartsWith("P1") && LoadPortQuantity > 0 )
            {
                target = ModuleName.LP1;
                if (int.TryParse(args.Replace("P1", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P2") && LoadPortQuantity > 1)
            {
                target = ModuleName.LP2;
                if (int.TryParse(args.Replace("P2", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P3") && LoadPortQuantity > 2)
            {
                target = ModuleName.LP3;
                if (int.TryParse(args.Replace("P3", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P4") && LoadPortQuantity > 3)
            {
                target = ModuleName.LP4;
                if (int.TryParse(args.Replace("P4", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P5") && LoadPortQuantity > 4)
            {
                target = ModuleName.LP5;
                if (int.TryParse(args.Replace("P5", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P6") && LoadPortQuantity > 5)
            {
                target = ModuleName.LP6;
                if (int.TryParse(args.Replace("P6", ""), out slot))
                {
                    return true;
                }
            }
            else if ((args.StartsWith("LLA") || args.StartsWith("LLLA")) && LoadLockQuantity > 0)
            {
                target = ModuleName.LL1;
                string temp = args.Replace("LLA", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;

                    
                    return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemLLParameter(target, slot, out target,
                        out slot); 
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemLLParameter(target, slot, out target,
                            out slot); 
                }
            }
            else if ((args.StartsWith("LLB") || args.StartsWith("LLLB")) && LoadLockQuantity > 1)
            {
                target = ModuleName.LL2;
                string temp = args.Replace("LLB", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemLLParameter(target, slot, out target,
                        out slot);
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemLLParameter(target, slot, out target,
                            out slot);
                }
            }
            else if ((args.StartsWith("LLC") || args.StartsWith("LLLC")) && LoadLockQuantity >2)
            {
                target = ModuleName.LL3;
                string temp = args.Replace("LLC", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if ((args.StartsWith("LLD") || args.StartsWith("LLLD")) && LoadLockQuantity > 3)
            {
                target = ModuleName.LL4;
                string temp = args.Replace("LLD", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if (args.StartsWith("LLE") && LoadLockQuantity > 4)
            {
                target = ModuleName.LL5;
                string temp = args.Replace("LLE", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if (args.StartsWith("LLF") && LoadLockQuantity > 5)
            {
                target = ModuleName.LL6;
                string temp = args.Replace("LLF", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if (args.StartsWith("LLG") && LoadLockQuantity > 6)
            {
                target = ModuleName.LL7;
                string temp = args.Replace("LLG", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if (args.StartsWith("LLH") && LoadLockQuantity > 7)
            {
                target = ModuleName.LL8;
                string temp = args.Replace("LLH", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if (args.StartsWith("BF1"))
            {
                target = ModuleName.Buffer1;
                string temp = args.Replace("BF1", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemBufferParameter(target, slot, out target,
                        out slot);
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemBufferParameter(target, slot, out target,
                        out slot);
                }
            }
            else if (args.StartsWith("BF2"))
            {
                target = ModuleName.Buffer2;
                string temp = args.Replace("BF2", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemBufferParameter(target, slot, out target,
                        out slot);
                }
            }
            else if (args.StartsWith("BF3"))
            {
                target = ModuleName.Buffer3;
                string temp = args.Replace("BF3", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemBufferParameter(target, slot, out target,
                        out slot);
                }
            }
            else if (args.StartsWith("BF4"))
            {
                target = ModuleName.Buffer4;
                string temp = args.Replace("BF4", "");
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return Singleton<EfemEntity>.Instance.EfemDevice.ConverterEfemBufferParameter(target, slot, out target,
                        out slot);
                }
            }
            return false;
        }

        public bool ParseMoveArm(string args, out Hand arm)
        {
            arm = Hand.Blade1;

            //EFEM require arm1 as upper arm, arm2 as lower arm
            switch (args)
            {
                case "ARM1": arm =  Hand.Blade2;
                    break;
                case "ARM2": arm = Hand.Blade1;
                    break;
                case "ARM3": arm = Hand.Both;
                    break;

                default:
                    return false;
            }

            if (RobotIsSingleArm && arm != Hand.Blade1)
                return false;

            return true;
        }



        public bool ParseMovePosition(string args, out MovePosition pos)
        {
            if(Enum.TryParse(args, out pos))
            {
                return true;    
            }
            return false;
        }


        public bool ParseWaferSize(string args, out WaferSize size)
        {
            if (Enum.TryParse<WaferSize>(args, out size))
            {
                return true;
            }
            return false;
        }
    }
}