using Aurora.Api;
using VisionCommon;
using VisionSequence.Pattern;
using VisionCommonUI;
using VisionCommonUI.Resources;
using Aurora.View;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Input;
using VisionLight;

#if USE_COGNEX
using CogUI;
#else
using MilUI;
#endif

namespace VisionUI {
    public class PatternListViewModel : NotifyPropertyChangedBase {
        private readonly Logger _logger = new Logger(typeof(PatternListViewModel).Name);

        private SubSysInfo _SubSysInfo;
        private FovInfo _FovInfo;
        private FovRecipe _FovRecipe;
        private eCamId _CamId;

        protected Window _window = null;
        protected PatternAgentBase _PatternAgent = null;
        protected readonly int _PatternCnt;

        public ICameraView CamViewBase { get; set; }

        public ICommand CMD_VisibleChanged { get; }
        public ICommand CMD_GrabFind { get; }
        public ICommand CMD_Find { get; }
        public ICommand CMD_Register { get; }
        public ICommand CMD_Edit { get; }
        public ICommand CMD_Delete { get; }
        public ICommand CMD_Apply { get; }
        public ICommand CMD_Tracking { get; }
        public ICommand CMD_PatternTest { get; }

        public ObservableCollection<PatternInfo> Patterns { get; set; }

        private int _selectedPatternIndex;
        public int SelectedPatternIndex {
            get => _selectedPatternIndex;
            set {
                SetProperty(ref _selectedPatternIndex, value);
                if (SelectedPatternIndex != -1) {
                    IsSelectedPatternRegistered = Patterns[SelectedPatternIndex].IsRegistered();
                }
            }
        }

        private bool _isViewEnabled = true;
        public bool IsViewEnabled { get => _isViewEnabled; set => SetProperty(ref _isViewEnabled, value); }

        private bool _isSelectedPatternRegistered;
        public bool IsSelectedPatternRegistered { get => _isSelectedPatternRegistered; set => SetProperty(ref _isSelectedPatternRegistered, value); }

        private bool _UseCamPattern = false;
        public bool UseCamPattern { get => _UseCamPattern; set => SetProperty(ref _UseCamPattern, value); }

        private bool _isRegistered;
        public bool IsRegistered { get => _isRegistered; set => SetProperty(ref _isRegistered, value); }

        public PatternListViewModel(
            FovInfo fovInfo, CameraView cameraView) {
            _SubSysInfo = fovInfo.ToSubSysInfo();
            _FovInfo = fovInfo;
            _FovRecipe = VisionRecipeManager.GetFovRecipe(fovInfo);
            _CamId = VisionRecipeManager.GetCamRecipe(fovInfo).CamId;

            _PatternCnt = PatternConstants.FOV_PATTERN_COUNT;
            UseCamPattern = VisionSettingManager.VisionSetting.UseCamPattern;

            CMD_VisibleChanged = new DelegateCommand(VisibleChanged);
            CMD_GrabFind = new DelegateCommand(GrabFind);
            CMD_Find = new DelegateCommand(Find);
            CMD_Register = new DelegateCommand(Register);
            CMD_Edit = new DelegateCommand(Edit);
            CMD_Delete = new DelegateCommand(Delete);
            CMD_Apply = new DelegateCommand(Apply);
            CMD_Tracking = new DelegateCommand(Tracking);
            CMD_PatternTest = new DelegateCommand(PatternTest);

            var unitInfo = VisionRecipeManager.GetUnitInfo(_FovInfo.UnitId);

            CamViewBase = cameraView;
            _PatternAgent = PatternAgentManager.GetAgent(fovInfo);

            InitPatternList(0);
        }

        private void ResetPatternAgent() {
            _PatternAgent = PatternAgentManager.GetAgent(_FovInfo);
        }

        public PatternInfo CreateDefaultPatternInfo(int patternId) {
            return new PatternInfo() {
                PatternIndex = new PatternIndex(_FovInfo, _FovRecipe.FovName, patternId),
                PatternType = ePatternType.None,
                MilSystemId = _PatternAgent.GetMilSystemId(_FovRecipe.CamRecipe.CamId),
                LightInfo = GetDefaultLightInfo()
            };
        }

        public LightInfo GetDefaultLightInfo() {
            var lightParams = LightHub.Instance.GetLightParams(_FovRecipe.CamRecipe.CamId);
            return new LightInfo() { LightParams = lightParams };
        }

        public void InitPatternList(int initIndex) {
            try {
                Application.Current.Dispatcher.Invoke(
                    new Action(() => {
                        if (Patterns == null) {
                            Patterns = new ObservableCollection<PatternInfo>();
                        }
                        Patterns.Clear();
                        //_window = new Window();

                        var existingPatterns = GetExistingPatterns();
                        var existingPatternKeys = existingPatterns.Select(ep => ep.GetPatternId()).ToList();

                        for (int i = 0; i < _PatternCnt; i++) {
                            if (existingPatternKeys.Contains(i)) {
                                Patterns.Add(existingPatterns.FirstOrDefault(ep => i == ep.GetPatternId()));

                                var curPatternInfo = Patterns[Patterns.Count - 1];
                                curPatternInfo.Thumbnail = _PatternAgent.GetThumbnail(curPatternInfo);
                            }
                            else {
                                Patterns.Add(CreateDefaultPatternInfo(i));
                            }
                        }

                        SelectedPatternIndex = initIndex;
                    }));
            }
            catch (Exception e) {
                _logger.FuncE(e.Message);
            }
        }

