using Aurora.Api;
using VisionCommon;
using Matrox.MatroxImagingLibrary;
using System;
using System.Windows;
using System.Windows.Controls;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using MilCommon;
using Aurora.Api.DataType;

namespace MilUI {
    /// <summary>
    /// Interaction logic for ForceOkView.xaml
    /// </summary>
    public partial class ForceOkView : UserControl, INotifyPropertyChanged, IDisposable {
        protected Window _PatternSettingWindow = null;

        public event PropertyChangedEventHandler PropertyChanged;
        protected bool SetProperty<S>(
            ref S storage,
            S value,
            [CallerMemberName] string propertyName = null) {
            if (Equals(storage, value))
                return false;
            storage = value;
            OnPropertyChanged(propertyName);
            return true;
        }

        protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
            => PropertyChanged?.Invoke(
                this,
                new PropertyChangedEventArgs(propertyName));

        public Window ParentWindow { get; set; }
        public PatternInfo PatternInfo { get; set; }

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

        private ImagePoint _forceOkPoint = new ImagePoint();
        public ImagePoint ForceOkPoint { get => _forceOkPoint; set => SetProperty(ref _forceOkPoint, value); }

        public PatternResult NewFindResult { get; set; }

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

        public bool IsApply { get; set; } = false;

        private Logger _logger = new Logger("ForceOkView");
        private FovInfo _fovInfo;
        private PatternAgentBase _patternAgent;
        private CameraAgentBase _CameraAgent;
        private CameraView _cameraView;
        private CameraDisplay _cameraDisplay;
        private MIL_ID _displayId = MIL.M_NULL;
        private MIL_ID _findImageId = MIL.M_NULL;
        private MIL_ID _graphicContext = MIL.M_NULL;
        private MIL_ID _graphicList = MIL.M_NULL;
        private MIL_ID _trainOriginLabel = MIL.M_NULL;
        private MIL_ID COLOR_FORCE_OK_POINT = MIL.M_COLOR_RED;
        private MilGraphics _milGraphics;
        private int _crossLength = 100;
        private const double ZOOM_STEP = 0.1;
        private Angle _forceOkAngle = Angle.CreateWithDegree(0);

        public ForceOkView(FovInfo fovInfo, PatternInfo patternInfo, object findImage) {
            InitializeComponent();

            _fovInfo = fovInfo;
            PatternInfo = patternInfo;

            SetForceOkEnabled();
            SetCameraView();
            SetDisplay();
            SetCameraAgent();
            SetPatternAgent();
            LoadFindlImageToDisplay((MIL_ID)findImage);

            if (_isForceOkEnabled) {
                LoadTrainOrigin();
                IsApplyButtonEnabled = true;
                SetDisplayMode();
            }

            DataContext = this;
        }

        private void SetForceOkEnabled() {
            _isForceOkEnabled = VisionRecipeManager.IsForceOkEnaled(_fovInfo.ToSubSysInfo(), eAlignId.Align1);
        }

        private void SetCameraView() {
            _cameraView = new CameraView(_fovInfo, eDisplayType.ForceOk);
            gridCameraView.Children.Add(_cameraView);
            _cameraDisplay = _cameraView.GetDisplay();
        }

        private void SetDisplay() {
            _displayId = _cameraDisplay.GetMilDisplayId();
            _graphicContext = _cameraDisplay.GetGraphicContextId();
            _graphicList = _cameraDisplay.GetGraphicListId();
            _milGraphics = new MilGraphics(_displayId, _graphicList);
        }

        public ICameraDisplay GetDisplay() {
            return _cameraDisplay;
        }

        private void SetCameraAgent() {
            _CameraAgent = CameraAgentManager.GetCameraAgent(_fovInfo);
        }

        private void SetPatternAgent() {
            if (PatternInfo is FovPatternInfo) {
                _patternAgent = FovPatternAgentManager.GetAgent(_fovInfo.ToSubSysInfo());
            }
            else {
                _patternAgent = CamPatternAgentManager.GetAgent(VisionRecipeManager.GetFovRecipe(_fovInfo).CamRecipe.CamId);
            }
        }

