using System;
using System.Collections.Generic;
using FastReport.DataVisualization.Charting;
using System.ComponentModel;
using System.Drawing;
using FastReport.Data;
using FastReport.Utils;
using System.Drawing.Design;

namespace FastReport.MSChart
{
    /// <summary>
    /// Specifies how the series points are sorted.
    /// </summary>
    public enum SortBy
    {
        /// <summary>
        /// Points are not sorted.
        /// </summary>
        None,

        /// <summary>
        /// Points are sorted by X value.
        /// </summary>
        XValue,

        /// <summary>
        /// Points are sorted by Y value.
        /// </summary>
        YValue
    }

    /// <summary>
    /// Specifies the direction in which the series points are sorted.
    /// </summary>
    public enum ChartSortOrder
    {
        /// <summary>
        /// Points are sorted in ascending order.
        /// </summary>
        Ascending,

        /// <summary>
        /// Points are sorted in descending order.
        /// </summary>
        Descending
    }

    /// <summary>
    /// Specifies how the series points are grouped.
    /// </summary>
    public enum GroupBy
    {
        /// <summary>
        /// Points are not grouped.
        /// </summary>
        None,

        /// <summary>
        /// Points are grouped by X value.
        /// </summary>
        XValue,

        /// <summary>
        /// Points are grouped by number specified in the <see cref="MSChartSeries.GroupInterval"/>.
        /// </summary>
        Number,

        /// <summary>
        /// Points are grouped by Years.
        /// </summary>
        Years,

        /// <summary>
        /// Points are grouped by Months.
        /// </summary>
        Months,

        /// <summary>
        /// Points are grouped by Weeks.
        /// </summary>
        Weeks,

        /// <summary>
        /// Points are grouped by Days.
        /// </summary>
        Days,

        /// <summary>
        /// Points are grouped by Hours.
        /// </summary>
        Hours,

        /// <summary>
        /// Points are grouped by Minutes.
        /// </summary>
        Minutes,

        /// <summary>
        /// Points are grouped by Seconds.
        /// </summary>
        Seconds,

        /// <summary>
        /// Points are grouped by Milliseconds.
        /// </summary>
        Milliseconds
    }

    /// <summary>
    /// Specifies which pie value to explode.
    /// </summary>
    public enum PieExplode
    {
        /// <summary>
        /// Do not explode pie values.
        /// </summary>
        None,

        /// <summary>
        /// Explode the biggest value.
        /// </summary>
        BiggestValue,

        /// <summary>
        /// Explode the lowest value.
        /// </summary>
        LowestValue,

        /// <summary>
        /// Explode the value specified in the <see cref="MSChartSeries.PieExplodeValue"/> property.
        /// </summary>
        SpecificValue
    }

    /// <summary>
    /// Specifies which data points to collect into one point.
    /// </summary>
    public enum Collect
    {
        /// <summary>
        /// Do not collect points.
        /// </summary>
        None,

        /// <summary>
        /// Show top N points (<i>N</i> value is specified in the <see cref="MSChartSeries.CollectValue"/>
        /// property), collect other points into one.
        /// </summary>
        TopN,

        /// <summary>
        /// Show bottom N points (<i>N</i> value is specified in the <see cref="MSChartSeries.CollectValue"/>
        /// property), collect other points into one.
        /// </summary>
        BottomN,

        /// <summary>
        /// Collect points which have Y value less than specified 
        /// in the <see cref="MSChartSeries.CollectValue"/> property.
        /// </summary>
        LessThan,

        /// <summary>
        /// Collect points which have Y value less than percent specified 
        /// in the <see cref="MSChartSeries.CollectValue"/> property.
        /// </summary>
        LessThanPercent,

        /// <summary>
        /// Collect points which have Y value greater than specified 
        /// in the <see cref="MSChartSeries.CollectValue"/> property.
        /// </summary>
        GreaterThan,

        /// <summary>
        /// Collect points which have Y value greater than percent specified 
        /// in the <see cref="MSChartSeries.CollectValue"/> property.
        /// </summary>
        GreaterThanPercent
    }


