using Aurora.Api;
using VisionCommon;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using VisionCommonUI;
using VisionCommonUI.Resources;
using Aurora.View;
using System.Security.Cryptography;

namespace VisionUI.Pattern {
    /// <summary>
    /// 패턴 콤보박스 정보 키
    /// </summary>
    public class PatternCbInfoKey {
        /// <summary>Fov Id</summary>
        public eFovId FovId { get; set; }
        /// <summary>Proc 패턴 Id</summary>
        public eProcPatternId ProcPatternId { get; set; }
        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="fovId">Fov Id</param>
        /// <param name="procPatternId">Proc 패턴 Id</param>
        public PatternCbInfoKey(eFovId fovId, eProcPatternId procPatternId) {
            this.FovId = fovId;
            this.ProcPatternId = procPatternId;
        }
    }
    /// <summary>
    /// 패턴 콤보박스 정보 값
    /// </summary>
    public class PatternCbInfoValue {
        /// <summary> 패턴 이름</summary>
        public string PatternName { get; set; }
        /// <summary>패턴 콤보박스</summary>
        public ComboBox PatternComboBox { get; set; }
        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="patternName">패턴이름</param>
        /// <param name="patternComboBox">패턴 콤보박스</param>
        public PatternCbInfoValue(string patternName, ComboBox patternComboBox) {
            this.PatternName = patternName;
            this.PatternComboBox = patternComboBox;
        }
    }

    /// <summary>
    /// 패턴 리스트에 등록된 패턴을 공정 패턴으로 지정
    /// </summary>
    public partial class ProcPatternSettingView : UserControl
    {
        private const string PATTERN_UNDEFINED = "Undefined";

        private Logger _Logger;
        private SubSysInfo _SubSysInfo;
        private SubSysRecipe _SubSysRecipe;
        private PatternAgentBase _FovPatternAgent = null;
        private Dictionary<PatternCbInfoKey, PatternCbInfoValue> _PatternCbInfos = new Dictionary<PatternCbInfoKey, PatternCbInfoValue>();
        private Dictionary<PatternCbInfoKey, List<PatternIndex>> _PatternIndexesAll = new Dictionary<PatternCbInfoKey, List<PatternIndex>>();
        private string _ProcId;
        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="subSysInfo">서브시스템 정보</param>
        /// <param name="procId">Proc Id</param>
        public ProcPatternSettingView(SubSysInfo subSysInfo, string procId) {
            _Logger = new Logger(typeof(ProcPatternSettingView).Name);
            _SubSysInfo = subSysInfo;
            _SubSysRecipe = VisionRecipeManager.GetSubSysRecipe(_SubSysInfo);
            _FovPatternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
            _ProcId = procId;
            InitializeComponent();
            CreateViews();
        }

        //public ProcPatternSettingView() {
        //    _Logger = new Logger(typeof(ProcPatternSettingView).Name);
        //    InitializeComponent();
        //}

        ///// <summary>
        /////  초기 생성 후 한번만 설정 해 줄 것
        ///// </summary>
        ///// <param name="subSysInfo"></param>
        ///// <param name="procId"></param>
        //public void InitView(SubSysInfo subSysInfo, string procId) {
        //    _SubSysInfo = subSysInfo;
        //    _SubSysRecipe = VisionRecipeManager.GetSubSysRecipe(_SubSysInfo);
        //    _FovPatternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
        //    _ProcId = procId;
        //    CreateViews();
        //}

        private void CreateViews() {
            gridProcPatterns.Children.Add(CreateProcPatternScrollView());
        }

        private ScrollViewer CreateProcPatternScrollView() {
            var scrollViewer = new ScrollViewer();
            scrollViewer.Visibility = Visibility.Visible;
            scrollViewer.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
            scrollViewer.CanContentScroll = true;
            scrollViewer.Margin = new Thickness(5);

            StackPanel spOtherFov = new StackPanel();
            spOtherFov.Orientation = Orientation.Vertical;

            try {
                foreach (FovRecipe fovRecipe in _SubSysRecipe.FovRecipes) {
                    eFovId fovId = fovRecipe.FovId;

                    StackPanel spSameFov = new StackPanel();
                    spSameFov.Orientation = Orientation.Vertical;

                    if (fovRecipe.PatternRecipe.ProcPatternInfos.Count > 0) {
                        // Align Subsystem의 경우 ProcId를 통해 어떤 Align의 ProcPattern을 가져와야 하는지 파악한다.
                        var alignRecipe = new AlignRecipe();
                        foreach (var recipe in _SubSysRecipe.AlignRecipes) {
                            if (recipe.AlignId.ToString().Equals(_ProcId)) {
                                alignRecipe = recipe;
                            }
                        }
                        foreach (var procPatternInfo in fovRecipe.PatternRecipe.ProcPatternInfos) {
                            if (procPatternInfo.ProcPatternId == eProcPatternId.ProcPattern1 &&
                                procPatternInfo.ProcId.Equals(_ProcId)) {

                                AddNewCb(procPatternInfo, fovId, spSameFov);
                            }
                        }
                        // Align의 종류가 하나의 Fov에서 여러개의 패턴을 가져와야 하는 경우 ProcPattern을 더 가져온다.
                        if (alignRecipe.ProcParams.ProcFovType == eProcFovType.C1_F1_M2R ||
                            alignRecipe.ProcParams.ProcFovType == eProcFovType.C1_F1_AP2_A2 ||
                            _SubSysRecipe.SubSysType == eSubSysType.Inspect) {
                            foreach (var procPatternInfo in fovRecipe.PatternRecipe.ProcPatternInfos) {
                                if (procPatternInfo.ProcPatternId == eProcPatternId.ProcPattern2 &&
                                    procPatternInfo.ProcId.Equals(_ProcId)) {

                                    AddNewCb(procPatternInfo, fovId, spSameFov);
                                }
                            }
                        }
                    }
                    else {
                        PrintRecipeError(fovRecipe, spSameFov);
                    }

                    spOtherFov.Children.Add(spSameFov);
                }
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }

            scrollViewer.Content = spOtherFov;
            return scrollViewer;
        }

