using Aurora.Api;
using PropertyTools.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;

namespace VisionCommon {
    public abstract class VisionDef {
        /// <summary>현재 SW의 레시피 버전</summary>
        public const double RECIPE_VERSION_CURRENT = 0.1;
        /// <summary>레시피 최초 버전</summary>
        public const double RECIPE_VERSION_INITIAL = 0.1; // 수정 금지
        private Logger _logger = new Logger(typeof(VisionDef).Name);

        [System.ComponentModel.ReadOnly(true)]
        public double Version { get; set; } = RECIPE_VERSION_INITIAL;
        public ObservableCollection<UnitRecipe> UnitRecipes { get; set; } = new ObservableCollection<UnitRecipe>();

        public VisionDef() {
            UnitRecipes.CollectionChanged += UnitRecipes_CollectionChanged;
        }

        #region UnitRecipes CollectionChanged Event
        private void UnitRecipes_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) {
            try {
                var unitRecipes = sender as ObservableCollection<UnitRecipe>;

                if (e.Action == NotifyCollectionChangedAction.Add) {
                    var newUnitReicpe = e.NewItems[0] as UnitRecipe;

                    if (unitRecipes == null || unitRecipes.Count == 0) {
                        return;
                    }
                    else {
                        newUnitReicpe.UnitId = (eUnitId)unitRecipes.Count - 1;
                        if (string.IsNullOrEmpty(newUnitReicpe.UnitName)) {
                            newUnitReicpe.UnitName = newUnitReicpe.UnitId.ToString();
                        }
                    }
                }
                else if (e.Action == NotifyCollectionChangedAction.Remove) {
                    int index = 0;
                    foreach (UnitRecipe unitRecipe in unitRecipes) {
                        if (index == (int)eUnitId.Max) {
                            break;
                        }
                        unitRecipe.UnitId = (eUnitId)index++;
                        if (string.IsNullOrEmpty(unitRecipe.UnitName) || unitRecipe.UnitName.Contains("Unit")) {
                            unitRecipe.UnitName = unitRecipe.UnitId.ToString();
                        }
                    }
                }
            }
            catch (Exception ex) {
            }
        }
        #endregion

        public List<UnitInfo> GetUnitInfos() {
            return UnitRecipes
                .Select(vu => new UnitInfo(vu.UnitId, vu.UnitName))
                .OrderBy(vu => vu.UnitId)
                .ToList();
        }

        public UnitInfo GetUnitInfo(eUnitId unitId) {
            return new UnitInfo(unitId, GetUnitName(unitId));
        }

        public List<eUnitId> GetUnitIds() {
            return UnitRecipes
                .Select(vu => vu.UnitId)
                .OrderBy(unitId => unitId)
                .ToList();
        }

        public string GetUnitName(eUnitId unitId) {
            if (IsValidId(unitId)) {
                var unitRecipe = GetUnitRecipe(unitId);
                if (unitRecipe != null) {
                    return unitRecipe.UnitName;
                }
            }
            return string.Empty;
        }

        public ObservableCollection<UnitRecipe> GetUnitRecipes() {
            return UnitRecipes;
        }

        public UnitRecipe GetUnitRecipe(eUnitId unitId) {
            return UnitRecipes.Where(x => x.UnitId == unitId).FirstOrDefault();
        }

        public SubSysRecipe GetSubSysRecipe(SubSysInfo subSysInfo) {
            return GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
        }

        public SubSysRecipe GetSubSysRecipe(eUnitId unitId, eSubSysId subSysId) {
            if (IsValidId(unitId, subSysId)) {
                var unitRecipe = GetUnitRecipe(unitId);
                if (unitRecipe != null) {
                    return unitRecipe.SubSysRecipes.Where(x => x.SubSysId == subSysId).FirstOrDefault();
                }
            }
            return null;
        }

        public List<FovRecipe> GetFovRecipes(List<FovInfo> fovInfos) {
            List<FovRecipe> fovRecipes = new List<FovRecipe>();
            foreach (var fovinfo in fovInfos) {
                fovRecipes.Add(GetFovRecipe(fovinfo.UnitId, fovinfo.SubSysId, fovinfo.FovId));
            }
            return fovRecipes;
        }