    /// <summary>
    /// Represents a MS Chart series wrapper.
    /// </summary>
    /// <remarks>
    /// This class provides a data for MS Chart series. The series itself is stored inside the
    /// MS Chart and is accessible via the <see cref="SeriesSettings"/> property.
    /// <para/>You don't need to create an instance of this class directly. Instead, use the
    /// <see cref="MSChartObject.AddSeries"/> method. 
    /// </remarks>
    public class MSChartSeries : Base
    {
        #region Fields
        private string filter;
        private SortBy sortBy;
        private ChartSortOrder sortOrder;
        private GroupBy groupBy;
        private float groupInterval;
        private TotalType groupFunction;
        private Collect collect;
        private float collectValue;
        private string collectedItemText;
        private Color collectedItemColor;
        private PieExplode pieExplode;
        private string pieExplodeValue;

        private string xValue;
        private string yValue1;
        private string yValue2;
        private string yValue3;
        private string yValue4;
        private string color;
        private string label;
        private bool autoSeriesForce;
        private string autoSeriesColumn;
        #endregion

        #region Properties
        /// <summary>
        /// Gets os sets the data filter expression.
        /// </summary>
        /// <remarks>
        /// The filter is applied for this series only. You can also use the
        /// <see cref="MSChartObject.Filter"/> property to set a filter that will be applied to all
        /// series in a chart.
        /// </remarks>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string Filter
        {
            get { return filter; }
            set { filter = value; }
        }

        /// <summary>
        /// Gets or set the data column or expression for automatically created series.
        /// </summary>
        /// <remarks>
        /// In order to create auto-series, you need to define one series that will be used as a 
        /// template for new series, and set up the <see cref="AutoSeriesColumn"/> property.
        /// The value of this property will be a name of new series. If there is no series 
        /// with such name yet, the new series will be added.
        /// </remarks>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string AutoSeriesColumn
        {
            get { return autoSeriesColumn; }
            set { autoSeriesColumn = value; }
        }

        /// <summary>
        /// Gets or sets the sort method used to sort data points.
        /// </summary>
        /// <remarks>
        /// You have to specify the <see cref="SortOrder"/> property as well. Data points in this series
        /// will be sorted according selected sort criteria and order.
        /// </remarks>
        [Category("Data")]
        [DefaultValue(SortBy.None)]
        public SortBy SortBy
        {
            get { return sortBy; }
            set { sortBy = value; }
        }

        /// <summary>
        /// Gets or set Force automatically created series.
        /// </summary>
        [Category("Data")]
        [DefaultValue(true)]
        public bool AutoSeriesForce
        {
            get { return autoSeriesForce; }
            set { autoSeriesForce = value; }
        }

        /// <summary>
        /// Gets or sets the sort order used to sort data points.
        /// </summary>
        /// <remarks>
        /// You have to specify the <see cref="SortBy"/> property as well. Data points in this series
        /// will be sorted according selected sort criteria and order.
        /// </remarks>
        [Category("Data")]
        [DefaultValue(ChartSortOrder.Ascending)]
        public ChartSortOrder SortOrder
        {
            get { return sortOrder; }
            set { sortOrder = value; }
        }

        /// <summary>
        /// Gets or sets the group method used to group data points.
        /// </summary>
        /// <remarks>
        /// This property is mainly used when series is filled with data with several identical X values.
        /// In this case, you need to set the property to <b>XValue</b>. All identical data points will be 
        /// grouped into one point, their Y values will be summarized. You can choose the summary function
        /// using the <see cref="GroupFunction"/> property.
        /// </remarks>
        [Category("Data")]
        [DefaultValue(GroupBy.None)]
        public GroupBy GroupBy
        {
            get { return groupBy; }
            set { groupBy = value; }
        }

        /// <summary>
        /// Gets or sets the group interval.
        /// </summary>
        /// <remarks>
        /// This value is used if <see cref="GroupBy"/> property is set to <b>Number</b>.
        /// </remarks>
        [Category("Data")]
        [DefaultValue(1f)]
        public float GroupInterval
        {
            get { return groupInterval; }
            set { groupInterval = value; }
        }

        /// <summary>
        /// Gets or sets the function used to group data points.
        /// </summary>
        [Category("Data")]
        [DefaultValue(TotalType.Sum)]
        public TotalType GroupFunction
        {
            get { return groupFunction; }
            set { groupFunction = value; }
        }

