using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using RealTimeGraphEx.Models;
using RealTimeGraphEx.DataSeries;
using RealTimeGraphEx.Controllers;
using System.Runtime.ExceptionServices;

namespace RealTimeGraphEx.FastGraphs
{
    public class RealTimeGraphExMultiLineScroll : RealTimeGraphExMultiBase
    {
        private GraphMultiController _lastController;

        #region Cross Thread Fields

        protected List<ConcurrentpointsList> _graphPolygons;
        protected Color _stroke;
        protected Color _fill;
        protected bool _fillGraph;
        protected List<double> _markers;

        #endregion

        #region Constructors

        public RealTimeGraphExMultiLineScroll()
            : base()
        {
            _graphPolygons = new List<ConcurrentpointsList>();
            _graphController = new GraphMultiController();
            _markers = new List<double>();
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets or sets the graph strokes color.
        /// </summary>
        public Color Stroke
        {
            get { return (Color)GetValue(StrokeProperty); }
            set { SetValue(StrokeProperty, value); }
        }
        public static readonly DependencyProperty StrokeProperty =
            DependencyProperty.Register("Stroke", typeof(Color), typeof(RealTimeGraphExMultiLineScroll), new PropertyMetadata(Colors.Black, new PropertyChangedCallback(CrossModelChanged)));

        /// <summary>
        /// Gets or sets the graph fill color.
        /// </summary>
        public Color Fill
        {
            get { return (Color)GetValue(FillProperty); }
            set { SetValue(FillProperty, value); }
        }
        public static readonly DependencyProperty FillProperty =
            DependencyProperty.Register("Fill", typeof(Color), typeof(RealTimeGraphExMultiLineScroll), new PropertyMetadata(Colors.Transparent, new PropertyChangedCallback(CrossModelChanged)));

        /// <summary>
        /// Gets or sets whether the graph will be rendered using the Fill color property.
        /// </summary>
        public bool FillGraph
        {
            get { return (bool)GetValue(FillGraphProperty); }
            set { SetValue(FillGraphProperty, value); }
        }
        public static readonly DependencyProperty FillGraphProperty =
            DependencyProperty.Register("FillGraph", typeof(bool), typeof(RealTimeGraphExMultiLineScroll), new PropertyMetadata(false, new PropertyChangedCallback(CrossModelChanged)));

        #endregion

        #region Override Methods

        protected override void OnControllerChanged()
        {
            if (_graphController != null)
            {
                if (_lastController != _graphController)
                {
                    _graphPolygons.Clear();

                    _graphController.RegisterMethods(ClearGraph, StartPushThread, SetPaused, ChangeRenderMode, OnPushMarker);

                    foreach (var dataSeries in _graphController.DataSeriesCollection)
                    {
                        _graphPolygons.Add(new ConcurrentpointsList());
                    }


                    _lastController = _graphController;
                }
            }
        }

        protected override void OnSizeChanged(object sender, SizeChangedEventArgs e)
        {
            OnSetCrossThreadFields();
        }

        protected override void OnSetCrossThreadFields()
        {
            base.OnSetCrossThreadFields();

            this.Dispatcher.Invoke(() =>
            {
                _maxPoints = MaxPoints;
                _scaleFactor = _width / _maxPoints;

            }, System.Windows.Threading.DispatcherPriority.Send);
        }

        protected override void OnClearGraph()
        {
            _graphPolygons.ForEach(x => x.Clear());
            _graphController.ClearPoints();

            base.OnClearGraph();
        }

        protected internal override void OnRenderGraph()
        {
            if (_graphController != null && _graphController.dataSeriesCollection.Count > 0 && _graphController.TotalPoints > 0 && _width > 1 && _height > 1)
            {
                var pointsCollection = _graphController.GetAndClearAllPoints();

                if (!_isPaused)
                {

                    Parallel.For(0, pointsCollection.Count, (i) =>
                    {
                        double seriesCounter = xValueCounter;

                        for (int j = 0; j < pointsCollection[(int)i].Count; j++)
                        {
                            double value = pointsCollection[(int)i][j];
                            NormalizeValue(ref value);

                            _graphPolygons[i].Add(value);
                            seriesCounter += _scaleFactor;
                        }

                    });

                    xValueCounter += (pointsCollection[0].Count * _scaleFactor);

                    if (_graphPolygons[0].Count > _maxPoints + _graphController.dataSeriesCollection[0].Points.Count)
                    {
                        xValueCounter -= (_scaleFactor * (_graphPolygons[0].Count - (_maxPoints + _graphController.dataSeriesCollection[0].Points.Count)));


                        Parallel.ForEach(_graphPolygons, (polygon) =>
                        {
                            polygon.RemoveFromStart(polygon.Count - (_maxPoints + _graphController.dataSeriesCollection[0].Points.Count));
                        });
                    }
                }

                updateCounter++;

                if (updateCounter >= 1)
                {
                    updateCounter = 0;

                    if (!_disableRendering)
                    {
                        WriteableBitmap bmp = BitmapFactory.New((int)_mainWidth, (int)_mainHeight);
                        bmp.Clear(Colors.Transparent);

                        OnDrawVisuals(bmp);

                        bmp.Freeze();

                        img.Dispatcher.BeginInvoke(new Action(() =>
                        {
                            img.Source = bmp;
                        }), System.Windows.Threading.DispatcherPriority.Send);
                    }
                }
            }
        }

        protected override void OnZoomingComplete(Point transformOrigin, double scaleX, double scaleY)
        {
            base.OnZoomingComplete(transformOrigin, scaleX, scaleY);

            if (IsPaused)
            {
                WriteableBitmap bmp = BitmapFactory.New((int)_width, (int)_height);
                bmp.Clear(Colors.Transparent);

                OnDrawVisuals(bmp);

                bmp.Freeze();

                img.Dispatcher.BeginInvoke(new Action(() =>
                {
                    img.Source = bmp;
                }), System.Windows.Threading.DispatcherPriority.Send);
            }
        }

        protected override void OnDragging(System.Windows.Controls.Primitives.DragDeltaEventArgs e)
        {
            base.OnDragging(e);
        }

        #endregion

        #region Virtual Methods

        [HandleProcessCorruptedStateExceptions]
        protected virtual void OnDrawVisuals(WriteableBitmap bmp)
        {
            for (int i = 0; i < _graphPolygons.Count; i++)
            {
                Color stroke = _graphController.dataSeriesCollection[i].GetStrokeColor() != null ? _graphController.dataSeriesCollection[i].GetStrokeColor().Value : _stroke;
                Color? fill = _graphController.dataSeriesCollection[i].GetFillColor();
                _fillGraph = fill != Colors.Transparent && fill != null;

                var polygon = _graphPolygons[i];
                double scale = _width / (polygon.Count - 1);

                if (polygon.Count > 0)
                {
                    if (_fillGraph && _graphController.dataSeriesCollection[i].isVisible) //Fill Graph
                    {
                        bmp.FillPolygon(polygon.ToPolygonPointsFill(_offSetX, _offSetY, _width, _height, scale, ConvertYToImageYFliped), fill.Value);
                    }

                    if (_graphController.dataSeriesCollection[i].isVisible)
                    {
                        DrawPolyline(bmp, polygon.ToPolygonPoints(_offSetX, _offSetY, scale, ConvertYToImageYFliped), stroke);
                    }
                }


                for (int j = 0; j < _markers.Count; j++)
                {
                    int x = (int)((_markers[j] * scale) + _offSetX);
                    bmp.DrawLine(x, 0, x, (int)_mainHeight, Colors.Silver);
                }
            }
        }

        public virtual List<double> GetCurrentPointsOnGraph(int seriesIndex)
        {
            return _graphPolygons[seriesIndex].GetPoints();
        }

        protected virtual void OnPushMarker()
        {

        }

        #endregion

    }
}