LGES-2170-ACW_CCW-Welder/AuroraVision/VisionCommon/Camera/CameraViewManager.cs

using Aurora.Api;
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;

namespace VisionCommon {
    public class CameraViewManager {
        private static Logger _Logger = new Logger("CameraViewManager");
        private static readonly object _Lock = new object();

        public static CameraViewManager _Instance;
        public static CameraViewManager Instance {
            get {
                lock (_Lock) {
                    try {
                        if (_Instance == null)
                            _Instance = new CameraViewManager();

                        return _Instance;
                    }
                    catch (Exception e) {
                        _Logger.FuncE(e.Message);
                    }

                    return null;
                }
            }
        }

        #region Same FovUiPos FovInfos
        private Dictionary<eDisplayType, Dictionary<eFovUiPos, List<FovInfo>>> _SameFovUiPosFovInfos =
            new Dictionary<eDisplayType, Dictionary<eFovUiPos, List<FovInfo>>>();

        public void SetSameUiPosFovInfos(eDisplayType displayType, eFovUiPos fovUiPos, FovInfo fovInfo) {
            if (!CamCommon.IsMainType(displayType) || fovUiPos == eFovUiPos.None) {
                return;
            }

            if (!_SameFovUiPosFovInfos.ContainsKey(displayType)) {
                _SameFovUiPosFovInfos.Add(displayType, new Dictionary<eFovUiPos, List<FovInfo>>());
            }
            if (!_SameFovUiPosFovInfos[displayType].ContainsKey(fovUiPos)) {
                _SameFovUiPosFovInfos[displayType].Add(fovUiPos, new List<FovInfo>());
            }
            if (!_SameFovUiPosFovInfos[displayType][fovUiPos].Contains(fovInfo)) {
                _SameFovUiPosFovInfos[displayType][fovUiPos].Add(fovInfo);
            }
        }

        public List<FovInfo> GetSameUiPosFovInfos(eDisplayType displayType, eFovUiPos fovUiPos) {
            if (_SameFovUiPosFovInfos.ContainsKey(displayType)) {
                if (_SameFovUiPosFovInfos[displayType].ContainsKey(fovUiPos)) {
                    return _SameFovUiPosFovInfos[displayType][fovUiPos];
                }
            }
            return null;
        }
        #endregion

        #region Camera Views
        private static Dictionary<eDisplayType, Dictionary<FovInfo, UserControl>> _CameraViews =
            new Dictionary<eDisplayType, Dictionary<FovInfo, UserControl>>();

        public void SetCameraView(eDisplayType displayType, FovInfo fovInfo, UserControl camView) {
            if (!_CameraViews.ContainsKey(displayType)) {
                _CameraViews.Add(displayType, new Dictionary<FovInfo, UserControl>());
            }
            if (!_CameraViews[displayType].ContainsKey(fovInfo)) {
                _CameraViews[displayType].Add(fovInfo, null);
            }
            _CameraViews[displayType][fovInfo] = camView;
        }

        public UserControl GetCameraView(eDisplayType displayType, FovInfo fovInfo) {
            if (_CameraViews.ContainsKey(displayType)) {
                if (_CameraViews[displayType].ContainsKey(fovInfo)) {
                    return _CameraViews[displayType][fovInfo];
                }
            }
            return null;
        }
        #endregion

        #region 메인 화면에 겹쳐져있는 화면 보이기/숨기기
        public void InitVisibilities() {
            // 겹치는 메인 화면들을 모두 숨기고, 기본 화면만 보이기
            Application.Current.Dispatcher.BeginInvoke(
                new Action(() => {
                    SetVisibility_AllOff();
                    SetVisibility_BasicOn();
                }));
        }

        public void SetVisibilities(FovInfo fovInfo, eFovUiPos fovUiPos, eDisplayType displayType) {
            if (!CamCommon.IsMainType(displayType)) {
                return;     // 메인 화면이 아니면 Skip
            }
            if (IsAlreadyVisible(fovInfo, displayType)) {
                return;     // 이미 화면이 활성화되어 있으면 Skip
            }

            // 현재 fovUiPos에 겹치는 화면들을 숨기고, 기본 화면만 보이기
            Application.Current.Dispatcher.BeginInvoke(
                new Action(() => {
                    SetVisibility_GrpOff(fovUiPos, displayType);
                    SetVisibility_EachOn(fovInfo, displayType);
                }));
        }