        public void Dispose() {
            _PatternSettingWindow?.Close();

            if (_isForceOkEnabled) {
                ResetDisplayMode();
            }

            MIL.MbufFree(_findImageId);
            _cameraView.Dispose();
        }

        private void LoadFindlImageToDisplay(MIL_ID findImage) {
            MilEnvironment.FreeImage(_findImageId);
            _findImageId = MilEnvironment.CloneImage(findImage);
            _cameraView.SetImage(_findImageId);
        }

        private void LoadTrainOrigin() {
            if (_isForceOkEnabled && _patternAgent.IsTrainPattern(PatternInfo)) {
                var trainParam = _patternAgent.GetTrainParam(PatternInfo) as ImageTrainParam;
                _crossLength = (int)(trainParam.TrainRoi.Width * 0.5);
                ForceOkPoint = trainParam.TrainOrigin.Origin.Clone() as ImagePoint;
            }
            else {
                MIL_ID imageId = _cameraDisplay.GetImage();
                ForceOkPoint = MilEnvironment.GetImageCenter(imageId);
            }

            SetForceOkPoint(ForceOkPoint);
        }

        private void SetDisplayMode() {
            var forceOkMode = new ForceOkMode();
            forceOkMode.SetForceOkPoint = SetForceOkPoint;

            VisionEnv.AuroraEnv.EventPublisher.Publish(
                    new EventMessage(
                        _fovInfo.FovName,
                        DiplayModeEvent.On,
                        new DisplayModeParam(
                            eDisplayType.ForceOk,
                            forceOkMode)));
        }

        private void ResetDisplayMode() {
            VisionEnv.AuroraEnv.EventPublisher.Publish(
                    new EventMessage(
                        _fovInfo.FovName,
                        DiplayModeEvent.Off,
                        new DisplayModeParam(
                            eDisplayType.ForceOk,
                            null)));
        }

        private void ZoomMinus_Button_Click(object sender, RoutedEventArgs e) {
            _cameraDisplay.SetRelativeImageZoom(ZOOM_STEP * (-1));
        }

        private void FitImage_Button_Click(object sender, RoutedEventArgs e) {
            _cameraDisplay.FitImage(MilEnvironment.GetImageSize(_findImageId));
        }

        private void ZoomPlus_Button_Click(object sender, RoutedEventArgs e) {
            _cameraDisplay.SetRelativeImageZoom(ZOOM_STEP);
        }

        private void Edit_Button_Click(object sender, RoutedEventArgs e) {
            _cameraDisplay.ClearAllGraphics();

            if (_PatternSettingWindow == null) {
                _patternAgent.ReloadPattern(PatternInfo);
                _PatternSettingWindow = PatternViewUtil.CreatePatternSettingWindow(
                    _patternAgent, _patternAgent.GetMainPatternInfo(PatternInfo), _cameraDisplay, _fovInfo);

                if (_PatternSettingWindow != null) {
                    (_PatternSettingWindow as IPatternSettingWindow).ResetPosition();
                    _PatternSettingWindow.Closed += OnWindowClosed;
                    _PatternSettingWindow.Show();
                }
            }
            else {
                if (_PatternSettingWindow.WindowState == WindowState.Minimized) {
                    _PatternSettingWindow.WindowState = WindowState.Normal;
                }
                (_PatternSettingWindow as IPatternSettingWindow).ResetPosition();
            }
        }

        private void OnWindowClosed(object sender, EventArgs e) {
            _cameraDisplay.ClearMeasureGraphics();
            _PatternSettingWindow = null;
        }

        private void Grab_Button_Click(object sender, RoutedEventArgs e) {
            var image = (object)_findImageId;
            _CameraAgent.GrabSync(_cameraDisplay, ref image);
            _findImageId = (MIL_ID)image;
        }

        private void Find_Button_Click(object sender, RoutedEventArgs e) {
            var patternResult = _patternAgent.Find(PatternInfo, _cameraDisplay.GetImage(), _cameraDisplay);
            NewFindResult = patternResult;

            if (patternResult.Status == eFoundStatus.FoundOK) {
                if (patternResult.Results != null) {
                    foreach (var result in patternResult.Results) {
                        ForceOkPoint = result.ImagePosition;
                        break;
                    }
                }
                IsApplyButtonEnabled = true;
                _milGraphics.Remove(_trainOriginLabel);
            }
            else {
                if (_isForceOkEnabled) {
                    Move(new ImagePoint(0, 0));
                }
                else {
                    IsApplyButtonEnabled = false;
                }
            }
            _cameraDisplay.ClearMeasureGraphics();
            _patternAgent.Draw(PatternInfo, patternResult, _cameraDisplay);
        }

