using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;
using DevComponents.DotNetBar.Charts.Style;

namespace DevComponents.DotNetBar.Charts
{
    /// <summary>
    /// Represents the collection of Axis Stripes.
    /// </summary>
    [Editor("DevComponents.Charts.Design.AxisStripeCollectionEditor, DevComponents.Charts.Design, " +
        "Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
    public class AxisStripeCollection : CustomNamedCollection<AxisStripe>
    {
        public AxisStripeCollection()
        {
        }

        #region GetUniqueName

        public string GetUniqueName()
        {
            return (GetUniqueName("Stripe"));
        }

        #endregion
    }

    /// <summary>
    /// Element describing a color stripe on the chart.  Each AxisStripe
    /// is associated with a primary or Ancillary Axis.
    /// </summary>
    public class AxisStripe : ChartVisualElement, ILegendItem
    {
        #region Private variables

        private States _States;

        private object _MinValue;
        private object _MaxValue;
        private AxisStripeVisualStyle _AxisStripeVisualStyle;

        private string _LegendText;
        private ChartLegendItem _LegendItem;
        private ChartLegendItemVisualStyles _ChartLegendItemVisualStyles;

        #endregion

        #region Constructors

        /// <summary>
        /// Create a new AxisStripe.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="minValue"></param>
        /// <param name="maxValue"></param>
        public AxisStripe(string name, object minValue, object maxValue)
            : this()
        {
            Name = name;

            MinValue = minValue;
            MaxValue = maxValue;
        }

        /// <summary>
        /// Create a new AxisStripe.
        /// </summary>
        /// <param name="name"></param>
        public AxisStripe(string name)
            : this()
        {
            Name = name;
        }

        /// <summary>
        /// Create a new AxisStripe.
        /// </summary>
        public AxisStripe()
        {
            InitDefaultStates();
        }

        #endregion

        #region InitDefaultStates

        private void InitDefaultStates()
        {
            SetState(States.CheckedInLegend, true);
            SetState(States.ShowInLegend, true);
            SetState(States.ShowInParentLegend, true);
            SetState(States.ShowCheckBoxInLegend, true);
            SetState(States.ShowMarkerInLegend, true);
        }

        #endregion

        #region Public properties

        #region AxisStripeVisualStyle

        /// <summary>
        /// Gets or sets the visual style for the AxisStripe.
        /// </summary>
        [Category("Style")]
        [Description("Indicates the visual style for the AxisStripe.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public AxisStripeVisualStyle AxisStripeVisualStyle
        {
            get
            {
                if (_AxisStripeVisualStyle == null)
                {
                    _AxisStripeVisualStyle = new AxisStripeVisualStyle();

                    StyleVisualChangeHandler(null, _AxisStripeVisualStyle);
                }

                return (_AxisStripeVisualStyle);
            }

            set
            {
                if (_AxisStripeVisualStyle != value)
                {
                    AxisStripeVisualStyle oldValue = _AxisStripeVisualStyle;

                    _AxisStripeVisualStyle = value;

                    OnVisualStyleChanged("AxisStripeVisualStyle", oldValue, value);

                    if (oldValue != null)
                        oldValue.Dispose();
                }
            }
        }

        #endregion

        #region IsDisplayed

        ///<summary>
        /// Gets whether the Stripe is displayed (must be Visible
        /// and appropriately 'checked' if presented in the Legend).
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsDisplayed
        {
            get
            {
                return ((Visible == true) &&
                        (ShowCheckBoxInLegend == false || CheckedInLegend == true));
            }
        }

        #endregion

        #region MaxValue

        ///<summary>
        /// Gets or sets the maximum axis stripe value.
        ///</summary>
        [DefaultValue(null), Category("Data")]
        [Description("Indicates the maximum axis stripe value.")]
        [TypeConverter("DevComponents.Charts.Design.PointValueConverter, DevComponents.Charts.Design," +
            "Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
        public object MaxValue
        {
            get { return (_MaxValue); }

            set
            {
                if (value != _MaxValue)
                {
                    _MaxValue = value;

                    OnPropertyChangedEx("MaxValue", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region MinValue

        ///<summary>
        /// Gets or sets the minimum axis stripe value.
        ///</summary>
        [DefaultValue(null), Category("Data")]
        [Description("Indicates the minimum axis stripe value.")]
        [TypeConverter("DevComponents.Charts.Design.PointValueConverter, DevComponents.Charts.Design," +
            "Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
        public object MinValue
        {
            get { return (_MinValue); }

            set
            {
                if (value != _MinValue)
                {
                    _MinValue = value;

                    OnPropertyChangedEx("MinValue", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #endregion

        #region MeasureOverride

        protected override void MeasureOverride(ChartLayoutInfo layoutInfo)
        {
        }

        #endregion

        #region ArrangeOverride

        protected override void ArrangeOverride(ChartLayoutInfo layoutInfo)
        {
        }

        #endregion

        #region RenderOverride

        protected override void RenderOverride(ChartRenderInfo renderInfo)
        {
        }

        #endregion

        #region Style support

        #region InvalidateStyle

        ///<summary>
        ///Invalidate the cached Styles
        ///</summary>
        public void InvalidateStyle()
        {
            ClearEffectiveStyles();
        }

        #endregion

        #region ClearEffectiveStyles

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

            if (LegendItem != null)
                LegendItem.EffectiveStyles.InvalidateStyles();
        }

        #endregion

        #region StyleChanged

        protected override void StyleChanged(object sender, PropertyChangedEventArgs e)
        {
            base.StyleChanged(sender, e);

            if (sender is ChartLegendItemVisualStyles && LegendItem != null)
                InvalidateRender(LegendItem.Bounds);
        }

        #endregion

        #endregion

        #region ILegendItem

        #region ChartLegendItemVisualStyles

        /// <summary>
        /// Gets or sets the visual styles for the Legend item.
        /// </summary>
        [Category("Style")]
        [Description("Indicates the visual styles for the Legend item.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartLegendItemVisualStyles ChartLegendItemVisualStyles
        {
            get
            {
                if (_ChartLegendItemVisualStyles == null)
                {
                    _ChartLegendItemVisualStyles = new ChartLegendItemVisualStyles();

                    StyleVisualChangeHandler(null, _ChartLegendItemVisualStyles);
                }

                return (_ChartLegendItemVisualStyles);
            }

            set
            {
                if (_ChartLegendItemVisualStyles != value)
                {
                    ChartLegendItemVisualStyles oldValue = _ChartLegendItemVisualStyles;

                    _ChartLegendItemVisualStyles = value;

                    OnStyleChanged("ChartLegendItemVisualStyles", oldValue, value);

                    if (oldValue != null)
                        oldValue.Dispose();
                }
            }
        }

        #endregion

        #region CheckedInLegend

        /// <summary>
        /// Gets or sets whether the ReferenceLine is checked in the Legend.
        /// </summary>
        [DefaultValue(true), Category("Legend")]
        [Description("Indicates whether the ReferenceLine is checked in the Legend.")]
        public bool CheckedInLegend
        {
            get { return (TestState(States.CheckedInLegend)); }

            set
            {
                if (value != CheckedInLegend)
                {
                    SetState(States.CheckedInLegend, value);

                    if (LegendItem != null)
                        LegendItem.UpdateCheckState();
                    
                    OnPropertyChangedEx("CheckedInLegend", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region ShowCheckBoxInLegend

        /// <summary>
        /// Gets or sets whether a checkbox for the ReferenceLine is shown in the Legend.
        /// </summary>
        [DefaultValue(true), Category("Legend")]
        [Description("Indicates whether a checkbox for the ReferenceLine is shown in the Legend.")]
        public bool ShowCheckBoxInLegend
        {
            get { return (TestState(States.ShowCheckBoxInLegend)); }

            set
            {
                if (value != ShowCheckBoxInLegend)
                {
                    SetState(States.ShowCheckBoxInLegend, value);

                    OnPropertyChangedEx("ShowCheckBoxInLegend", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ShowInLegend

        /// <summary>
        /// Gets or sets whether the ReferenceLine is shown in the Legend.
        /// </summary>
        [DefaultValue(true), Category("Legend")]
        [Description("Indicates whether the ReferenceLine is shown in the Legend.")]
        public bool ShowInLegend
        {
            get { return (TestState(States.ShowInLegend)); }

            set
            {
                if (value != ShowInLegend)
                {
                    SetState(States.ShowInLegend, value);

                    OnPropertyChangedEx("ShowInLegend", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ShowInParentLegend

        /// <summary>
        /// Gets or sets whether the Reference Line is shown in parent Legend(s).
        /// </summary>
        [DefaultValue(true), Category("Legend")]
        [Description("Indicates whether the Reference Line is shown in parent Legend(s).")]
        public bool ShowInParentLegend
        {
            get { return (TestState(States.ShowInParentLegend)); }

            set
            {
                if (value != ShowInParentLegend)
                {
                    SetState(States.ShowInParentLegend, value);

                    OnPropertyChangedEx("ShowInParentLegend", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ShowMarkerInLegend

        /// <summary>
        /// Gets or sets whether the ReferenceLine Marker is shown in the Legend.
        /// </summary>
        [DefaultValue(true), Category("Legend")]
        [Description("Indicates whether the ReferenceLine Marker is shown in the Legend.")]
        public bool ShowMarkerInLegend
        {
            get { return (TestState(States.ShowMarkerInLegend)); }

            set
            {
                if (value != ShowMarkerInLegend)
                {
                    SetState(States.ShowMarkerInLegend, value);

                    OnPropertyChangedEx("ShowMarkerInLegend", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region LegendItem

        ///<summary>
        /// Gets the item's parent LegendItem.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Indicates the item's parent LegendItem.")]
        public ChartLegendItem LegendItem
        {
            get { return (_LegendItem); }
            internal set { _LegendItem = value; }
        }

        #endregion

        #region LegendText

        ///<summary>
        /// Gets or sets the text to display in the legend.
        ///</summary>
        [DefaultValue(null), Category("Legend")]
        [Description("Indicates the text to display in the legend.")]
        [NotifyParentProperty(true)]
        public string LegendText
        {
            get { return (_LegendText); }

            set
            {
                if (value != _LegendText)
                {
                    _LegendText = value;

                    OnPropertyChangedEx("LegendText", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region GetLegendItem

        /// <summary>
        /// Creates the LegendItem for the AxisStripe.
        /// </summary>
        /// <returns></returns>
        public ChartLegendItem GetLegendItem()
        {
            _LegendItem = null;

            if (ShowInLegend == true)
            {
                _LegendItem = new ChartLegendItem();

                if (CheckedInLegend == true)
                    _LegendItem.CheckState = CheckState.Checked;

                _LegendItem.Name = Name;
                _LegendItem.ItemText = LegendText;

                if (string.IsNullOrEmpty(_LegendItem.Name) == true)
                    _LegendItem.Name = "(RefLine)";

                _LegendItem.ChartItems.Add(this);
            }

            return (_LegendItem);
        }

        #endregion

        #region GetLegendItems

        /// <summary>
        /// Creates a list of legend items associated with
        /// the AxisStripe.
        /// </summary>
        /// <returns></returns>
        public List<ChartLegendItem> GetLegendItems()
        {
            List<ChartLegendItem> list = null;

            ChartLegendItem item = GetLegendItem();

            if (item != null)
            {
                list = new List<ChartLegendItem>(1);

                list.Add(item);
            }

            return (list);
        }

        #endregion

        #region GetLegendItemColor

        /// <summary>
        /// Gets the default color associated with the
        /// AxisStripe legend item.
        /// </summary>
        /// <returns></returns>
        public Color GetLegendItemColor()
        {
            AxisStripeVisualStyle astyle = AxisStripeVisualStyle;

            Color color = astyle.Background.Color1;

            if (color.IsEmpty == false)
                return (color);

            return (Color.DimGray);
        }

        #endregion

        #region RenderLegendItemMarker

        /// <summary>
        /// Renders the Legend item Marker.
        /// </summary>
        /// <param name="g"></param>
        /// <param name="litem"></param>
        /// <param name="style"></param>
        public void RenderLegendItemMarker(Graphics g,
            ChartLegendItem litem, ChartLegendItemVisualStyle style)
        {
            AxisStripeVisualStyle astyle = AxisStripeVisualStyle;

            Rectangle bounds = litem.MarkerBounds;

            if (astyle.Background.IsEmpty == true)
            {
                g.FillRectangle(Brushes.LightPink, bounds);
            }
            else
            {
                using (Brush br = astyle.Background.GetBrush(bounds))
                    g.FillRectangle(br, bounds);
            }
        }

        #endregion

        #endregion

        #region Copy/CopyTo

        /// <summary>
        /// Creates a copy of the element.
        /// </summary>
        /// <returns></returns>
        public override ChartVisualElement Copy()
        {
            AxisStripe copy = new AxisStripe();

            CopyTo(copy);

            return (copy);
        }

        /// <summary>
        /// Copies the current element properties and styles 
        /// to the provided "copy".
        /// </summary>
        /// <param name="copy"></param>
        public override void CopyTo(ChartVisualElement copy)
        {
            AxisStripe c = copy as AxisStripe;

            if (c != null)
            {
                base.CopyTo(c);

                c.AxisStripeVisualStyle =  (_AxisStripeVisualStyle != null) ? _AxisStripeVisualStyle.Copy() : null;
                c.ChartLegendItemVisualStyles = (_ChartLegendItemVisualStyles != null) ? ChartLegendItemVisualStyles.Copy() : null;

                c.MaxValue = MaxValue;
                c.MinValue = MinValue;

                c.CheckedInLegend = CheckedInLegend;
                c.ShowCheckBoxInLegend = ShowCheckBoxInLegend;
                c.ShowInLegend = ShowInLegend;
                c.ShowInParentLegend = ShowInParentLegend;
                c.LegendText = LegendText;
                c.ShowMarkerInLegend = ShowMarkerInLegend;
            }
        }

        #endregion

        #region GetSerialData

        internal override SerialElementCollection GetSerialData(string serialName)
        {
            SerialElementCollection sec = new SerialElementCollection();

            if (serialName != null)
            {
                if (serialName.Equals("") == true)
                    serialName = "ChartAxis";

                sec.AddStartElement(serialName);
            }

            if (_AxisStripeVisualStyle != null && _AxisStripeVisualStyle.IsEmpty == false)
                sec.AddElement(_AxisStripeVisualStyle.GetSerialData("AxisStripeVisualStyle"));

            if (_ChartLegendItemVisualStyles != null)
                sec.AddElement(_ChartLegendItemVisualStyles.GetSerialData("ChartLegendItemVisualStyles"));

            sec.AddDataValue("MaxValue", MaxValue, null);
            sec.AddDataValue("MinValue", MinValue, null);

            sec.AddValue("CheckedInLegend", CheckedInLegend, true);
            sec.AddValue("LegendText", LegendText, null);
            sec.AddValue("ShowCheckBoxInLegend", ShowCheckBoxInLegend, true);
            sec.AddValue("ShowInLegend", ShowInLegend, true);
            sec.AddValue("ShowInParentLegend", ShowInParentLegend, true);
            sec.AddValue("ShowMarkerInLegend", ShowMarkerInLegend, true);

            sec.AddElement(base.GetSerialData(null));

            if (serialName != null)
                sec.AddEndElement(serialName);

            return (sec);
        }

        #endregion

        #region PutSerialData

        #region ProcessValue

        internal override void ProcessValue(SerialElement se)
        {
            switch (se.Name)
            {
                case "CheckedInLegend":
                    CheckedInLegend = bool.Parse(se.StringValue);
                    break;

                case "LegendText":
                    LegendText = se.StringValue;
                    break;

                case "MaxValue":
                    MaxValue = se.DataValue;
                    break;

                case "MinValue":
                    MinValue = se.DataValue;
                    break;

                case "ShowCheckBoxInLegend":
                    ShowCheckBoxInLegend = bool.Parse(se.StringValue);
                    break;

                case "ShowInLegend":
                    ShowInLegend = bool.Parse(se.StringValue);
                    break;

                case "ShowInParentLegend":
                    ShowInParentLegend = bool.Parse(se.StringValue);
                    break;

                case "ShowMarkerInLegend":
                    ShowMarkerInLegend = bool.Parse(se.StringValue);
                    break;

                default:
                    base.ProcessValue(se);
                    break;
            }
        }

        #endregion

        #region ProcessCollection

        internal override void ProcessCollection(SerialElement se)
        {
            SerialElementCollection sec = se.Sec;

            switch (se.Name)
            {
                case "AxisStripeVisualStyle":
                    sec.PutSerialData(AxisStripeVisualStyle);
                    break;

                case "ChartLegendItemVisualStyles":
                    sec.PutSerialData(ChartLegendItemVisualStyles);
                    break;

                default:
                    base.ProcessCollection(se);
                    break;
            }
        }

        #region GetAncillaryAxis

        private ChartAxis GetAncillaryAxis(ChartAxesCollection axes, string name)
        {
            foreach (ChartAxis axis in axes)
            {
                if (name.Equals(axis.Name) == true)
                    return (axis);
            }

            return (null);
        }

        #endregion

        #endregion

        #endregion

        #region States

        [Flags]
        private enum States : uint
        {
            CheckedInLegend = (1U << 1),
            ShowCheckBoxInLegend = (1U << 2),
            ShowInLegend = (1U << 3),
            ShowInParentLegend = (1U << 4),
            ShowMarkerInLegend = (1U << 5),
        }

        #region TestState

        private bool TestState(States state)
        {
            return ((_States & state) == state);
        }

        #endregion

        #region SetState

        private void SetState(States state, bool value)
        {
            if (value == true)
                _States |= state;
            else
                _States &= ~state;
        }

        #endregion

        #endregion

        #region IDisposable

        public override void Dispose()
        {
            AxisStripeVisualStyle = null;

            base.Dispose();
        }

        #endregion
    }
}