        /// <summary>
        /// Gets or sets the collect method used to collect several data points into one.
        /// </summary>
        /// <remarks>
        /// This instrument for data processing allows to collect several series points into one point.
        /// The collected point will be displaed using the text specified in the <see cref="CollectedItemText"/>
        /// property and color specified in the <see cref="CollectedItemColor"/> property.
        /// <para/>For example, to display top 5 values, set this property to <b>TopN</b> and specify
        /// N value (5) in the <see cref="CollectValue"/> property.
        /// </remarks>
        [Category("Data")]
        [DefaultValue(Collect.None)]
        public Collect Collect
        {
            get { return collect; }
            set { collect = value; }
        }

        /// <summary>
        /// Gets or sets the collect value used to collect several data points into one.
        /// </summary>
        /// <remarks>
        /// This property is used if the <see cref="Collect"/> property is set to any value other than <b>None</b>.
        /// </remarks>
        [Category("Data")]
        [DefaultValue(0f)]
        public float CollectValue
        {
            get { return collectValue; }
            set { collectValue = value; }
        }

        /// <summary>
        /// Gets or sets the text for the collected value.
        /// </summary>
        [Category("Data")]
        public string CollectedItemText
        {
            get { return collectedItemText; }
            set { collectedItemText = value; }
        }

        /// <summary>
        /// Gets or sets the color for the collected value.
        /// </summary>
        /// <remarks>
        /// If this property is set to <b>Transparent</b> (by default), the default palette color
        /// will be used to display a collected point.
        /// </remarks>
        [Category("Data")]
        public Color CollectedItemColor
        {
            get { return collectedItemColor; }
            set { collectedItemColor = value; }
        }

        /// <summary>
        /// Gets or sets the method used to explode values in pie-type series.
        /// </summary>
        [Category("Data")]
        [DefaultValue(PieExplode.None)]
        public PieExplode PieExplode
        {
            get { return pieExplode; }
            set { pieExplode = value; }
        }

        /// <summary>
        /// Gets or sets the value that must be exploded.
        /// </summary>
        /// <remarks>
        /// This property is used if <see cref="PieExplode"/> property is set
        /// to <b>SpecificValue</b>.
        /// </remarks>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string PieExplodeValue
        {
            get { return pieExplodeValue; }
            set { pieExplodeValue = value; }
        }

        /// <summary>
        /// Gets or sets the data column or expression that returns the X value of data point.
        /// </summary>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string XValue
        {
            get { return xValue; }
            set { xValue = value; }
        }

        /// <summary>
        /// Gets or sets the data column or expression that returns the first Y value of data point.
        /// </summary>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string YValue1
        {
            get { return yValue1; }
            set { yValue1 = value; }
        }

        /// <summary>
        /// Gets or sets the data column or expression returns the second Y value of data point.
        /// </summary>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string YValue2
        {
            get { return yValue2; }
            set { yValue2 = value; }
        }

        /// <summary>
        /// Gets or sets the data column or expression returns the third Y value of data point.
        /// </summary>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string YValue3
        {
            get { return yValue3; }
            set { yValue3 = value; }
        }

        /// <summary>
        /// Gets or sets the data column or expression returns the fourth Y value of data point.
        /// </summary>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string YValue4
        {
            get { return yValue4; }
            set { yValue4 = value; }
        }

        /// <summary>
        /// Gets or sets the data column or expression that returns the color of data point.
        /// </summary>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string Color
        {
            get { return color; }
            set { color = value; }
        }

        /// <summary>
        /// Gets or sets the data column or expression returns the label value of data point.
        /// </summary>
        [Category("Data")]
        [Editor("FastReport.TypeEditors.ExpressionEditor, FastReport", typeof(UITypeEditor))]
        public string Label
        {
            get { return label; }
            set { label = value; }
        }

        /// <summary>
        /// Gets a reference to MS Chart <b>Series</b> object.
        /// </summary>
        /// <remarks>
        /// Use this property to set many options available for the <b>Series</b> object. These options
        /// include: visual appearance, labels, marks, value types. Refer to the Microsoft Chart control
        /// documentation to learn more.
        /// </remarks>
        [Category("Appearance")]
        public Series SeriesSettings
        {
            get
            {
                MSChartObject parent = Parent as MSChartObject;
                if (parent == null)
                    return null;
                int index = parent.Series.IndexOf(this);
                if (index < parent.Chart.Series.Count)
                    return parent.Chart.Series[index];
                return null;
            }
        }

        /// <summary>
        /// Gets a number of Y value per data point.
        /// </summary>
        /// <remarks>
        /// Number of Y values depends on series type. Most of series have only one Y value. Financial
        /// series such as Stock and Candlestick, use four Y values.
        /// </remarks>
        [Browsable(false)]
        public int YValuesPerPoint
        {
            get { return SeriesSettings.YValuesPerPoint; }
        }

