/*
  * Copyright (c) 2025 LG Electronics Inc.
   * SPDX-License-Identifier: LicenseRef-LGE-Proprietary
   */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Input;
using Aurora.Api;
using Aurora.Api.DataType;
using Aurora.View;
using CogCommon;
using VisionCommon;
using Hermes;
using CogPattern;
using VisionCommonUI;
using Cognex.VisionPro.PMAlign;
using VisionCommonUI.Resources;

namespace CogUI {
    public class ImageModelSettingViewModel : NotifyPropertyChangedBase, IGraEventSubscriber {
        private Logger _logger = new Logger("ImageModelSettingVM");

        public ICommand CMD_VisibleChanged { get; }
        public ICommand CMD_CreateSubPatternWithMask { get; }
        public ICommand CMD_Copy { get; }
        public ICommand CMD_Create { get; }
        public ICommand CMD_Save { get; }
        public ICommand CMD_Cancel { get; }
        public ICommand CMD_Delete { get; }
        public ICommand CMD_SetLight { get; }
        public ICommand CMD_SetPreProc { get; }
        public ICommand CMD_SetTrainROI { get; }
        public ICommand CMD_TrainPattern { get; }
        public ICommand CMD_SetMask { get; }
        public ICommand CMD_SetFindROI { get; }
        public ICommand CMD_FindPattern { get; }
        public ICommand CMD_SyncTrainOrigin { get; }

        public bool IsSubPattern { get; set; }

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

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

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

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

        private PatternInfo _patternInfo;
        public PatternInfo PatternInfo { get => _patternInfo; set => SetProperty(ref _patternInfo, value); }

        private ImageModelFinderTrainParam _trainParam;
        public ImageModelFinderTrainParam TrainParam { get => _trainParam; set => SetProperty(ref _trainParam, value); }

        private ModelFinderRunParam _runParam;
        public ModelFinderRunParam RunParam { get => _runParam; set => SetProperty(ref _runParam, value); }

        private IEnumerable<int> _fixturePatterns;
        public IEnumerable<int> FixturePatterns { get => _fixturePatterns; set => SetProperty(ref _fixturePatterns, value); }

        public IEnumerable<eIgnorePolarity> IgnorePolarityItems { get; } = Enum.GetValues(typeof(eIgnorePolarity)).Cast<eIgnorePolarity>();

        private PatternAgentBase _patternAgent;
        private CameraDisplay _cameraDisplay;
        private FovInfo _fovInfo;
        private Window _childWindow = null;

        public ImageModelSettingViewModel(
            PatternAgentBase patternAgent, PatternInfo patternInfo, CameraDisplay cameraDisplay, FovInfo fovInfo) {
            _patternAgent = patternAgent;
            _patternInfo = patternInfo;
            _cameraDisplay = cameraDisplay;
            _fovInfo = fovInfo;
            IsSubPattern = PatternConstants.IsSubPattern(_patternInfo.GetPatternIndex());

            CMD_VisibleChanged = new DelegateCommand(VisibleChanged);
            CMD_CreateSubPatternWithMask = new DelegateCommand(CreateSubPatternWithMask);
            CMD_Copy = new DelegateCommand(Copy);
            CMD_Create = new DelegateCommand(Create);
            CMD_Save = new DelegateCommand(Save);
            CMD_Cancel = new DelegateCommand(Cancel);
            CMD_Delete = new DelegateCommand(Delete);

            CMD_SetLight = new DelegateCommand(SetLight);
            CMD_SetPreProc = new DelegateCommand(SetPreProc);
            CMD_SetTrainROI = new DelegateCommand(SetTrainROI);
            CMD_TrainPattern = new DelegateCommand(TrainPattern);
            CMD_SetMask = new DelegateCommand(SetMask);
            CMD_SetFindROI = new DelegateCommand(SetFindROI);
            CMD_FindPattern = new DelegateCommand(FindPattern);
            CMD_SyncTrainOrigin = new DelegateCommand(SyncTrainOrigin);

            Update();
            _cameraDisplay.SetGraEventSubscriber(_patternInfo, this);
        }

