using Bro.Common.Base;
using Bro.Common.ImageCanvas.Shapes;
using Bro.Common.Interface;
using Bro.Common.Model;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Ioc;
using MahApps.Metro.Controls.Dialogs;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Drawing;
using System.Linq;

namespace Bro.UI.ViewModel
{
    public class RunningViewModel : ViewModelBase
    {
        #region IDialogService
        public IDialogCoordinator Dialog
        {
            get
            {
                return SimpleIoc.Default.GetInstance<IDialogCoordinator>("Main");
            }
        }
        #endregion

        #region Properties
        private IProcess processControl = null;
        public IProcess ProcessControl
        {
            get => processControl;
            set
            {
                if (processControl?.ProductionCode != value.ProductionCode)
                {
                    processControl = value;
                    ResetProcessControl();
                }
            }
        }

        private void ResetProcessControl()
        {
            Images.Clear();
            Indicators.Clear();

            ProcessControl.DeviceCollection.ForEach(d =>
            {
                if (d is CameraBase camera)
                {
                    ImageModel imgModel = new ImageModel();
                    imgModel.CameraId = camera.Id;
                    imgModel.CameraName = camera.Name;
                    Images.Add(imgModel);

                    BoxIndicatorModel biModel = new BoxIndicatorModel();
                    biModel.CameraId = camera.Id;
                    biModel.Results = new ObservableCollection<dynamic>() { new { Status = (bool?)null, CodeStr = "NA" }, new { Status = (bool?)null, CodeStr = "NA" } };
                    Indicators.Add(biModel);

                    camera.OnImageUpdated -= Camera_OnImageUpdated;
                    camera.OnElementsUpdated -= Camera_OnElementsUpdated;
                    camera.OnImageUpdated += Camera_OnImageUpdated;
                    camera.OnElementsUpdated += Camera_OnElementsUpdated;
                }
            });

            //ProcessControl.OnBitmapOutput -= OnBitmapUpdate;
            //ProcessControl.OnBitmapOutput += OnBitmapUpdate;

            //ProcessControl.OnIndicatorResultUpdated -= OnIndicatorResultUpdated;
            //ProcessControl.OnIndicatorResultUpdated += OnIndicatorResultUpdated;
        }

        private ObservableCollection<ImageModel> images = new ObservableCollection<ImageModel>();
        public ObservableCollection<ImageModel> Images
        {
            get => images;
            set => Set(ref images, value);
        }

        private ObservableCollection<BoxIndicatorModel> indicators = new ObservableCollection<BoxIndicatorModel>();
        public ObservableCollection<BoxIndicatorModel> Indicators
        {
            get => indicators;
            set => Set(ref indicators, value);
        }
        #endregion

        public RunningViewModel(IProcess process)
        {
            ProcessControl = process;

            #region 测试使用
            //ShapeElementBase shape1 = new ComplexPointIndicator()
            //{
            //    PointInfo = new ComplexPoint()
            //    {
            //        ImagePoint = new DirectionAidPoint() { X = 400, Y = 500 },
            //        PlatPoint = new DirectionAidPoint() { X = 300, Y = 200, IsAvailable = true, },
            //    },
            //    Angle = 30,
            //    Index = 10
            //};

            //ShapeElementBase shape2 = new PointIndicator(300, 400, 50);

            //ShapeElementBase shape3 = new ComplexPointIndicator()
            //{
            //    PointInfo = new ComplexPoint()
            //    {
            //        ImagePoint = new DirectionAidPoint() { X = 500, Y = 600 },
            //        PlatPoint = new DirectionAidPoint() { X = 300, Y = 200, IsAvailable = false, },
            //    },
            //    Angle = 30,
            //    Index = 10,

            //};

            //Images[0].Shapes.Add(shape1);
            //Images[0].Shapes.Add(shape2);
            //Images[0].Shapes.Add(shape3);
            #endregion
        }

        private void Camera_OnElementsUpdated(CameraBase camera, List<IShapeElement> eleList, string imgSet)
        {
            App.Current.Dispatcher.Invoke(() =>
            {
                var imgModel = Images.FirstOrDefault(u => u.CameraId == camera.Id);
                var biModel = Indicators.FirstOrDefault(u => u.CameraId == camera.Id);
                if (imgModel != null)
                {
                    while (imgModel.Shapes.Count > 0)
                    {
                        imgModel.Shapes.RemoveAt(0);
                    }
                }
            });
        }

        private void Camera_OnImageUpdated(CameraBase camera, Bitmap bmp, string imgSetId)
        {
            var model = Images.FirstOrDefault(u => u.CameraId == camera.Id);
            if (model != null)
            {
                model.Image = bmp;
            }
        }