        public FovRecipe GetFovRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            if (IsValidId(unitId, subSysId, fovId)) {
                var subSysRecipe = GetSubSysRecipe(unitId, subSysId);
                if (subSysRecipe != null) {
                    return subSysRecipe.FovRecipes.Where(x => x.FovId == fovId).FirstOrDefault();
                }
            }
            return null;
        }

        public AlignRecipe GetAlignRecipe(eUnitId unitId, eSubSysId subSysId, eAlignId alignId) {
            if (IsValidId(unitId, subSysId, alignId)) {
                var subSysRecipe = GetSubSysRecipe(unitId, subSysId);
                if (subSysRecipe != null) {
                    return subSysRecipe.AlignRecipes.Where(x => x.AlignId == alignId).FirstOrDefault();
                }
            }
            return null;
        }

        public InspRecipe GetInspRecipe(eUnitId unitId, eSubSysId subSysId) {
            if (IsValidId(unitId, subSysId)) {
                var subSysRecipe = GetSubSysRecipe(unitId, subSysId);
                if (subSysRecipe != null) {
                    return subSysRecipe.InspRecipe;
                }
            }
            return null;
        }

        public AttachInspRecipe GetAttachInspRecipe(SubSysInfo subSysInfo) {
            if (IsValidId(subSysInfo.UnitId, subSysInfo.SubSysId)) {
                var inspRecipe = GetInspRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
                if (inspRecipe?.AttachInspRecipe != null) {
                    return inspRecipe.AttachInspRecipe;
                }
            }
            return null;
        }

        public AttachInspParam GetAttachInspParam(FovInfo fovInfo) {
            if (IsValidId(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId)) {
                var inspRecipe = GetInspRecipe(fovInfo.UnitId, fovInfo.SubSysId);
                if (inspRecipe?.AttachInspRecipe?.AttachInspParams != null) {
                    return inspRecipe.AttachInspRecipe.AttachInspParams[(int)fovInfo.FovId];
                }
            }
            return null;
        }

        private bool IsValidId(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            if (IsValidId(unitId, subSysId)) {
                return fovId != eFovId.None &&
                    (int)fovId < GetFovCnt(unitId, subSysId);
            }
            return false;
        }

        private bool IsValidId(eUnitId unitId, eSubSysId subSysId, eAlignId alignId) {
            if (IsValidId(unitId, subSysId)) {
                return alignId != eAlignId.None &&
                    (int)alignId < GetAlignCnt(unitId, subSysId);
            }
            return false;
        }

        private bool IsValidId(eUnitId unitId, eSubSysId subSysId) {
            if (IsValidId(unitId)) {
                return subSysId != eSubSysId.None &&
                    (int)subSysId < GetSubSysCount(unitId);
            }
            return false;
        }

        private bool IsValidId(eUnitId unitId) {
            return eUnitId.None != unitId && (int)unitId < UnitRecipes.Count;
        }

        public int GetSubSysCount(eUnitId unitId) {
            if (IsValidId(unitId)) {
                var unitRecipe = GetUnitRecipe(unitId);
                if (unitRecipe != null) {
                    return unitRecipe.SubSysRecipes.Count;
                }
            }
            return 0;
        }

        public List<SubSysInfo> GetSubSysInfos(UnitInfo unitInfo) {
            return GetSubSysInfos(unitInfo.UnitId);
        }

        public List<SubSysInfo> GetSubSysInfos(eUnitId unitId) {
            var subSysInfos = new List<SubSysInfo>();
            if (IsValidId(unitId)) {
                var unitRecipe = GetUnitRecipe(unitId);
                if (unitRecipe != null) {
                    foreach (var subSystem in unitRecipe.SubSysRecipes) {
                        subSysInfos.Add(GetSubSysInfo(unitId, subSystem.SubSysId));
                    }
                }
            }
            return subSysInfos.OrderBy(subSysRecipe => subSysRecipe.SubSysId).ToList();
        }

        public List<SubSysInfo> GetSubSysInfos() {
            List<SubSysInfo> subSysInfos = new List<SubSysInfo>();
            foreach(var unitInfo in GetUnitInfos()) {
                foreach(var subSysInfo in GetSubSysInfos(unitInfo)) {
                    subSysInfos.Add(subSysInfo);
                }
            }
            return subSysInfos;
        }

        public SubSysInfo GetSubSysInfo(eUnitId unitId, eSubSysId subSysId) {
            if (IsValidId(unitId, subSysId)) {
                var unitInfo = new UnitInfo(unitId, GetUnitName(unitId));
                return new SubSysInfo(unitInfo, subSysId, GetSubSysName(unitId, subSysId));
            }
            return null;
        }

        public List<string> GetSubSysNames(eUnitId unitId) {
            var subSysInfos = GetSubSysInfos(unitId);
            return subSysInfos.Select(subSysInfo => subSysInfo.SubSysName).ToList();
        }

        public string GetSubSysName(eUnitId unitId, eSubSysId subSysId) {
            if (IsValidId(unitId, subSysId)) {
                var unitRecipe = GetUnitRecipe(unitId);
                if (unitRecipe != null) {
                    foreach (var subSystem in unitRecipe.SubSysRecipes) {
                        if (subSystem.SubSysId == subSysId) {
                            return subSystem.SubSysName;
                        }
                    }
                }
            }
            return string.Empty;
        }

        public List<eSubSysId> GetSubSysIds(eUnitId unitId) {
            var subSysInfos = GetSubSysInfos(unitId);
            return subSysInfos.Select(subSysInfo => subSysInfo.SubSysId).ToList();
        }

        public List<FovInfo> GetFovInfos(eCamId camId) {
            var fovInfosSharingCamId = new List<FovInfo>();
            foreach (var unitId in GetUnitIds()) {
                var fovInfos = GetFovInfos(unitId);
                foreach (var fovInfo in fovInfos) {
                    var camRecipe = GetCamRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
                    if (camRecipe.CamId.Equals(camId)) {
                        fovInfosSharingCamId.Add(fovInfo);
                    }
                }
            }
            return fovInfosSharingCamId;
        }

        public List<FovInfo> GetFovInfos() {
            var fovInfos = new List<FovInfo>();
            foreach (var unitId in GetUnitIds()) {
                fovInfos.AddRange(GetFovInfos(unitId));
            }
            return fovInfos;
        }

        public List<FovInfo> GetFovInfos(eUnitId unitId) {
            var fovInfos = new List<FovInfo>();
            if (IsValidId(unitId)) {
                foreach (var subSysInfo in GetSubSysInfos(unitId)) {
                    fovInfos.AddRange(GetFovInfos(unitId, subSysInfo.SubSysId));
                }
            }
            return fovInfos;
        }

        public List<FovInfo> GetFovInfos(eUnitId unitId, eSubSysId subSysId) {
            var fovInfos = new List<FovInfo>();
            if (IsValidId(unitId, subSysId)) {
                var subSysRecipe = GetSubSysRecipe(unitId, subSysId);
                if (subSysRecipe != null) {
                    foreach (var fovRecipe in subSysRecipe.FovRecipes) {
                        fovInfos.Add(new FovInfo(
                            GetSubSysInfo(unitId, subSysId),
                            fovRecipe.FovId,
                            fovRecipe.FovName));
                    }
                }
            }
            return fovInfos.OrderBy(fovInfo => fovInfo.FovId).ToList();
        }

        public FovInfo GetFovInfo(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            if (IsValidId(unitId, subSysId, fovId)) {
                return new FovInfo(
                    GetSubSysInfo(unitId, subSysId),
                    fovId,
                    GetFovName(unitId, subSysId, fovId));
            }
            return null;
        }

        public string GetFovName(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            if (IsValidId(unitId, subSysId, fovId)) {
                var fovRecipe = GetFovRecipe(unitId, subSysId, fovId);
                if (fovRecipe != null) {
                    return fovRecipe.FovName;
                }
            }
            return string.Empty;
        }

        public int GetFovCnt(eUnitId unitId, eSubSysId subSysId) {
            var subSysRcp = GetSubSysRecipe(unitId, subSysId);
            if (subSysRcp != null) {
                return subSysRcp.FovRecipes.Count;
            }

            return 0;
        }

        public List<eCamId> GetCamIds(List<FovRecipe> fovRecipes) {
            HashSet<eCamId> camList = new HashSet<eCamId>();
            camList = fovRecipes.Select(fovRecipe => fovRecipe.CamRecipe.CamId).ToHashSet();
            return camList.ToList();
        }

        public List<AlignInfo> GetAlignInfos() {
            var alignInfos = new List<AlignInfo>();
            foreach (var unitId in GetUnitIds()) {
                alignInfos.AddRange(GetAlignInfos(unitId));
            }
            return alignInfos;
        }

        public List<AlignInfo> GetAlignInfos(eUnitId unitId) {
            var alignInfos = new List<AlignInfo>();
            if (IsValidId(unitId)) {
                foreach (var subSysInfo in GetSubSysInfos(unitId)) {
                    alignInfos.AddRange(GetAlignInfos(unitId, subSysInfo.SubSysId));
                }
            }
            return alignInfos;
        }

        public List<AlignInfo> GetAlignInfos(eUnitId unitId, eSubSysId subSysId) {
            var alignInfos = new List<AlignInfo>();
            if (IsValidId(unitId, subSysId)) {
                var subSysRecipe = GetSubSysRecipe(unitId, subSysId);
                if (subSysRecipe != null) {
                    foreach (var alignRecipe in subSysRecipe.AlignRecipes) {
                        alignInfos.Add(new AlignInfo(
                            GetSubSysInfo(unitId, subSysId),
                            alignRecipe.AlignId,
                            alignRecipe.AlignName));
                    }
                }
            }
            return alignInfos.OrderBy(alignInfo => alignInfo.AlignId).ToList();
        }

        public AlignInfo GetAlignInfo(eUnitId unitId, eSubSysId subSysId, eAlignId alignId) {
            if (IsValidId(unitId, subSysId, alignId)) {
                return new AlignInfo(
                    GetSubSysInfo(unitId, subSysId),
                    alignId,
                    GetAlignName(unitId, subSysId, alignId));
            }
            return null;
        }

        public string GetAlignName(eUnitId unitId, eSubSysId subSysId, eAlignId alignId) {
            if (IsValidId(unitId, subSysId, alignId)) {
                var alignRecipe = GetAlignRecipe(unitId, subSysId, alignId);
                if (alignRecipe != null) {
                    return alignRecipe.AlignName;
                }
            }
            return string.Empty;
        }

        public int GetAlignCnt(eUnitId unitId, eSubSysId subSysId) {
            if (IsValidId(unitId, subSysId)) {
                var subSysRecipe = GetSubSysRecipe(unitId, subSysId);
                if (subSysRecipe != null) {
                    return subSysRecipe.AlignRecipes.Count;
                }
            }
            return 0;
        }

        public CamRecipe GetCamRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var fovRecipe = GetFovRecipe(unitId, subSysId, fovId);
            if (fovRecipe != null) {
                return fovRecipe.CamRecipe;
            }
            return null;
        }

        public PatternRecipe GetPatternRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var fovRecipe = GetFovRecipe(unitId, subSysId, fovId);
            if (fovRecipe != null) {
                return fovRecipe.PatternRecipe;
            }
            return null;
        }

        public CalRecipe GetCalRecipe(eUnitId unitId, eSubSysId subSysId) {
            var subSysRecipe = GetSubSysRecipe(unitId, subSysId);
            if (subSysRecipe != null) {
                return subSysRecipe.CalRecipe;
            }
            return null;
        }

        public CalFovRecipe GetCalFovRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var fovRecipe = GetFovRecipe(unitId, subSysId, fovId);
            if (fovRecipe != null) {
                return fovRecipe.CalFovRecipe;
            }
            return null;
        }

        public RefPointRecipe GetRefPointRecipe(eUnitId unitId, eSubSysId subSysId, eFovId fovId) {
            var fovRecipe = GetFovRecipe(unitId, subSysId, fovId);
            if (fovRecipe != null) {
                return fovRecipe.RefPointRecipe;
            }
            return null;
        }

        public DirectorRecipe GetTeachingDirectorRecipe(SubSysInfo subSysInfo) {
            var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            if (subSysRecipe != null && subSysRecipe.TeachingDirectorRecipe != null) {
                return subSysRecipe.TeachingDirectorRecipe;
            }

            return null;
        }

        public DirectorRecipe GetAlignDirectorRecipe(SubSysInfo subSysInfo) {
            var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            if (subSysRecipe != null && subSysRecipe.AlignDirectorRecipe != null) {
                return subSysRecipe.AlignDirectorRecipe;
            }

            return null;
        }

        public LightRetryParams GetLightRetryParams(SubSysInfo subSysInfo, eAlignId alignId)
        {
            var alignRecipe = GetAlignRecipe(subSysInfo.UnitId, subSysInfo.SubSysId, alignId);
            if (alignRecipe != null)
            {
                return alignRecipe.ProcParams.LightRetryParams;
            }
            return null;
        }

        public bool IsLightRetryEnaled(SubSysInfo subSysInfo, eAlignId alignId) {
            var alignRecipe = GetAlignRecipe(subSysInfo.UnitId, subSysInfo.SubSysId, alignId);
            if (alignRecipe != null) {
                return alignRecipe.ProcParams.LightRetryParams.LightRetryEnabled;
            }
            return false;
        }

        public bool IsForceOkEnaled(SubSysInfo subSysInfo, eAlignId alignId) {
            var alignRecipe = GetAlignRecipe(subSysInfo.UnitId, subSysInfo.SubSysId, alignId);
            if (alignRecipe != null) {
                return alignRecipe.ProcParams.ForceOkEnabled;
            }
            return false;
        }

        public CoordConvRecipe GetCoordConvRecipe(SubSysInfo subSysInfo) {
            var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            if (subSysRecipe != null) {
                return subSysRecipe.CoordConvRecipe;
            }
            return null;
        }

        public eSubSysType GetSubSysType(SubSysInfo subSysInfo) {
            var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            if (subSysRecipe != null) {
                return subSysRecipe.SubSysType;
            }
            return eSubSysType.None;
        }

        public bool ContainsAlignSystem(UnitInfo unitInfo) {
            foreach (SubSysInfo subSysInfo in GetSubSysInfos(unitInfo)) {
                var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
                if (subSysRecipe?.SubSysType == eSubSysType.Align) {
                    return true;
                }
            }
            return false;
        }

        public bool ContainsInspSystem(UnitInfo unitInfo) {
            foreach (SubSysInfo subSysInfo in GetSubSysInfos(unitInfo)) {
                var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
                if (subSysRecipe?.SubSysType == eSubSysType.Inspect) {
                    return true;
                }
            }
            return false;
        }

        public bool ContainsReviewSystem(UnitInfo unitInfo) {
            foreach (SubSysInfo subSysInfo in GetSubSysInfos(unitInfo)) {
                var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
                if (subSysRecipe?.SubSysType == eSubSysType.Review) {
                    return true;
                }
            }
            return false;
        }

        #region Setup Recipe for SubSystem
        public CalSetupRecipe GetCalSetupRecipe(SubSysInfo subSysInfo) {
            var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            if (subSysRecipe != null) {
                return subSysRecipe.SubSysSetupRecipe?.CalSetupRecipe;
            }
            return null;
        }

        public CenterTuningRecipe GetCenterTuningRecipe(SubSysInfo subSysInfo) {
            var subSysRecipe = GetSubSysRecipe(subSysInfo.UnitId, subSysInfo.SubSysId);
            if (subSysRecipe != null) {
                return subSysRecipe.SubSysSetupRecipe?.CenterTuningRecipe;
            }
            return null;
        }
        #endregion

        #region Setup Recipe for Fov
        public AutoFocusRecipe GetAutoFocusRecipe(FovInfo fovInfo) {
            var fovRecipe = GetFovRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            if (fovRecipe != null) {
                return fovRecipe.FovSetupRecipe?.AutoFocusRecipe;
            }
            return null;
        }

        public VisionRepeatRecipe GetVisionRepeatRecipe(FovInfo fovInfo) {
            var fovRecipe = GetFovRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            if (fovRecipe != null) {
                return fovRecipe.FovSetupRecipe?.VisionRepeatRecipe;
            }
            return null;
        }
        #endregion
    }
}