        private bool IsAlreadyVisible(FovInfo fovInfo, eDisplayType displayType) {
            if (_CameraViews[displayType].ContainsKey(fovInfo)) {
                UserControl camView = _CameraViews[displayType][fovInfo];
                if (camView.Visibility == Visibility.Visible) {
                    return true;
                }
            }
            return false;
        }

        public void SetVisibility_AllOff() {
            // 모든 메인 화면 숨기기
            foreach (eDisplayType displayType in _CameraViews.Keys) {
                if (!CamCommon.IsMainType(displayType)) {
                    continue;
                }
                foreach (FovInfo fovInfo in _CameraViews[displayType].Keys) {
                    UserControl camView = _CameraViews[displayType][fovInfo];
                    camView.Visibility = Visibility.Collapsed;
                }
            }
        }

        public void SetVisibility_BasicOn() {
            // 기본 메인 화면만 보이기
            foreach (eDisplayType displayType in _CameraViews.Keys) {
                var basicFovKeys = new List<eFovUiPos>();
                if (!CamCommon.IsMainType(displayType)) {
                    continue;
                }

                foreach (FovInfo fovInfo in _CameraViews[displayType].Keys) {
                    UserControl camView = _CameraViews[displayType][fovInfo];
                    FovRecipe fovRecipe = VisionRecipeManager.GetFovRecipe(fovInfo);
                    if (fovRecipe == null) {
                        continue;
                    }

                    var fovUiPos = VisionRecipeManager.GetFovUiPos(fovRecipe, displayType);
                    // 겹치는 Layout 중에 가장 먼저 등록된 화면만 보이기
                    if (!basicFovKeys.Contains(fovUiPos)) {
                        camView.Visibility = Visibility.Visible;
                        basicFovKeys.Add(fovUiPos);
                    }
                }
            }
        }

        public void SetVisibility_GrpOff(eFovUiPos fovUiPos, eDisplayType displayType) {
            // 현재 fovUiPos에 겹치는 화면들 모두 숨기기
            foreach (FovInfo fovInfo in _CameraViews[displayType].Keys) {
                UserControl camView = _CameraViews[displayType][fovInfo];
                FovRecipe fovRecipe = VisionRecipeManager.GetFovRecipe(fovInfo);
                if (fovRecipe == null) {
                    continue;
                }

                var _fovUiPos = VisionRecipeManager.GetFovUiPos(fovRecipe, displayType);
                if (_fovUiPos.Equals(fovUiPos)) {
                    camView.Visibility = Visibility.Collapsed;
                }
            }
        }

        public void SetVisibility_EachOn(FovInfo fovInfo, eDisplayType displayType) {
            // 현재 fovInfo에 해당하는 화면만 보이기
            if (_CameraViews[displayType].ContainsKey(fovInfo)) {
                UserControl camView = _CameraViews[displayType][fovInfo];
                camView.Visibility = Visibility.Visible;
            }
        }
        #endregion

        public void Remove(eDisplayType displayType, eFovUiPos fovUiPos, FovInfo fovInfo) {
            if (CamCommon.IsMainType(displayType)) {
                if (_SameFovUiPosFovInfos.ContainsKey(displayType)) {
                    if (_SameFovUiPosFovInfos[displayType].ContainsKey(fovUiPos)) {
                        if (_SameFovUiPosFovInfos[displayType][fovUiPos].Contains(fovInfo)) {
                            _SameFovUiPosFovInfos[displayType][fovUiPos].Remove(fovInfo);
                        }
                    }
                }
            }
            if (_CameraViews.ContainsKey(displayType)) {
                if (_CameraViews[displayType].ContainsKey(fovInfo)) {
                    _CameraViews[displayType].Remove(fovInfo);
                }
            }
        }
    }
}