        private void Update() {
            InitRegistered();
            InitRunParam();
            InitFixturePatterns();
            UpdateControlButtons(IsPatternRegistered);
        }

        public void InitRegistered() {
            IsPatternRegistered = _patternAgent.IsPatternExist(_patternInfo.GetPatternIndex());
        }

        public void InitRunParam() {
            if (_patternAgent.IsPatternExist(_patternInfo.GetPatternIndex())) {
                RunParam = _patternAgent.GetRunParam(_patternInfo) as ModelFinderRunParam;
            }
            else {
                RunParam = new ModelFinderRunParam();
            }
        }

        public void InitFixturePatterns() {
            FixturePatterns = _patternAgent.GetFixturePatternIndexListForFov(_patternInfo);
        }

        private void UpdateControlButtons(bool isPatternRegistered) {
            IsPatternRegistered = isPatternRegistered;
            IsSubPatternRegistered = IsSubPattern && isPatternRegistered;
            IsSubPatternNotRegistered = IsSubPattern && !isPatternRegistered;
            InitIsMainPatternTrained();
        }

        public void InitIsMainPatternTrained() {
            if (IsSubPattern) {
                IsMainPatternTrained = false;
                return;
            }

            var patternTrain = _patternAgent.GetPattern(_patternInfo.GetPatternIndex()) as IPatternTrain;
            if (patternTrain != null && patternTrain.IsTrained()) {
                IsMainPatternTrained = true;
            }
        }

        private void VisibleChanged(object obj) {
            bool visible = (bool)obj;
            if (visible) {
                Update();
            }
            else {
                CloseChildWindow();
                ClosingWindow();
            }
        }

        private void CreateSubPatternWithMask(object obj) {
            if (_childWindow == null) {
                _childWindow = new SubMaskViewWindow(_patternAgent, _patternInfo);
                (_childWindow as IPatternSettingWindow).ResetPosition();
                _childWindow.Closed += OnWindowClosed;
                _childWindow.Owner = Application.Current.MainWindow;
                _childWindow.Show();
            }
            else {
                ResetWindow();
            }
        }

        private void Copy(object obj) {
            var result = MessageBoxUtil.ShowMessageBoxQuestion(StrTokens.MSG_Q_CopyPatternZero);
            if (result == MessageBoxResult.Yes) {
                var mainPatternInfo = _patternAgent.GetMainPatternInfo(_patternInfo.GetPatternIndex());
                if (E1.OK == _patternAgent.CopyPattern(mainPatternInfo.GetPatternIndex(), _patternInfo.GetPatternIndex())) {
                    InitRunParam();
                    InitFixturePatterns();
                    UpdateControlButtons(true);
                    MessageBoxUtil.ShowMessageBoxOk(StrTokens.MSG_O_CopyCompleted);
                }
            }
        }

        private void Create(object obj) {
            if (!_patternAgent.IsPatternExist(_patternInfo.GetPatternIndex())) {
                if (E1.OK == _patternAgent.Create(_patternInfo) &&
                    E1.OK == _patternAgent.Save(_patternInfo)) {
                    InitRunParam();
                    InitFixturePatterns();
                    UpdateControlButtons(true);
                    MessageBoxUtil.ShowMessageBoxOk(StrTokens.MSG_O_RegisterCompleted);
                }
            }
        }

        private void Save(object obj) {
            if (_cameraDisplay.HasFindRoi()) {
                RunParam.FindROI = _cameraDisplay.GetFindRoi().Clone() as ROI;
            }
            _patternAgent.SetRunParam(_patternInfo, RunParam);
            _patternAgent.Save(_patternInfo);
            InitIsMainPatternTrained();
            MessageBoxUtil.ShowMessageBoxOk(StrTokens.MSG_O_SaveCompleted);
        }

        private void Cancel(object obj) {
            CloseChildWindow();
            ClosingWindow();
            CloseWindow(obj);
        }