        /// <summary>
        /// This property is not relevant to this class.
        /// </summary>
        [Browsable(false)]
        public new Restrictions Restrictions
        {
            get { return base.Restrictions; }
            set { base.Restrictions = value; }
        }
        #endregion

        #region Private Methods
        private object Calc(string expression)
        {
            if (!String.IsNullOrEmpty(expression))
                return Report.Calc(expression);
            return null;
        }

        private void InternalProcessData()
        {
            object xValue = Calc(XValue);
            if (xValue != null)
            {
                string[] expressions = new string[] { YValue1, YValue2, YValue3, YValue4 };
                object[] values = new object[YValuesPerPoint];

                for (int i = 0; i < YValuesPerPoint; i++)
                {
                    values[i] = Calc(expressions[i]);
                }

                DataPoint point = SeriesSettings.Points[SeriesSettings.Points.AddXY(xValue, values)];

                // color
                object color = Calc(Color);
                if (color != null)
                {
                    if (color is System.Drawing.Color)
                        point.Color = (System.Drawing.Color)color;
                    else if (color is Int32)
                        point.Color = System.Drawing.Color.FromArgb(255, System.Drawing.Color.FromArgb((int)color));
                    else if (color is String)
                        point.Color = System.Drawing.Color.FromName((string)color);
                }

                // label
                object label = Calc(Label);
                if (label != null)
                    point.Label = label.ToString();
            }
        }

        private void SortData()
        {
            SeriesSettings.Sort(new DataPointComparer(SortBy, SortOrder));
        }

        private void CollectValues()
        {
            double others = 0;

            if (Collect == Collect.TopN || Collect == Collect.BottomN)
            {
                for (int i = (int)CollectValue; i < SeriesSettings.Points.Count;)
                {
                    others += SeriesSettings.Points[i].YValues[0];
                    SeriesSettings.Points.RemoveAt(i);
                }
            }
            else
            {
                double totalValue = 0;
                if (Collect == Collect.LessThanPercent || Collect == Collect.GreaterThanPercent)
                {
                    foreach (DataPoint point in SeriesSettings.Points)
                    {
                        totalValue += point.YValues[0];
                    }
                }

                for (int i = 0; i < SeriesSettings.Points.Count;)
                {
                    double value = SeriesSettings.Points[i].YValues[0];
                    if ((Collect == Collect.LessThan && value < CollectValue) ||
                      (Collect == Collect.GreaterThan && value > CollectValue) ||
                      (Collect == Collect.LessThanPercent && value / totalValue * 100 < CollectValue) ||
                      (Collect == Collect.GreaterThanPercent && value / totalValue * 100 > CollectValue))
                    {
                        others += value;
                        SeriesSettings.Points.RemoveAt(i);
                    }
                    else
                        i++;
                }
            }

            if (others > 0 && !String.IsNullOrEmpty(CollectedItemText))
            {
                SeriesSettings.Points.AddXY(CollectedItemText, others);
                DataPoint point = SeriesSettings.Points[SeriesSettings.Points.Count - 1];
                if (CollectedItemColor != System.Drawing.Color.Transparent)
                    point.Color = CollectedItemColor;
            }
        }

        private void GroupData()
        {
            Chart chart = (Parent as MSChartObject).Chart;
            string function = "";

            switch (GroupFunction)
            {
                case TotalType.Sum:
                    function = "SUM";
                    break;

                case TotalType.Min:
                    function = "MIN";
                    break;

                case TotalType.Max:
                    function = "MAX";
                    break;

                case TotalType.Avg:
                    function = "AVE";
                    break;

                case TotalType.Count:
                    function = "COUNT";
                    break;
            }

            if (GroupBy == GroupBy.XValue)
                chart.DataManipulator.GroupByAxisLabel(function, SeriesSettings);
            else
            {
                IntervalType type = IntervalType.Number;
                switch (GroupBy)
                {
                    case GroupBy.Years:
                        type = IntervalType.Years;
                        break;

                    case GroupBy.Months:
                        type = IntervalType.Months;
                        break;

                    case GroupBy.Weeks:
                        type = IntervalType.Weeks;
                        break;

                    case GroupBy.Days:
                        type = IntervalType.Days;
                        break;

                    case GroupBy.Hours:
                        type = IntervalType.Hours;
                        break;

                    case GroupBy.Minutes:
                        type = IntervalType.Minutes;
                        break;

                    case GroupBy.Seconds:
                        type = IntervalType.Seconds;
                        break;

                    case GroupBy.Milliseconds:
                        type = IntervalType.Milliseconds;
                        break;
                }

                chart.DataManipulator.Group(function, GroupInterval, type, SeriesSettings);
            }
        }