        private void OnPointsCalculated(string cameraId, List<ComplexPoint> complexPoints)
        {
            //App.Current.Dispatcher.Invoke(() =>
            //{
            //    var imgModel = Images.FirstOrDefault(u => u.CameraId == cameraId);
            //    if (imgModel != null)
            //    {
            //        //imgModel.Shapes.Clear();

            //        for (int i = imgModel.Shapes.Count - 1; i >= 0; i--)
            //        {
            //            imgModel.Shapes.RemoveAt(i);
            //        }

            //        if (complexPoints != null)
            //        {
            //            for (int i = 0; i < complexPoints.Count; i++)
            //            {
            //                if (complexPoints[i].ImagePoint != null)
            //                {
            //                    ComplexPointIndicator indicator = new ComplexPointIndicator();
            //                    indicator.PointInfo = complexPoints[i];
            //                    indicator.Index = i + 1;

            //                    imgModel.Shapes.Add(indicator);
            //                }
            //            }
            //        }

            //        //if (imagePoints != null)
            //        //{
            //        //    for (int i = 0; i < imagePoints.Count; i++)
            //        //    {
            //        //        PointIndicator indicator = new PointIndicator(imagePoints[i].X, imagePoints[i].Y);
            //        //        imgModel.Shapes.Add(indicator);
            //        //    }
            //        //}
            //    }
            //});

            //var pModel = Points.FirstOrDefault(p => p.CameraId == cameraId);
            //if (pModel != null && complexPoints != null)
            //{
            //    IEnumerable<ComplexPoint> temp = pModel.PointsSource.Union(complexPoints);
            //    if (temp.Count() > 200)
            //    {
            //        temp = temp.Skip(100);
            //    }

            //    pModel.PointsSource = new ObservableCollection<ComplexPoint>(temp);
            //}
        }

        private void OnIndicatorResultUpdated(string cameraId, int indicatorIndex, bool indicatorResult, bool isLTR)
        {
            App.Current.Dispatcher.Invoke(() =>
            {
                var indicator = Indicators.FirstOrDefault(u => u.CameraId == cameraId);

                if (indicator != null)
                {
                    if (indicatorIndex >= 0 && indicatorIndex < indicator.Results.Count)
                    {
                        if (isLTR)
                        {
                            if (indicatorIndex == 0)
                            {
                                indicator.Results.ToList().ForEach(u => u = null);
                            }

                            indicator.Results[indicatorIndex] = indicatorResult;
                        }
                        else
                        {
                            if (indicatorIndex == indicator.Results.Count - 1)
                            {
                                indicator.Results.ToList().ForEach(u => u = null);
                            }

                            indicator.Results[indicator.Results.Count - 1 - indicatorIndex] = indicatorResult;
                        }
                    }
                }
            });
        }
    }

    public class ImageModel : INotifyPropertyChanged
    {
        public string CameraId { get; set; }
        public string CameraName { get; set; }

        private Bitmap image = null;
        public Bitmap Image
        {
            get => image;
            set
            {
                if (image != value)
                {
                    image = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("Image"), null, null);
                }
            }
        }

        private ObservableCollection<ShapeElementBase> shapes = null;
        public ObservableCollection<ShapeElementBase> Shapes
        {
            get
            {
                if (shapes == null)
                {
                    shapes = new ObservableCollection<ShapeElementBase>();
                    shapes.CollectionChanged -= Shapes_CollectionChanged;
                    shapes.CollectionChanged += Shapes_CollectionChanged;
                }

                return shapes;
            }
            set
            {
                if (shapes != value)
                {
                    shapes = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("Shapes"), null, null);

                    shapes.CollectionChanged -= Shapes_CollectionChanged;
                    shapes.CollectionChanged += Shapes_CollectionChanged;
                }
            }
        }

        //static object shapeChangeLock = new object();
        private void Shapes_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            //App.Current.Dispatcher.Invoke(() =>
            //{
            //    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Shapes"));
            //});
            PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("Shapes"), null, null);
            //lock (shapeChangeLock)
            //{
            //    App.Current.Dispatcher.Invoke(() =>
            //    {
            //        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Shapes"));
            //    });
            //}
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }

    public class BoxIndicatorModel : INotifyPropertyChanged
    {
        public string CameraId { get; set; }

        private ObservableCollection<dynamic> results = new ObservableCollection<dynamic>();

        public event PropertyChangedEventHandler PropertyChanged;

        public ObservableCollection<dynamic> Results
        {
            get => results;
            set
            {
                if (results != value)
                {
                    results = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("Results"), null, null);

                    results.CollectionChanged -= Results_CollectionChanged;
                    results.CollectionChanged += Results_CollectionChanged;
                }
            }
        }

        private void Results_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("Results"), null, null);
        }
    }
}