using Aurora;
using VisionCommon;
using System;
using System.Windows;
using System.Windows.Controls;
using Aurora.Api;
using VisionCommonUI;
using VisionCommonUI.Resources;

namespace VisionUI.Setup {
    /// <summary>
    /// 캘리브레이션 뷰
    /// CalView.xaml behind code
    /// </summary>
    public partial class CalView : UserControl, IUpdateRecipe, IDisposable {
        private SubSysInfo _SubSysInfo;
        private SubSysRecipe _SubSysRecipe;
        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="subSysInfo">서브시스템 정보</param>
        public CalView(SubSysInfo subSysInfo) {
            this._SubSysInfo = subSysInfo;
            this._SubSysRecipe = VisionRecipeManager.GetSubSysRecipe(_SubSysInfo);

            InitializeComponent();
        }

        private void Init() {
            if (VisionRecipeManager.GetFovCnt(_SubSysInfo) == 1) {
                CreateCameraView_Single();
            }
            else {
                CreateCameraView_Multi();
            }

            CreateCalParamView();
            CreateCalLogView();
            CreateCalSettingView();
        }

        private void CreateCameraView_Single() {
            var fovInfo = new FovInfo(_SubSysInfo, eFovId.Fov1);
            var cameraView = IpViewManager.CreateCameraView(fovInfo, eDisplayType.Calibration);
            gridCameraView.Children.Add(cameraView);
        }

        private void CreateCameraView_Multi() {
            // Create 2x2 grid
            var grid = new Grid();
            var rowDef1 = new RowDefinition();
            var rowDef2 = new RowDefinition();
            var colDef1 = new ColumnDefinition();
            var colDef2 = new ColumnDefinition();

            grid.RowDefinitions.Add(rowDef1);
            grid.RowDefinitions.Add(rowDef2);
            grid.ColumnDefinitions.Add(colDef1);
            grid.ColumnDefinitions.Add(colDef2);

            var fovInfos = VisionRecipeManager.GetFovInfos(_SubSysInfo);
            foreach (var fovInfo in fovInfos) {
                var cameraView = IpViewManager.CreateCameraView(fovInfo, eDisplayType.Calibration);

                switch (fovInfo.FovId) {
                    case eFovId.Fov1:
                        Grid.SetRow(cameraView, 0);
                        Grid.SetColumn(cameraView, 0);
                        break;
                    case eFovId.Fov2:
                        Grid.SetRow(cameraView, 0);
                        Grid.SetColumn(cameraView, 1);
                        break;
                    case eFovId.Fov3:
                        Grid.SetRow(cameraView, 1);
                        Grid.SetColumn(cameraView, 0);
                        break;
                    case eFovId.Fov4:
                        Grid.SetRow(cameraView, 1);
                        Grid.SetColumn(cameraView, 1);
                        break;
                }
                grid.Children.Add(cameraView);
            }

            if (fovInfos.Count == 0 || grid.Children.Count < fovInfos.Count) {
                PrintRecipeError(typeof(FovRecipe).Name, gridCameraView);
            }
            else {
                gridCameraView.Children.Add(grid);
            }
        }

        private void CreateCalParamView() {
            var fovTabControl = new TabControl();
            fovTabControl.Style = FindResource("styleSubMenuRootTabControl") as Style;
            fovTabControl.Margin = new System.Windows.Thickness(3, 5, 3, 5);

            var fovInfos = VisionRecipeManager.GetFovInfos(_SubSysInfo);
            foreach (var fovInfo in fovInfos) {
                var fovTabItem = new TabItem();
                var fovRecipe = VisionRecipeManager.GetFovRecipe(fovInfo);
                fovTabItem.Header = fovRecipe.FovName;
                fovTabItem.Content = GetCalParamView(fovInfo);
                fovTabItem.Style = FindResource("styleSubMenuRootTabItem") as Style;
                fovTabControl.Items.Add(fovTabItem);
            }

            if (fovInfos.Count == 0 || fovTabControl.Items.Count < fovInfos.Count) {
                PrintRecipeError(typeof(FovRecipe).Name, gridCalParamView);
            }
            else {
                gridCalParamView.Children.Add(fovTabControl);
            }
        }