        public List<PatternInfo> GetExistingPatterns() {
            if (_PatternAgent == null) {
                ResetPatternAgent();
            }
            if (VisionSettingManager.VisionSetting.UseCamPattern) {
                // CamPattern을 사용하는 경우에는 Pattern Agent들마다 동기화를 해줘야 하므로 패턴을 다시 불러온다.
                _PatternAgent.LoadPatterns();
            }
            return _PatternAgent.GetMainPatterns(CreateDefaultPatternInfo(0));
        }

        private void VisibleChanged(object obj) {
            bool isVisible = (bool)obj;

            if (isVisible) {
                InitPatternList(0);
                NotifyPropertyChanged("Patterns");
            }
            else {
                _window?.Close();
            }
        }

        public void GrabFind(object obj) {
            var cameraAgent = CameraAgentManager.GetCameraAgent(_FovInfo);
            if (cameraAgent.IsLiveRunning()) {
                cameraAgent.StopLive();
            }

            _logger.FuncI($"SelectedPatternIndex : {SelectedPatternIndex}");

            if (0 <= SelectedPatternIndex) {
                var patternInfo = Patterns[SelectedPatternIndex];
                if (IsFindSupported(patternInfo.PatternType)) {
                    StartGrabFindSeq(patternInfo);
                }
                else {
                    MessageBoxUtil.ShowMessageBoxError(
                        string.Format(StrTokens.MSG_E_PatternFindingNotSupported, patternInfo.PatternType));
                }
            }
        }

        private bool IsFindSupported(ePatternType patternType) {
            return patternType != ePatternType.EdgeFinder;
        }

        public void Find(object obj) {
            if (0 <= SelectedPatternIndex) {
                var patternInfo = Patterns[SelectedPatternIndex];
                if (IsFindSupported(patternInfo.PatternType)) {
                    StartFindSeq(patternInfo);
                }
                else {
                    MessageBoxUtil.ShowMessageBoxError(
                        string.Format(StrTokens.MSG_E_PatternFindingNotSupported, patternInfo.PatternType));
                }
            }
        }

        private void Register(object obj) {
            _logger.FuncI($"SelectedPatternIndex : {SelectedPatternIndex}");

            var param = new Tuple<PatternAgentBase, PatternInfo, Window, PatternListViewModel, int>(
                _PatternAgent, Patterns[SelectedPatternIndex].Clone() as PatternInfo, _window, this, SelectedPatternIndex);
            VisionEnv.AuroraEnv.EventPublisher.Publish(
                new EventMessage(string.Empty, VisionEventId.SHOW_REGISTER_PATTERN_WINDOW, param));
        }

        public void ResetWindow() {
            if (_window.WindowState == WindowState.Minimized) {
                _window.WindowState = WindowState.Normal;
            }
            if(_window is IPatternSettingWindow) {
                (_window as IPatternSettingWindow).ResetPosition();
            }
            else if(_window is VisionImageTestWindow) {
                (_window as VisionImageTestWindow).ResetPosition();
            }
        }

        private void Edit(object obj) {
            _logger.FuncI($"SelectedPatternIndex : {SelectedPatternIndex}");

            var param = new Tuple<PatternAgentBase, PatternInfo, ICameraDisplay, FovInfo, Window, PatternListViewModel, int>(
                _PatternAgent, Patterns[SelectedPatternIndex].Clone() as PatternInfo, CamViewBase.GetDisplay(), _FovInfo, _window, this, SelectedPatternIndex);
            VisionEnv.AuroraEnv.EventPublisher.Publish(
                new EventMessage(string.Empty, VisionEventId.SHOW_PATTERN_SETTING_WINDOW, param));
        }

        private void Delete(object obj) {
            _logger.FuncI($"SelectedPatternIndex : {SelectedPatternIndex}");

            if (Patterns[SelectedPatternIndex].PatternType == ePatternType.LineFinder) {
                foreach (var patternInfo in Patterns) {
                    if(patternInfo.PatternType == ePatternType.LineIntersection || patternInfo.PatternType == ePatternType.LineWidth) {
                        if(!_PatternAgent.IsDeletable(patternInfo, SelectedPatternIndex)) {
                            MessageBoxUtil.ShowMessageBoxError(
                                string.Format(StrTokens.MSG_E_NotDeletablePattern, patternInfo.GetPatternId()));
                            return;
                        }
                    }
                }
            }

            var lastSelectedPatternIndex = SelectedPatternIndex;
            var result = MessageBoxUtil.ShowMessageBoxQuestion(
                string.Format(StrTokens.MSG_Q_DeletePatternFormat, SelectedPatternIndex));
            if (result == MessageBoxResult.Yes) {
                Application.Current.Dispatcher.Invoke(() => {
                    DeleteSubPatterns(Patterns[SelectedPatternIndex]);
                    DeleteMainPattern(Patterns[SelectedPatternIndex]);
                    Patterns[SelectedPatternIndex] = CreateDefaultPatternInfo(SelectedPatternIndex);
                    InitPatternList(lastSelectedPatternIndex);
                });
            }
        }