        private void ExplodePoint()
        {
            if (SeriesSettings.Points.Count == 0)
                return;

            if (PieExplode == PieExplode.SpecificValue)
            {
                object pieExplodeValue = Calc(PieExplodeValue);
                if (pieExplodeValue != null)
                {
                    foreach (DataPoint point in SeriesSettings.Points)
                    {
                        if (point.AxisLabel == pieExplodeValue.ToString())
                        {
                            point["Exploded"] = "true";
                            break;
                        }
                    }
                }
            }
            else
            {
                List<DataPoint> points = new List<DataPoint>();
                foreach (DataPoint point in SeriesSettings.Points)
                {
                    points.Add(point);
                }

                points.Sort(new DataPointComparer(SortBy.YValue, ChartSortOrder.Ascending));

                DataPoint explodePoint = null;
                if (PieExplode == PieExplode.BiggestValue)
                    explodePoint = points[points.Count - 1];
                else
                    explodePoint = points[0];

                explodePoint["Exploded"] = "true";
            }
        }
        #endregion

        #region Public Methods
        /// <inheritdoc/>
        public override void Assign(Base source)
        {
            base.Assign(source);
            MSChartSeries src = source as MSChartSeries;

            Filter = src.Filter;
            SortOrder = src.SortOrder;
            SortBy = src.SortBy;
            GroupBy = src.GroupBy;
            GroupInterval = src.GroupInterval;
            GroupFunction = src.GroupFunction;
            Collect = src.Collect;
            CollectValue = src.CollectValue;
            CollectedItemText = src.CollectedItemText;
            CollectedItemColor = src.CollectedItemColor;
            PieExplode = src.PieExplode;
            PieExplodeValue = src.PieExplodeValue;
            AutoSeriesForce = src.AutoSeriesForce;
            AutoSeriesColumn = src.AutoSeriesColumn;

            XValue = src.XValue;
            YValue1 = src.YValue1;
            YValue2 = src.YValue2;
            YValue3 = src.YValue3;
            YValue4 = src.YValue4;
            Color = src.Color;
            Label = src.Label;
        }

        /// <inheritdoc/>
        public override void Serialize(FRWriter writer)
        {
            MSChartSeries s = writer.DiffObject as MSChartSeries;
            base.Serialize(writer);

            if (Filter != s.Filter)
                writer.WriteStr("Filter", Filter);
            if (SortOrder != s.SortOrder)
                writer.WriteValue("SortOrder", SortOrder);
            if (SortBy != s.SortBy)
                writer.WriteValue("SortBy", SortBy);
            if (GroupBy != s.GroupBy)
                writer.WriteValue("GroupBy", GroupBy);
            if (GroupInterval != s.GroupInterval)
                writer.WriteFloat("GroupInterval", GroupInterval);
            if (GroupFunction != s.GroupFunction)
                writer.WriteValue("GroupFunction", GroupFunction);
            if (Collect != s.Collect)
                writer.WriteValue("Collect", Collect);
            if (CollectValue != s.CollectValue)
                writer.WriteFloat("CollectValue", CollectValue);
            if (CollectedItemText != s.CollectedItemText)
                writer.WriteStr("CollectedItemText", CollectedItemText);
            if (CollectedItemColor != s.CollectedItemColor)
                writer.WriteValue("CollectedItemColor", CollectedItemColor);
            if (PieExplode != s.PieExplode)
                writer.WriteValue("PieExplode", PieExplode);
            if (PieExplodeValue != s.PieExplodeValue)
                writer.WriteStr("PieExplodeValue", PieExplodeValue);

            if (XValue != s.XValue)
                writer.WriteStr("XValue", XValue);
            if (YValue1 != s.YValue1)
                writer.WriteStr("YValue1", YValue1);
            if (YValue2 != s.YValue2)
                writer.WriteStr("YValue2", YValue2);
            if (YValue3 != s.YValue3)
                writer.WriteStr("YValue3", YValue3);
            if (YValue4 != s.YValue4)
                writer.WriteStr("YValue4", YValue4);
            if (Color != s.Color)
                writer.WriteStr("Color", Color);
            if (Label != s.Label)
                writer.WriteStr("Label", Label);
            if (!AutoSeriesForce)
                writer.WriteBool("AutoSeriesForce", AutoSeriesForce);
            if (AutoSeriesColumn != s.AutoSeriesColumn)
                writer.WriteStr("AutoSeriesColumn", AutoSeriesColumn);
        }