        private void CreateCalLogView() {
            var calLogView = new CalLogView(_SubSysInfo);
            var calLogViewModel = new CalLogViewModel(_SubSysInfo);

            calLogView.DataContext = calLogViewModel;
            (DataContext as CalViewModel).SetCalLogViewModel(calLogViewModel);

            gridCalLogView.Children.Add(calLogView);
        }

        private void CreateCalSettingView() {
            var calSettingView = new CalSettingView(_SubSysInfo);
            var calSettingViewModel = new CalSettingViewModel(_SubSysInfo);

            calSettingView.DataContext = calSettingViewModel;
            (DataContext as CalViewModel).SetCalSettingViewModel(calSettingViewModel);

            gridCalSettingView.Children.Add(calSettingView);
        }

        private CalParamView GetCalParamView(FovInfo fovInfo) {
            var calParamView = new CalParamView(fovInfo);
            var calParamViewModel = new CalParamViewModel(fovInfo);

            calParamView.DataContext = calParamViewModel;
            (DataContext as CalViewModel).SetCalParamViewModel(calParamViewModel);

            return calParamView;
        }

        private void PrintRecipeError(string recipeName, Grid grid) {
            var errMsg = string.Format(StrTokens.RecipeErrorMessage, recipeName);
            grid.Children.Add(new UCRecipeErrorTextBlock(errMsg) { Margin = new Thickness(15) });
            grid.VerticalAlignment = VerticalAlignment.Center;
            grid.HorizontalAlignment = HorizontalAlignment.Center;
        }

        private void UserControl_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) {
            bool isVisible = (bool)e.NewValue;
            if (isVisible == true) {
                RefreshVisionRecipes();
                Init();
            }
            else {
                ISequence seq = VisionEnv.AuroraEnv.SequenceEntry[VisionKeys.CalSeqKey];
                if (seq != null) {
                    if (seq.RunState != SequenceRunState.Idle) {
                        seq.EmergencyStop();
                    }
                }
                Dispose();
            }
        }

        public void RefreshVisionRecipes() {
            _SubSysRecipe = VisionRecipeManager.GetSubSysRecipe(_SubSysInfo);
        }

        public void UpdateRecipeFromFile() {
            throw new NotImplementedException();
        }

        public void UpdateRecipeFromUI() {
            throw new NotImplementedException();
        }

        #region Dispose
        public void Dispose() {
            CheckRecipeErrorGrid(gridCameraView);
            CheckRecipeErrorGrid(gridCalParamView);

            if (VisionRecipeManager.GetFovCnt(_SubSysInfo) == 1) {
                RemoveCameraView_Single();
            }
            else {
                RemoveCameraView_Multi();
            }

            RemoveCalParamView();
            RemoveCalLogView();
            RemoveCalSettingView();
        }

        private void CheckRecipeErrorGrid(Grid grid) {
            if (grid.Children.Count == 1) {
                if (grid.Children[0] is UCRecipeErrorTextBlock) {
                    grid.Children.Clear();
                }
            }
        }

        private void RemoveCameraView_Single() {
            foreach (var child in gridCameraView.Children) {
                if (child is UserControl view) {
                    IpViewManager.DisposeCameraView(view);
                }
            }
            gridCameraView.Children.Clear();
        }

        private void RemoveCameraView_Multi() {
            foreach (Grid child in gridCameraView.Children) {
                foreach (var innerChild in child.Children) {
                    if (innerChild is UserControl view) {
                        IpViewManager.DisposeCameraView(view);
                    }
                }
                child.Children.Clear();
            }
            gridCameraView.Children.Clear();
        }

        private void RemoveCalParamView() {
            foreach (var child in gridCalParamView.Children) {
                var fovTabControl = child as TabControl;

                foreach (TabItem tabItem in fovTabControl.Items) {
                    if (tabItem.Content is CalParamView view) {
                        view.Dispose();
                        view = null;
                    }
                }
            }
            gridCalParamView.Children.Clear();
        }

        private void RemoveCalLogView() {
            foreach (var child in gridCalLogView.Children) {
                if (child is CalLogView view) {
                    view = null;
                }
            }
            gridCalLogView.Children.Clear();
        }

        private void RemoveCalSettingView() {
            foreach (var child in gridCalSettingView.Children) {
                if (child is CalSettingView view) {
                    view = null;
                }
            }
            gridCalSettingView.Children.Clear();
        }
        #endregion
    }
}