        private void DeleteSubPatterns(PatternInfo patternInfo) {
            var subPatternList = _PatternAgent.GetSubPatterns(patternInfo);
            foreach (var subPatternInfo in subPatternList) {
                _PatternAgent.Remove(subPatternInfo);
            }
        }
        private void DeleteMainPattern(PatternInfo patternInfo) {
            _PatternAgent.Remove(patternInfo);
        }

        private void Apply(object obj) {
            _logger.FuncI($"SelectedPatternIndex : {SelectedPatternIndex}");

            var patternRecipe = VisionRecipeManager.GetPatternRecipe(_SubSysInfo, _FovInfo.FovId);
            var options = new string[(int)eProcPatternId.Max];

            for (int i = 0; i < patternRecipe.ProcPatternInfos.Count; i++) {
                options[i] = patternRecipe.ProcPatternInfos[i].ProcPatternId.ToString();
            }

            var msgResult = MessageBoxUtil.ShowMessageBoxQuestionOption(
                string.Format(StrTokens.MSG_Q_ApplyPatternAsProcessPatternFormat, SelectedPatternIndex),
                StrTokens.MSG_I_SelectProcessPatternId,
                options);

            if (msgResult.Result == MessageBoxResult.Yes) {
                Application.Current.Dispatcher.Invoke(() => {
                    var patternInfo = Patterns[SelectedPatternIndex];
                    var procPatternId = (eProcPatternId)msgResult.SelIndex;
                    var procPatternInfo = patternRecipe.ProcPatternInfos.Where(p => p.ProcPatternId.Equals(procPatternId)).FirstOrDefault();

                    if (procPatternInfo == null) {
                        _logger.FuncE("procPatternInfo is null.");
                    }

                    procPatternInfo.PatternId = patternInfo.GetPatternId();
                    procPatternInfo.ProcPatternId = procPatternId;
                    RecipeFileManager.SaveVisionRecipe();
                });
            }
        }

        private void Tracking(object obj) {
            var window = new PatternTrackingSettingWindow(_FovInfo);
            window?.Show();
        }

        public void StartGrabFindSeq(PatternInfo patternInfo) {
            var manualFixtureProcSeq = ManualGrabFindSeqManager.GetSeq(_FovInfo);

            if (manualFixtureProcSeq == null) {
                _logger.FuncE("manualFixtureProcSeq is null.");
            }
            else if (manualFixtureProcSeq.RunState == SequenceRunState.Running) {
                _logger.FuncE("manualFixtureProcSeq is running.");
            }
            else if (manualFixtureProcSeq.RunState == SequenceRunState.Idle) {
                GrabFindSeqUtil.Clear(_SubSysInfo);

                var fixtureSeqParam = new GrabFindProcSeqParams(
                    _FovInfo, patternInfo, eDisplayType.Pattern, seqMode: eSeqMode.Manual);
                manualFixtureProcSeq.Start(fixtureSeqParam);
            }
            else {
                _logger.FuncE("manualFixtureProcSeq is not idle.");
            }
        }

        public void StartFindSeq(PatternInfo patternInfo) {
            var manualFindSeq = VisionEnv.AuroraEnv.SequenceEntry[VisionKeys.ManualFindSeqKey];
            if (manualFindSeq != null && manualFindSeq.RunState == SequenceRunState.Idle) {

                var cameraDisplay = (CamViewBase as CameraView).GetDisplay() as CameraDisplay;
                cameraDisplay.ClearMeasureGraphics();

                var image = cameraDisplay.GetImage();
                if (image == null) {
                    MessageBoxUtil.ShowMessageBoxError(StrTokens.MSG_E_ImageNotReady);
                    return;
                }

                var findSeqParam = new FindSeqParams(
                    image, _FovInfo, patternInfo, eDisplayType.Pattern, seqMode: eSeqMode.Manual);
                manualFindSeq.Start(findSeqParam);
            }
        }

        public void PatternTest(object obj) {
            if (_window != null) {
                _window.Close();
            }
            IsViewEnabled = false;
            _window = new VisionImageTestWindow(_FovInfo, eVisionTestType.Pattern, Patterns[SelectedPatternIndex].Clone() as PatternInfo, this);
            (_window as VisionImageTestWindow).ResetPosition();
            _window.Show();
        }
    }
}