using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.ExceptionServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace RealTimeGraphEx.FastGraphs
{
    public class RealTimeGraphExMultiLineErase : RealTimeGraphExMultiLineScroll
    {

        #region Cross Thread Fields

        protected Color _markerColor;
        protected bool _showMarker;
        protected bool _endReached;
        protected int _currentReplaceIndex;

        #endregion

        #region Constructors

        public RealTimeGraphExMultiLineErase()
            : base()
        {

        }

        #endregion

        #region Properties


        /// <summary>
        /// Gets or sets the graph marker color.
        /// </summary>
        public Color MarkerColor
        {
            get { return (Color)GetValue(MarkerColorProperty); }
            set { SetValue(MarkerColorProperty, value); }
        }
        public static readonly DependencyProperty MarkerColorProperty =
            DependencyProperty.Register("MarkerBrush", typeof(Color), typeof(RealTimeGraphExMultiLineErase), new PropertyMetadata(Colors.Red, new PropertyChangedCallback(CrossModelChanged)));

        /// <summary>
        /// Gets or sets whether to display the marker on the graph.
        /// </summary>
        public bool ShowMarker
        {
            get { return (bool)GetValue(ShowMarkerProperty); }
            set { SetValue(ShowMarkerProperty, value); }
        }
        public static readonly DependencyProperty ShowMarkerProperty =
            DependencyProperty.Register("ShowMarker", typeof(bool), typeof(RealTimeGraphExMultiLineErase), new PropertyMetadata(true, new PropertyChangedCallback(CrossModelChanged)));


        #endregion

        #region Override Methods

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

            this.Dispatcher.Invoke(() =>
            {

                _markerColor = MarkerColor;
                _showMarker = ShowMarker;

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

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

            _currentReplaceIndex = 0;
            _endReached = false;
        }

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

                if (_useAutoRange && pointsCollection.Count > 0)
                {
                    Dispatcher.Invoke(() =>
                    {
                        Maximum = pointsCollection.SelectMany(x => x).Concat(_graphPolygons.SelectMany(x => x.GetPoints())).Max();
                        Minimum = pointsCollection.SelectMany(x => x).Concat(_graphPolygons.SelectMany(x => x.GetPoints())).Min();
                    });
                }

                if (!_isPaused)
                {

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

                                    _graphPolygons[j].Add(value);
                                }

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

                                    _graphPolygons[j].Replace(value, _currentReplaceIndex);

                                    if (j == pointsCollection.Count - 1)
                                    {
                                        _currentReplaceIndex++;

                                        for (int k = 0; k < _markers.Count; k++)
                                        {
                                            if (_markers[k] == _currentReplaceIndex)
                                            {
                                                _markers.RemoveAt(k);
                                                k--;
                                            }
                                        }
                                    }
                                }

                                xValueCounter += _scaleFactor;

                                if (_currentReplaceIndex > _graphPolygons[0].Count - 1)
                                {
                                    xValueCounter = 0;
                                    _currentReplaceIndex = 0;
                                }
                            }
                        }
                        else
                        {
                            _endReached = true;
                            xValueCounter = 0;


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

                                if (j == pointsCollection.Count - 1)
                                {
                                    _currentReplaceIndex++;
                                }
                            }

                            xValueCounter += _scaleFactor;
                        }
                    }

                }


                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 OnPushMarker()
        {
            if (_currentReplaceIndex != 0)
            {
                _markers.Add(_currentReplaceIndex);
            }
        }

        [HandleProcessCorruptedStateExceptions]
        protected override void OnDrawVisuals(WriteableBitmap bmp)
        {
            if (_graphController == null) return;

            base.OnDrawVisuals(bmp);

            var polygon = _graphPolygons[0];
            double scale = _width / polygon.Count;

            //Draw marker
            if (_showMarker)
            {
                if (_currentReplaceIndex > 0)
                {
                    try
                    {
                        double x = ((_currentReplaceIndex * scale) + _offSetX);

                        bmp.DrawLine((int)x, 0, (int)x, (int)_mainHeight, _markerColor);
                    }
                    catch
                    {
                        Debug.WriteLine("[RealTimeGraphExMultiLineErase] [OnDrawVisuals] Error on drawing marker!");
                    }
                }
            }
        }

        #endregion
    }
}