        private void AddNewCb(ProcPatternInfo procPatternInfo, eFovId fovId, StackPanel spSameFov) {
            var spSameFovInside = new StackPanel();
            spSameFovInside.Orientation = Orientation.Horizontal;
            spSameFovInside.Margin = new Thickness(5, 3, 5, 3);

            TextBlock tbPatternName = GetPatternName(procPatternInfo.PatternName);
            tbPatternName.TextAlignment = TextAlignment.Left;
            //tbPatternName.Width = 130;
            //tbPatternName.Width = 155;
            spSameFovInside.Children.Add(tbPatternName);

            ComboBox cbPattern = new ComboBox();
            spSameFovInside.Children.Add(cbPattern);

            SetPatternCbInfos(fovId, procPatternInfo, cbPattern);

            spSameFov.Children.Add(spSameFovInside);
        }

        private TextBlock GetPatternName(string patternName) {
            var tbPatternName = new TextBlock();
            tbPatternName.FontSize = 13;
            tbPatternName.Style = FindResource("styleTextBlockSubTitleSmall") as Style;
            tbPatternName.Margin = new Thickness(5, 5, 15, 5);
            tbPatternName.HorizontalAlignment = HorizontalAlignment.Left;
            tbPatternName.Text = patternName;

            return tbPatternName;
        }

        private void SetPatternCbInfos(eFovId fovId, ProcPatternInfo procPatternInfo, ComboBox patternComboBox) {
            var infoKey = new PatternCbInfoKey(fovId, procPatternInfo.ProcPatternId);
            if (!_PatternCbInfos.ContainsKey(infoKey)) {
                _PatternCbInfos.Add(infoKey, new PatternCbInfoValue(procPatternInfo.PatternName, patternComboBox));
            }
        }

        private void InitPatternItemsList() {
            try {
                foreach (var key in _PatternCbInfos.Keys.Select((value, index) => (value, index))) {
                    PatternCbInfoKey infoKey = key.value;
                    var index = key.index;
                    AddComboBoxeItems(infoKey);
                    SelectComboBoxItem(infoKey, index);
                }
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }
        }

        // 콤보박스 항목 추가
        private void AddComboBoxeItems(PatternCbInfoKey infoKey) {
            try {
                ComboBox cb = _PatternCbInfos[infoKey].PatternComboBox;
                cb.Items.Clear();

                var fovInfo = VisionRecipeManager.GetFovInfo(_SubSysInfo.UnitId, _SubSysInfo.SubSysId, infoKey.FovId);
                var fovRecipe = VisionRecipeManager.GetFovRecipe(_SubSysInfo.UnitId, _SubSysInfo.SubSysId, infoKey.FovId);

                var fovPatternInfos = _FovPatternAgent.GetMainPatterns(_SubSysInfo, infoKey.FovId);
                List<PatternIndex> patternIndexes = new List<PatternIndex>();

                for (int i = 0; i < fovPatternInfos.Count; i++) {
                    patternIndexes.Add(new FovPatternIndex(_SubSysInfo, fovRecipe.FovId, fovPatternInfos[i].GetPatternId()));
                    cb.Items.Add(PatternUtil.GetPatternDescription(fovPatternInfos[i]));
                }
                if (VisionSettingManager.VisionSetting.UseCamPattern) {
                    var camPatternAgent = CamPatternAgentManager.GetAgent(fovRecipe.CamRecipe.CamId);
                    if (camPatternAgent != null) {
                        var camPatternInfos = camPatternAgent.GetMainPatterns(fovInfo);

                        for (int i = 0; i < camPatternInfos.Count; i++) {
                            patternIndexes.Add(new CamPatternIndex(fovRecipe.CamRecipe.CamId, camPatternInfos[i].GetPatternId()));
                            cb.Items.Add(PatternUtil.GetPatternDescription(camPatternInfos[i]));
                        }
                    }
                }
                if (!_PatternIndexesAll.ContainsKey(infoKey)) {
                    _PatternIndexesAll.Add(infoKey, patternIndexes);
                }
                else {
                    _PatternIndexesAll[infoKey] = patternIndexes;
                }
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }
        }