        /// <inheritdoc/>
        public override void Deserialize(FRReader reader)
        {
            base.Deserialize(reader);
            if (reader.HasProperty("GroupByXValue"))
                GroupBy = GroupBy.XValue;
        }

        /// <summary>
        /// Clears all data points in this series.
        /// </summary>
        public void ClearValues()
        {
            SeriesSettings.Points.Clear();
        }

        /// <summary>
        /// Adds a data point with specified X and Y values.
        /// </summary>
        /// <param name="xValue">X value.</param>
        /// <param name="yValues">Array of Y values.</param>
        /// <remarks>
        /// Note: number of values in the <b>yValues</b> parameter must be the same as value returned 
        /// by the <see cref="YValuesPerPoint"/> property.
        /// </remarks>
        public void AddValue(object xValue, params object[] yValues)
        {
            SeriesSettings.Points.AddXY(xValue, yValues);
        }

        internal void ProcessData()
        {
            object match = true;
            if (!String.IsNullOrEmpty(Filter))
                match = Report.Calc(Filter);
            if (match is bool && (bool)match == true)
                InternalProcessData();
        }

        internal void FinishData()
        {
            // sort is required if we group by value, not by axis label
            bool sortThenGroup = GroupBy != GroupBy.XValue;
            if (!sortThenGroup)
            {
                if (GroupBy != GroupBy.None)
                    GroupData();
            }

            // sort
            if (Collect == Collect.TopN)
            {
                SortBy = SortBy.YValue;
                SortOrder = ChartSortOrder.Descending;
            }
            else if (Collect == Collect.BottomN)
            {
                SortBy = SortBy.YValue;
                SortOrder = ChartSortOrder.Ascending;
            }
            if (SortBy != SortBy.None)
                SortData();

            // group
            if (sortThenGroup)
            {
                if (GroupBy != GroupBy.None)
                    GroupData();
            }

            // collect topn values
            if (Collect != Collect.None)
                CollectValues();

            // explode values
            if (PieExplode != PieExplode.None)
                ExplodePoint();
        }

        internal void CreateDummyData()
        {
            SeriesSettings.Points.Clear();
            SeriesSettings.Points.AddXY("A", 1);
            SeriesSettings.Points.AddXY("B", 3);
            SeriesSettings.Points.AddXY("C", 2);
            SeriesSettings.Points.AddXY("D", 4);
        }

        /// <inheritdoc/>
        public override string[] GetExpressions()
        {
            List<string> expressions = new List<string>();

            if (!String.IsNullOrEmpty(PieExplodeValue))
                expressions.Add(PieExplodeValue);

            if (!String.IsNullOrEmpty(XValue))
                expressions.Add(XValue);
            if (!String.IsNullOrEmpty(YValue1))
                expressions.Add(YValue1);
            if (!String.IsNullOrEmpty(YValue2))
                expressions.Add(YValue2);
            if (!String.IsNullOrEmpty(YValue3))
                expressions.Add(YValue3);
            if (!String.IsNullOrEmpty(YValue4))
                expressions.Add(YValue4);
            if (!String.IsNullOrEmpty(Color))
                expressions.Add(Color);
            if (!String.IsNullOrEmpty(Label))
                expressions.Add(Label);
            if (!String.IsNullOrEmpty(Filter))
                expressions.Add(Filter);

            return expressions.ToArray();
        }
        #endregion

        /// <summary>
        /// Creates a new instance of the <see cref="MSChartSeries"/> class with default settings.
        /// </summary>
        public MSChartSeries()
        {
            filter = "";
            groupInterval = 1;
            collectedItemText = "";
            collectedItemColor = System.Drawing.Color.Transparent;
            pieExplodeValue = "";

            xValue = "";
            yValue1 = "";
            yValue2 = "";
            yValue3 = "";
            yValue4 = "";
            color = "";
            label = "";
            autoSeriesForce = true;
            BaseName = "Series";
        }
    }
}