        private void Delete(object obj) {
            var result = MessageBoxUtil.ShowMessageBoxQuestion(StrTokens.MSG_Q_Delete);
            if (result == MessageBoxResult.Yes) {
                if (_patternAgent.IsPatternExist(_patternInfo.GetPatternIndex())) {
                    if (E1.OK == _patternAgent.Remove(_patternInfo)) {
                        UpdateControlButtons(false);
                    }
                }
            }
        }

        private void ClosingWindow() {
            _cameraDisplay.ClearTrainGraphics();
            _cameraDisplay.ClearFindGraphics();
        }

        private void CloseWindow(object obj) {
            var window = obj as Window;
            if (window != null) {
                window.Close();
            }
        }

        private void CloseChildWindow() {
            if (_childWindow != null) {
                _childWindow.Close();
            }
        }

        private void SetLight(object obj) {
            PatternLightWindowManager.ShowLightSettingWindow(_fovInfo, _patternInfo);
        }

        private void SetPreProc(object obj) {
            if (_childWindow == null) {
                _childWindow = new PreProcessingWindow(_patternInfo, _cameraDisplay);
                (_childWindow as IPatternSettingWindow).ResetPosition();
                _childWindow.Closed += OnWindowClosed;
                _childWindow.Owner = Application.Current.MainWindow;
                _childWindow.Show();
            }
            else {
                ResetWindow();
            }
        }

        public void UpdateAngleOfTrainRoi(double roiAngle) {
            _cameraDisplay.UpdateAngleOfTrainRoi(roiAngle);
        }

        private void SetTrainROI(object obj) {
            _cameraDisplay.SetPatternInfo(_patternInfo);
            var cogImage = _cameraDisplay.GetImage();
            if (cogImage != null) {
                var curPattern = _patternAgent.GetPattern(_patternInfo) as IPatternTrain;
                TrainParam = curPattern.GetTrainParam() as ImageModelFinderTrainParam;

                _cameraDisplay.ClearTrainGraphics();
                var imageCenter = CogEnvironment.GetImageCenter(cogImage);
                if (ROI.IsNullOrEmpty(TrainParam.TrainRoi) || TrainParam.TrainOrigin is null) {
                    _cameraDisplay.AddTrainRoi(imageCenter, true);
                    _cameraDisplay.AddTrainOrigin(new Cross(imageCenter));
                }
                else {
                    _cameraDisplay.AddTrainRoi(TrainParam.TrainRoi, true);
                    _cameraDisplay.AddTrainOrigin(TrainParam.TrainOrigin);
                }
            }
        }

        private void TrainPattern(object obj) {
            if (_cameraDisplay != null) {
                var trainRoi = _cameraDisplay.GetTrainRoi();
                if (ROI.IsNullOrEmpty(trainRoi)) {
                    MessageBoxUtil.ShowMessageBoxError(StrTokens.MSG_E_TrainRoiNotSet);
                    return;
                }

                var result = MessageBoxUtil.ShowMessageBoxQuestion(StrTokens.MSG_Q_ContinuToTrainPattern);
                if (result == MessageBoxResult.Yes) {
                    var trainOrigin = _cameraDisplay.GetTrainOrigin();
                    var image = _cameraDisplay.GetImage();

                    _cameraDisplay.ClearTrainGraphics();
                    _patternAgent.Train(
                        _patternInfo,
                        new ImageModelFinderTrainParam() {
                            TrainImage = image,
                            TrainRoi = trainRoi.Clone() as ROI,
                            TrainOrigin = trainOrigin.Clone() as Cross
                        });

                    _cameraDisplay.DrawTrainEdge(_patternAgent, _patternInfo);
                    MessageBoxUtil.ShowMessageBoxOk(StrTokens.MSG_O_TrainCompleted);
                }
            }
        }