        private void Apply_Button_Click(object sender, RoutedEventArgs e) {
            IsApply = true;
            ParentWindow?.Close();
        }

        private void Cancel_Button_Click(object sender, RoutedEventArgs e) {
            IsApply = false;
            ParentWindow?.Close();
        }

        private void Move_Left_Up_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(
                GetMoveStep() * (-1),
                GetMoveStep() * (-1)));
        }

        private void Move_Right_Up_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(
                GetMoveStep(),
                GetMoveStep() * (-1)));
        }

        private void Move_Up_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(
                0,
                GetMoveStep() * (-1)));
        }

        private void Move_Left_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(
                GetMoveStep() * (-1),
                0));
        }

        private void Move_Right_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(
                GetMoveStep(),
                0));
        }

        private void Move_Left_Down_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(
                GetMoveStep() * (-1),
                GetMoveStep()));
        }

        private void Move_Down_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(0, GetMoveStep()));
        }

        private void Move_Right_Down_Button_Click(object sender, RoutedEventArgs e) {
            Move(new ImagePoint(
                GetMoveStep(),
                GetMoveStep()));
        }

        private void Rotate_Clock_Wise_Button_Click(object sender, RoutedEventArgs e) {
            Rotate(_forceOkAngle + Angle.CreateWithDegree(GetMoveStep()));
        }

        private void Rotate_Counter_Clock_Wise_Button_Click(object sender, RoutedEventArgs e) {
            Rotate(_forceOkAngle - Angle.CreateWithDegree(GetMoveStep()));
        }

        private double GetMoveStep() {
            return Convert.ToDouble(trainOriginMoveStep.Value);
        }

        private void Move(ImagePoint moveOffset) {
            var movePoint = (ForceOkPoint + moveOffset) as ImagePoint;
            SetForceOkPoint(movePoint);
        }

        private void Rotate(Angle moveAngle) {
            SetForceOkPoint(ForceOkPoint, moveAngle);
        }

        private void Center_Button_Click(object sender, RoutedEventArgs e) {
            var imageCenter = MilEnvironment.GetImageCenter(_findImageId);
            SetForceOkPoint(imageCenter, new Angle());
        }

        private void SetForceOkPoint(ImagePoint forceOkPoint, Angle forceAngle = null) {
            MIL_ID imageId = _cameraDisplay.GetImage();

            if (imageId == MIL.M_NULL) {
                return;
            }

            ImageSize imageSize = MilEnvironment.GetImageSize(imageId);
            _crossLength = Math.Max(imageSize.Width, imageSize.Height);
            if (IsOutOfImageArea(forceOkPoint, imageSize)) {
                return;
            }

            if (_milGraphics.HasGraphicLabel(_trainOriginLabel)) {
                _milGraphics.Remove(_trainOriginLabel);
                _cameraDisplay.ClearMeasureGraphics();
            }

            ForceOkPoint = forceOkPoint.Clone() as ImagePoint;

            Cross forceCross = null;
            if (forceAngle == null) {
                forceCross = new Cross(ForceOkPoint, _forceOkAngle, _crossLength);
            }
            else {
                forceCross = new Cross(ForceOkPoint, forceAngle, _crossLength);
                _forceOkAngle = forceAngle.Clone() as Angle;
            }

            DisplayDrawer.AddCross(
                _displayId, _graphicContext, _graphicList, COLOR_FORCE_OK_POINT, _milGraphics,
                forceCross);
            _trainOriginLabel = _milGraphics.GetLastLabel();
        }

        private static bool IsOutOfImageArea(ImagePoint forceOkPoint, ImageSize imageSize) {
            return forceOkPoint.X < 0 ||
                   forceOkPoint.Y < 0 ||
                   imageSize.Width - 1 < forceOkPoint.X ||
                   imageSize.Height - 1 < forceOkPoint.Y;
        }
    }
}