        // 콤보박스 항목 선택
        private void SelectComboBoxItem(PatternCbInfoKey infoKey, int index) {
            try {
                var procPatternInfos = _SubSysRecipe.FovRecipes[(int)infoKey.FovId].PatternRecipe.ProcPatternInfos;
                var procPatternInfo = procPatternInfos.Where(p => p.ProcPatternId.Equals(infoKey.ProcPatternId) && p.ProcId.Equals(_ProcId)).FirstOrDefault().Clone();
                var fovPatternInfos = _FovPatternAgent.GetMainPatterns(_SubSysInfo, infoKey.FovId);

                if (VisionSettingManager.VisionSetting.UseCamPattern) {
                    var startIndex = 0;
                    var endIndex = fovPatternInfos.Count;
                    if (!procPatternInfo.IsFovPattern) {
                        startIndex = fovPatternInfos.Count;
                        endIndex = _PatternIndexesAll[infoKey].Count();
                    }

                    for (int i = startIndex; i < endIndex; i++) {
                        if (_PatternIndexesAll[infoKey][i].PatternId == procPatternInfo.PatternId) {
                            _PatternCbInfos[infoKey].PatternComboBox.SelectedIndex = i;
                        }
                    }
                }
                else {
                    for (int i = 0; i < _PatternIndexesAll[infoKey].Count(); i++) {
                        if (_PatternIndexesAll[infoKey][i].PatternId == procPatternInfo.PatternId) {
                            _PatternCbInfos[infoKey].PatternComboBox.SelectedIndex = i;
                        }
                    }
                }
            }
            catch (NullReferenceException e) {
                MessageUtil.ShowErrorToast($"[{_SubSysInfo.SubSysId}][{infoKey.FovId}][{infoKey.ProcPatternId}] Not Found in ProcPatternInfos.");
                _Logger.FuncE(e.Message);
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }
        }

        private void PrintRecipeError(FovRecipe fovRecipe, StackPanel spSameFov) {
            var errMsg = string.Format(StrTokens.RecipeErrorMessage, $"PatternRecipe.ProcPatternInfos of {fovRecipe.FovId}");
            spSameFov.Children.Add(new UCRecipeErrorTextBlock(errMsg) {
                Margin = new Thickness(5),
                HorizontalContentAlignment = HorizontalAlignment.Left
            }); ;
        }

        private void UserControl_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) {
            bool isVisible = (bool)e.NewValue;
            if (isVisible == true) {
                RefreshVisionRecipes();
                InitPatternItemsList();
            }
        }
        /// <summary>
        /// 비전 레시피 Refresh
        /// </summary>
        public void RefreshVisionRecipes() {
            _SubSysRecipe = VisionRecipeManager.GetSubSysRecipe(_SubSysInfo);
        }
        /// <summary>
        /// UI로 부터 레시피 업데이트
        /// </summary>
        public void UpdateRecipeFromUI() {
            try {
                foreach (var key in _PatternCbInfos.Keys.Select((value, index) => (value, index))) {
                    PatternCbInfoKey infoKey = key.value;
                    var patternRecipe = VisionRecipeManager.GetPatternRecipe(_SubSysInfo, infoKey.FovId);
                    var procPatternInfos = patternRecipe.ProcPatternInfos;
                    var procPatternInfo = procPatternInfos.Where(p => p.ProcPatternId.Equals(infoKey.ProcPatternId) && p.ProcId.Equals(_ProcId)).FirstOrDefault();

                    if (_PatternCbInfos[infoKey].PatternName == procPatternInfo.PatternName) {
                        int cbSelectedIdx = _PatternCbInfos[infoKey].PatternComboBox.SelectedIndex;

                        if (!_PatternIndexesAll.ContainsKey(infoKey) || _PatternIndexesAll[infoKey].Count <= cbSelectedIdx) {
                            AddComboBoxeItems(infoKey);
                        }

                        List<PatternIndex> patternIndexes = _PatternIndexesAll[infoKey];
                        PatternIndex patternIndex = patternIndexes[cbSelectedIdx];

                        procPatternInfo.PatternId = patternIndex.PatternId;
                        if (patternIndex is FovPatternIndex) {
                            procPatternInfo.IsFovPattern = true;
                        }
                        else {
                            procPatternInfo.IsFovPattern = false;
                        }
                    }
                }
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }
        }
    }
}