        private void SetMask(object obj) {
            if (_childWindow == null) {
                var curPattern = _patternAgent.GetPattern(_patternInfo) as IPatternTrain;
                if (curPattern != null && curPattern.IsTrained()) {
                    _childWindow = new ImageMaskViewWindow(_patternAgent, _patternInfo, _cameraDisplay);
                    (_childWindow as IPatternSettingWindow).ResetPosition();
                    _childWindow.Closed += OnWindowClosed;
                    _childWindow.Owner = Application.Current.MainWindow;
                    _childWindow.Show();
                }
                else {
                    MessageBoxUtil.ShowMessageBoxError(StrTokens.MSG_E_PatternNotTrained);
                }
            }
            else {
                ResetWindow();
            }
        }

        private void ResetWindow() {
            if (_childWindow.WindowState == WindowState.Minimized) {
                _childWindow.WindowState = WindowState.Normal;
            }

            (_childWindow as IPatternSettingWindow).ResetPosition();
        }

        private void OnWindowClosed(object sender, EventArgs e) {
            _childWindow = null;
        }

        private void SetFindROI(object obj) {
            var cogImage = _cameraDisplay.GetImage();
            if (cogImage != null) {
                var imageSize = CogEnvironment.GetImageSize(cogImage);
                var findRoi = GetFindROIFromRunParam(imageSize, RunParam);
                _cameraDisplay.AddFindRoi(findRoi);
            }
        }

        private ROI GetFindROIFromRunParam(ImageSize imageSize, ModelFinderRunParam runParam) {
            if ((0 < runParam.FindROI.Width && runParam.FindROI.Width < imageSize.Width) &&
                (0 < runParam.FindROI.Height && runParam.FindROI.Height < imageSize.Height)) {
                return runParam.FindROI.Clone() as ROI;
            }

            return RoiUtil.GetDefaultFindRoi(imageSize);
        }

        private void FindPattern(object obj) {
            if (!_patternInfo.IsActivated) {
                MessageBoxUtil.ShowMessageBoxError(StrTokens.MSG_E_PatternNotActivated);
                return;
            }

            if (_cameraDisplay != null) {
                var image = _cameraDisplay.GetImage();
                if (image == null) {
                    MessageBoxUtil.ShowMessageBoxError(StrTokens.MSG_E_ImageNotReady);
                    return;
                }
                if (_cameraDisplay.HasFindRoi()) {
                    RunParam.FindROI = _cameraDisplay.GetFindRoi().Clone() as ROI;
                }

                _cameraDisplay.ClearTrainGraphics();
                _cameraDisplay.ClearFindGraphics(eGraphicToClear.STATIC);
                _cameraDisplay.ClearMeasureGraphics();

                _patternAgent.SetRunParam(_patternInfo, RunParam);
                var patternResult = _patternAgent.Find(_patternInfo, image);
                _patternAgent.Draw(_patternInfo, patternResult, _cameraDisplay);

                if (patternResult.Status == eFoundStatus.NotFound) {
                    MessageBoxUtil.ShowMessageBoxError(StrTokens.MSG_E_PatternNotFound);
                }
            }
        }

        private void SyncTrainOrigin(object obj) {
            if (_childWindow == null) {
                if (_patternAgent.HasSubPattern(_patternInfo)) {
                    _childWindow = new TrainOriginSyncWindow(_patternAgent, _patternInfo, _cameraDisplay);
                    (_childWindow as IPatternSettingWindow).ResetPosition();
                    _childWindow.Closed += OnWindowClosed;
                    _childWindow.Owner = Application.Current.MainWindow;
                    _childWindow.Show();
                }
                else {
                    MessageBoxUtil.ShowMessageBoxError(StrTokens.MSG_E_NoSubPatterns);
                }
            }
            else {
                ResetWindow();
            }
        }

        public void UpdateAngleOfRoi(eGraRoiType graRoiType, object param) {
            if (graRoiType == eGraRoiType.TrainRoi) {
                TrainParam.TrainRoi.Angle.Degree = Math.Round((double)param, 1);
                NotifyPropertyChanged(nameof(TrainParam));
            }
        }

        public void UpdateRadiusOfRoi(eGraRoiType graRoiType, double radius) {
        }
    }
}