using Aurora;
using Aurora.Api;
using Aurora.View;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace VisionCommon {
    public static class VisionRecipeManager {
        private static Logger _Logger = new Logger("VisionRecipeManager");

        #region SubSys/Fov Setup Recipe Enabled
        public static bool CalibrationEnabled { get; set; } = false;
        public static bool CenterTuningEnabled { get; set; } = false;
        public static bool AutoFocusEnabled { get; set; } = false;
        public static bool VisionRepeatEnabled { get; set; } = false;
        public static bool AttachInspEnabled { get; set; } = false;
        #endregion

        public static VisionRecipeDef CreateVisionRecipeDef() {
            return new VisionRecipeDef();
        }

        public static VisionModelDef CreateVisionModelDef() {
            return new VisionModelDef();
        }

        public static VisionIngredientDef CreateVisionIngredientDef() {
            return new VisionIngredientDef();
        }

        public static VisionDef GetVisionRecipeDef() {
            var visionSetting = VisionSettingManager.VisionSetting;
            if (visionSetting.RecipeModelType == eRecipeModelType.AuroraModel) {
                var currentModelName = VisionEnv.AuroraEnv.RecipeManager.ActivatedModelName();
                if (currentModelName != null && currentModelName != string.Empty) {
                    return VisionEnv.AuroraEnv.ModelManager.ModelItem(currentModelName, VisionKeys.VisionRecipeKey) as VisionModelDef;
                }
                return new VisionModelDef();
            }
            else if (visionSetting.RecipeModelType == eRecipeModelType.AuroraIngredient) {
                var vsIngredient = VisionEnv.AuroraEnv.IngredientsManager.Ingredient(VisionKeys.VisionRecipeKey);
                string activatedItemName = vsIngredient.ActivatedItemName();
                if (activatedItemName != null) {
                    return vsIngredient.IngredientItem(activatedItemName) as VisionIngredientDef;
                }
                return new VisionIngredientDef();
            }

            return VisionEnv.AuroraEnv.RecipeManager[VisionKeys.VisionRecipeKey] as VisionRecipeDef;
        }

        public static ObservableCollection<UnitRecipe> GetUnitRecipes() {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetUnitRecipes();
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static UnitRecipe GetUnitRecipe(UnitInfo unitInfo) {
            if (unitInfo != null) {
                return GetUnitRecipe(unitInfo.UnitId);
            }
            return null;
        }

        public static UnitRecipe GetUnitRecipe(eUnitId unitId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetUnitRecipe(unitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<UnitInfo> GetUnitInfos() {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetUnitInfos();
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static UnitInfo GetUnitInfo(UnitInfo unitInfo) {
            try {
                if (unitInfo != null) {
                    return GetUnitInfo(unitInfo.UnitId);
                }
                return null;
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static UnitInfo GetUnitInfo(eUnitId unitId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetUnitInfo(unitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<eUnitId> GetUnitIds() {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetUnitIds();
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static string GetUnitName(eUnitId unitId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetUnitName(unitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return string.Empty;
            }
        }

        public static SubSysRecipe GetSubSysRecipe(SubSysInfo subSysInfo) {
            if (subSysInfo != null) {
                return GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            }
            return null;
        }

        public static SubSysRecipe GetSubSysRecipe(eUnitId unitId, eSubSysId subSysId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetSubSysRecipe(unitId, subSysId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static int GetSubSysCount(eUnitId unitId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetSubSysCount(unitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return 0;
            }
        }

        public static List<SubSysInfo> GetSubSysInfos(UnitInfo unitInfo) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetSubSysInfos(unitInfo.UnitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<SubSysInfo> GetSubSysInfos(eUnitId unitId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetSubSysInfos(unitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<SubSysInfo> GetSubSysInfos() {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetSubSysInfos();
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static SubSysInfo GetSubSysInfo(SubSysInfo subSysInfo) {
            try {
                if (subSysInfo != null) {
                    var vsRpDef = GetVisionRecipeDef();
                    return vsRpDef.GetSubSysInfo(subSysInfo.UnitId, subSysInfo.SubSysId);
                }
                return null;
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static SubSysInfo GetSubSysInfo(eUnitId unitId, eSubSysId subSysId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetSubSysInfo(unitId, subSysId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<string> GetSubSysNames(eUnitId unitId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetSubSysNames(unitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<FovRecipe> GetFovRecipes(List<FovInfo> fovinfos) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetFovRecipes(fovinfos);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static FovRecipe GetFovRecipe(FovInfo fovInfo) {
            if (fovInfo != null) {
                return GetFovRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            }
            return null;
        }

        public static FovRecipe GetFovRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetFovRecipe(unitId, subSysId, fovId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<FovInfo> GetFovInfos(eCamId camId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetFovInfos(camId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<FovInfo> GetFovInfos() {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetFovInfos();
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<FovInfo> GetFovInfos(eUnitId unitId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetFovInfos(unitId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<FovInfo> GetFovInfos(SubSysInfo subSysInfo) {
            if (subSysInfo != null) {
                return GetFovInfos(subSysInfo.UnitId, subSysInfo.SubSysId);
            }
            return null;
        }

        public static List<FovInfo> GetFovInfos(eUnitId unitId, eSubSysId subSysId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetFovInfos(unitId, subSysId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static FovInfo GetFovInfo(SubSysInfo subSysInfo, eFovId fovId) {
            if (subSysInfo != null) {
                return GetFovInfo(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
            }
            return null;
        }

        public static FovInfo GetFovInfo(FovInfo fovInfo) {
            if (fovInfo != null) {
                return GetFovInfo(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            }
            return null;
        }

        public static FovInfo GetFovInfo(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetFovInfo(unitId, subSysId, fovId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static int GetFovCnt(SubSysInfo subSysInfo) {
            if (subSysInfo != null) {
                return GetFovCnt(subSysInfo.UnitId, subSysInfo.SubSysId);
            }
            return -1;
        }

        public static int GetFovCnt(eUnitId unitId, eSubSysId subSysId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetFovCnt(unitId, subSysId);
        }

        public static List<eFovIdPair> GetFovIdPairs(List<eFovId> fovIds) {
            fovIds.Sort();
            var fovIdPairs = new List<eFovIdPair>();
            var tempList = new List<eFovId>();

            for (eFovId fovId = fovIds.Min(); fovId < fovIds.Max(); fovId++) {
                if (!fovIds.Contains(fovId)) {
                    continue;
                }
                tempList.Clear();

                for (eFovId curFovId = fovId; curFovId <= fovIds.Max(); curFovId++) {
                    if (!fovIds.Contains(curFovId)) {
                        continue;
                    }

                    if (!tempList.Contains(curFovId)) {
                        tempList.Add(curFovId);

                        if (tempList.Count == 2) {
                            if (tempList.Contains(eFovId.Fov1) && tempList.Contains(eFovId.Fov2)) {
                                fovIdPairs.Add(eFovIdPair.Fov1_2);
                                tempList.Remove(eFovId.Fov2);
                            }
                            else if (tempList.Contains(eFovId.Fov1) && tempList.Contains(eFovId.Fov3)) {
                                fovIdPairs.Add(eFovIdPair.Fov1_3);
                                tempList.Remove(eFovId.Fov3);
                            }
                            else if (tempList.Contains(eFovId.Fov1) && tempList.Contains(eFovId.Fov4)) {
                                fovIdPairs.Add(eFovIdPair.Fov1_4);
                            }
                            else if (tempList.Contains(eFovId.Fov2) && tempList.Contains(eFovId.Fov3)) {
                                fovIdPairs.Add(eFovIdPair.Fov2_3);
                                tempList.Remove(eFovId.Fov3);
                            }
                            else if (tempList.Contains(eFovId.Fov2) && tempList.Contains(eFovId.Fov4)) {
                                fovIdPairs.Add(eFovIdPair.Fov2_4);
                            }
                            else if (tempList.Contains(eFovId.Fov3) && tempList.Contains(eFovId.Fov4)) {
                                fovIdPairs.Add(eFovIdPair.Fov3_4);
                            }
                        }
                    }
                }
            }
            return fovIdPairs;
        }

        public static eFovUiPos GetFovUiPos(FovRecipe fovRecipe, eDisplayType displayType) {
            eFovUiPos fovUiPos = new eFovUiPos();
            foreach (var mainUiRecipe in fovRecipe.MainUiRecipes) {
                if (mainUiRecipe.MainDisplayType == displayType) {
                    fovUiPos = mainUiRecipe.FovUiPos;
                    return fovUiPos;
                }
            }
            return fovUiPos;
        }

        public static FovInfo GetLastFovInfo(SubSysInfo subSysInfo) {
            var fovInfos = GetFovInfos(subSysInfo);
            FovInfo lastFovInfo = GetFovInfo(subSysInfo, eFovId.Fov1);
            foreach (var fovInfo in fovInfos) {
                if ((int)lastFovInfo.FovId < (int)fovInfo.FovId) {
                    lastFovInfo = fovInfo;
                }
            }
            return lastFovInfo;
        }

        public static List<eCamId> GetCamIds() {
            var fovRecipes = new List<FovRecipe>();
            foreach (var fovInfo in GetFovInfos()) {
                var fovRecipe = GetFovRecipe(fovInfo);
                if (fovRecipe != null) {
                    fovRecipes.Add(fovRecipe);
                }
            }
            return GetCamIds(fovRecipes);
        }

        public static List<eCamId> GetCamIds(List<FovRecipe> fovRecipes) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetCamIds(fovRecipes);
        }

        public static AlignRecipe GetAlignRecipe(AlignInfo alignInfo) {
            if (alignInfo != null) {
                return GetAlignRecipe(alignInfo.UnitId, alignInfo.SubSysId, alignInfo.AlignId);
            }
            return null;
        }

        public static AlignRecipe GetAlignRecipe(eUnitId unitId, eSubSysId subSysId, eAlignId alignId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetAlignRecipe(unitId, subSysId, alignId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<AlignInfo> GetAlignInfos() {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetAlignInfos();
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<AlignInfo> GetAlignInfos(SubSysInfo subSysInfo) {
            try {
                if (subSysInfo != null) {
                    var vsRpDef = GetVisionRecipeDef();
                    return vsRpDef.GetAlignInfos(subSysInfo.UnitId, subSysInfo.SubSysId);
                }
                return null;
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static List<AlignInfo> GetAlignInfos(eUnitId unitId, eSubSysId subSysId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetAlignInfos(unitId, subSysId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static AlignInfo GetAlignInfo(eUnitId unitId, eSubSysId subSysId, eAlignId alignId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetAlignInfo(unitId, subSysId, alignId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static AlignOffset GetAlignOffset(eUnitId unitId, eSubSysId subSysId, eAlignId alignId) {
            var vsRpDef = GetVisionRecipeDef();
            var alignRecipe = vsRpDef.GetAlignRecipe(unitId, subSysId, alignId);
            if (alignRecipe != null) {
                return alignRecipe.AlignOffset;
            }
            return null;
        }

        public static InspRecipe GetInspRecipe(SubSysInfo subSysInfo) {
            if (subSysInfo != null) {
                return GetInspRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            }
            return null;
        }

        public static InspRecipe GetInspRecipe(eUnitId unitId, eSubSysId subSysId) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetInspRecipe(unitId, subSysId);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static AttachInspRecipe GetAttachInspRecipe(SubSysInfo subSysInfo) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetAttachInspRecipe(subSysInfo);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static AttachInspParam GetAttachInspParam(FovInfo fovInfo) {
            try {
                var vsRpDef = GetVisionRecipeDef();
                return vsRpDef.GetAttachInspParam(fovInfo);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static string GetDisplayName(string subSysName, string fovName) {
            try {
                return string.Format($"{subSysName}_{fovName}");
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
                return null;
            }
        }

        public static CamRecipe GetCamRecipe(FovInfo fovInfo) {
            if (fovInfo != null) {
                return GetCamRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            }
            return null;
        }

        public static CamRecipe GetCamRecipe(SubSysInfo subSysInfo, eFovId fovId) {
            if (subSysInfo != null) {
                return GetCamRecipe(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
            }
            return null;
        }

        public static CamRecipe GetCamRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetCamRecipe(unitId, subSysId, fovId);
        }

        public static PatternRecipe GetPatternRecipe(SubSysInfo subSysInfo, eFovId fovId) {
            if (subSysInfo != null) {
                return GetPatternRecipe(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
            }
            return null;
        }

        public static PatternRecipe GetPatternRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetPatternRecipe(unitId, subSysId, fovId);
        }

        public static PatternInfo GetPatternInfo(FovInfo fovInfo, ProcPatternInfo procPatternInfo, AlignInfo alignInfo) {
            var fovRecipe = GetFovRecipe(fovInfo);

            PatternIndex patternIndex;
            PatternAgentBase patternAgent;

            if (procPatternInfo.IsFovPattern) {
                patternAgent = FovPatternAgentManager.GetAgent(fovInfo.ToSubSysInfo());
                patternIndex = new FovPatternIndex(fovInfo, fovRecipe.FovName, procPatternInfo.PatternId);
            }
            else {
                patternAgent = CamPatternAgentManager.GetAgent(fovRecipe.CamRecipe.CamId);
                patternIndex = new CamPatternIndex(fovRecipe.CamRecipe.CamId, procPatternInfo.PatternId);
            }

            PatternInfo patternInfo = patternAgent.GetPatternInfo(patternIndex);
            patternInfo.PatternName = procPatternInfo.PatternName;

            return patternInfo;
        }

        public static CalRecipe GetCalRecipe(SubSysInfo subSysInfo) {
            if (subSysInfo != null) {
                return GetCalRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            }
            return null;
        }

        public static CalRecipe GetCalRecipe(eUnitId unitId, eSubSysId subSysId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetCalRecipe(unitId, subSysId);
        }

        public static StaticPoint GetThetaOrigin(SubSysInfo subSysInfo) {
            var calRecipe = GetCalRecipe(subSysInfo);
            if (calRecipe != null) {
                return calRecipe.ThetaOrigin;
            }

            return null;
        }

        public static CalFovRecipe GetCalFovRecipe(FovInfo fovInfo) {
            if (fovInfo != null) {
                return GetCalFovRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            }
            return null;
        }

        public static CalFovRecipe GetCalFovRecipe(SubSysInfo subSysInfo, eFovId fovId) {
            if (subSysInfo != null) {
                return GetCalFovRecipe(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
            }
            return null;
        }

        public static CalFovRecipe GetCalFovRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetCalFovRecipe(unitId, subSysId, fovId);
        }

        /// <summary>
        /// 자재 좌표계의 FOV 위치(오프셋 포함)를 반환한다.
        /// </summary>
        /// <param name="fovInfo">FovInfo</param>
        /// <returns>FOV 위치</returns>
        public static StaticPoint GetFovPoint(FovInfo fovInfo) {
            if (fovInfo != null) {
                return GetFovPoint(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            }
            return null;
        }

        /// <summary>
        /// 자재 좌표계의 FOV 위치(오프셋 포함)를 반환한다.
        /// </summary>
        /// <param name="subSysInfo">SubSysInfo</param>
        /// <param name="fovId">eFovId</param>
        /// <returns>FOV 위치</returns>
        public static StaticPoint GetFovPoint(SubSysInfo subSysInfo, eFovId fovId) {
            if (subSysInfo != null) {
                return GetFovPoint(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
            }
            return null;
        }

        /// <summary>
        /// 자재 좌표계의 FOV 위치(오프셋 포함)를 반환한다.
        /// </summary>
        /// <param name="unitId">eUnitId</param>
        /// <param name="subSysId">eSubSysId</param>
        /// <param name="fovId">eFovId</param>
        /// <returns>FOV 위치</returns>
        public static StaticPoint GetFovPoint(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var calRecipe = GetCalFovRecipe(unitId, subSysId, fovId);
            if (calRecipe != null) {
                return calRecipe.FovCenter + calRecipe.FovCenterOffset as StaticPoint;
            }
            return null;
        }

        /// <summary>
        /// 얼라인 정위치(Reference Point) 레시피를 반환한다.
        /// </summary>
        /// <param name="fovInfo">FovInfo</param>
        /// <returns>RefPointRecipe</returns>
        public static RefPointRecipe GetRefPointRecipe(FovInfo fovInfo) {
            if (fovInfo != null) {
                return GetRefPointRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            }
            return null;
        }

        /// <summary>
        /// 얼라인 정위치(Reference Point) 레시피를 반환한다.
        /// </summary>
        /// <param name="unitId">UnitId</param>
        /// <param name="subSysId">SubSysId</param>
        /// <param name="fovId">FovId</param>
        /// <returns>RefPointRecipe</returns>
        public static RefPointRecipe GetRefPointRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetRefPointRecipe(unitId, subSysId, fovId);
        }

        /// <summary>
        /// 얼라인 정위치(Reference Point)를 반환한다.
        /// </summary>
        /// <param name="subSysInfo">SubSysInfo</param>
        /// <param name="fovId">FovId</param>
        /// <returns>Reference Point</returns>
        public static StaticPoint GetRefPoint(SubSysInfo subSysInfo, eFovId fovId) {
            if (subSysInfo != null) {
                return GetRefPoint(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
            }
            return null;
        }

        /// <summary>
        /// 얼라인 정위치(Reference Point)를 반환한다.
        /// </summary>
        /// <param name="fovInfo">FovInfo</param>
        /// <returns>Reference Point</returns>
        public static StaticPoint GetRefPoint(FovInfo fovInfo) {
            if (fovInfo != null) {
                return GetRefPoint(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            }
            return null;
        }

        /// <summary>
        /// 얼라인 정위치(Reference Point)를 반환한다.
        /// </summary>
        /// <param name="unitId">UnitId</param>
        /// <param name="subSysId">SubSysId</param>
        /// <param name="fovId">FovId</param>
        /// <returns>Reference Point</returns>
        public static StaticPoint GetRefPoint(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var vsRpDef = GetVisionRecipeDef();

            var refPointRecipe = vsRpDef.GetRefPointRecipe(unitId, subSysId, fovId);
            if (refPointRecipe != null) {
                return (GetFovPoint(unitId, subSysId, fovId) + refPointRecipe.Offset) as StaticPoint;
            }
            return null;
        }

        public static ProcPatternInfo GetProcPatternInfo(
            SubSysInfo subSysInfo, eFovId fovId, string procId, eProcPatternId procPatternId) {
            if (subSysInfo != null) {
                return GetProcPatternInfo(subSysInfo.UnitId, subSysInfo.SubSysId, fovId, procId, procPatternId);
            }
            return null;
        }

        public static ProcPatternInfo GetProcPatternInfo(
            SubSysInfo subSysInfo, eFovId fovId, string procId, int procPatternId) {
            if (subSysInfo != null) {
                return GetProcPatternInfo(subSysInfo.UnitId, subSysInfo.SubSysId, fovId, procId, (eProcPatternId)procPatternId);
            }
            return null;
        }

        public static ProcPatternInfo GetProcPatternInfo(
            eUnitId unitId, eSubSysId subSysId, eFovId fovId, string procId, int procPatternId) {
            return GetProcPatternInfo(unitId, subSysId, fovId, procId, (eProcPatternId)procPatternId);
        }

        public static ProcPatternInfo GetProcPatternInfo(
            FovInfo fovInfo, string procId, eProcPatternId procPatternId) {
            if (fovInfo != null) {
                return GetProcPatternInfo(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId, procId, procPatternId);
            }
            return null;
        }

        public static ProcPatternInfo GetProcPatternInfo(
            eUnitId unitId, eSubSysId subSysId, eFovId fovId, string procId, eProcPatternId procPatternId) {
            try {
                var patternRecipe = GetPatternRecipe(unitId, subSysId, fovId);
                return patternRecipe.ProcPatternInfos.Where(p => p.ProcPatternId.Equals(procPatternId) && p.ProcId.Equals(procId)).FirstOrDefault().Clone();
            }
            catch (NullReferenceException e) {
                MessageUtil.ShowErrorToast($"[{subSysId}][{fovId}][{procPatternId}] Not Found in ProcPatternInfos.");
                _Logger.FuncE(e.Message);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }
            return null;
        }

        public static DirectorRecipe GetTeachingDirectorRecipe(SubSysInfo subSysInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetTeachingDirectorRecipe(subSysInfo);
        }

        public static DirectorRecipe GetAlignDirectorRecipe(SubSysInfo subSysInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetAlignDirectorRecipe(subSysInfo);
        }

        public static LightRetryParams GetLightRetryParams(SubSysInfo subSysInfo, eAlignId alignId)
        {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetLightRetryParams(subSysInfo, alignId);
        }

        public static bool IsLightRetryEnaled(SubSysInfo subSysInfo, eAlignId alignId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.IsLightRetryEnaled(subSysInfo, alignId);
        }


        public static bool IsForceOkEnaled(SubSysInfo subSysInfo, eAlignId alignId) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.IsForceOkEnaled(subSysInfo, alignId);
        }

        public static CoordConvRecipe GetCoordConvRecipe(SubSysInfo subSysInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetCoordConvRecipe(subSysInfo);
        }

        public static eSubSysType GetSubSysType(SubSysInfo subSysInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetSubSysType(subSysInfo);
        }

        public static bool ContainsAlignSystem(UnitInfo unitInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.ContainsAlignSystem(unitInfo);
        }

        public static bool ContainsInspSystem(UnitInfo unitInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.ContainsInspSystem(unitInfo);
        }

        public static bool ContainsReviewSystem(UnitInfo unitInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.ContainsReviewSystem(unitInfo);
        }

        #region Setup Recipe for SubSystem
        public static CalSetupRecipe GetCalSetupRecipe(SubSysInfo subSysInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetCalSetupRecipe(subSysInfo);
        }

        public static CenterTuningRecipe GetCenterTuningRecipe(SubSysInfo subSysInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetCenterTuningRecipe(subSysInfo);
        }
        #endregion

        #region Setup Recipe for Fov
        public static AutoFocusRecipe GetAutoFocusRecipe(FovInfo fovInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetAutoFocusRecipe(fovInfo);
        }

        public static VisionRepeatRecipe GetVisionRepeatRecipe(FovInfo fovInfo) {
            var vsRpDef = GetVisionRecipeDef();
            return vsRpDef.GetVisionRepeatRecipe(fovInfo);
        }
        #endregion
    }
}