using System.ComponentModel;
using System.Drawing;

namespace DevComponents.DotNetBar.Charts.Style
{
    ///<summary>
    /// ScrollBarVisualStyle
    ///</summary>
    [TypeConverter(typeof(VisualStylesConverter))]
    public class ScrollBarVisualStyles : VisualStyles<ScrollBarVisualStyle>
    {
        #region Copy

        /// <summary>
        /// Returns the copy of the style.
        /// </summary>
        /// <returns>Copy of the style.</returns>
        public ScrollBarVisualStyles Copy()
        {
            ScrollBarVisualStyles styles = new ScrollBarVisualStyles();

            for (int i = 0; i < Styles.Length; i++)
            {
                ScrollBarVisualStyle vstyle = Styles[i];

                if (vstyle != null)
                    styles.Styles[i] = vstyle.Copy();
            }

            return (styles);
        }

        #endregion
    }

    /// <summary>
    /// Represents the visual style of a ScrollBar element.
    /// </summary>
    [TypeConverter(typeof(VisualStylesConverter))]
    public class ScrollBarVisualStyle : BaseVisualStyle
    {
        #region Private variables

        private Color _ArrowColor;
        private Color _ArrowBorderColor;
        private Background _ArrowBackground;

        private Color _ThumbColor;
        private Color _ThumbBorderColor;
        private Background _ThumbBackground;

        private Color _BorderColor;
        private Background _TrackBackground;

        private Tbool _NoAlphaOnMouseOver = Tbool.NotSet;

        #endregion

        #region Public properties

        #region ArrowBackground

        /// <summary>
        /// Gets or sets the Background of the Increase/Decrease Arrow elements of the ScrollBar.
        /// </summary>
        [Description("Indicates the Background of the Increase/Decrease Arrow elements of the ScrollBar")]
        public Background ArrowBackground
        {
            get
            {
                if (_ArrowBackground == null)
                {
                    _ArrowBackground = Background.Empty;

                    UpdateChangeHandler(null, _ArrowBackground);
                }

                return (_ArrowBackground);
            }

            set
            {
                if (value != _ArrowBackground)
                {
                    UpdateChangeHandler(_ArrowBackground, value);

                    _ArrowBackground = value;

                    OnPropertyChangedEx("ArrowBackground", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeArrowBackground()
        {
            return (_ArrowBackground != null && _ArrowBackground.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetArrowBackground()
        {
            ArrowBackground = null;
        }

        #endregion

        #region ArrowBorderColor

        /// <summary>
        /// Gets or sets the Arrow Increase/Decrease border color.
        /// </summary>
        [Description("Indicates the Arrow Increase/Decrease border color")]
        public Color ArrowBorderColor
        {
            get { return (_ArrowBorderColor); }

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

                    OnPropertyChangedEx("ArrowBorderColor", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeArrowBorderColor()
        {
            return (_ArrowBorderColor.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetArrowBorderColor()
        {
            ArrowBorderColor = Color.Empty;
        }

        #endregion
        
        #region ArrowColor

        /// <summary>
        /// Gets or sets the Color of the Increase/Decrease Arrow elements of the scrollBar.
        /// </summary>
        [Description("Indicates the Color of the Increase/Decrease Arrow elements of the scrollBar")]
        public Color ArrowColor
        {
            get { return (_ArrowColor); }

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

                    OnPropertyChangedEx("ArrowColor", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeArrowColor()
        {
            return (_ArrowColor.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetArrowColor()
        {
            ArrowColor = Color.Empty;
        }

        #endregion

        #region BorderColor

        /// <summary>
        /// Gets or sets the border color of the scrollBar.
        /// </summary>
        [Description("Indicates the Border Color of the scrollBar")]
        public Color BorderColor
        {
            get { return (_BorderColor); }

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

                    OnPropertyChangedEx("BorderColor", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeBorderColor()
        {
            return (_BorderColor.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetBorderColor()
        {
            BorderColor = Color.Empty;
        }

        #endregion

        #region NoAlphaOnMouseOver

        /// <summary>
        /// Gets or sets whether color alpha values are ignored when the mouse is over the scrollbar.
        /// </summary>
        [DefaultValue(Tbool.NotSet)]
        [Description("Indicates whether color alpha values are ignored when the mouse is over the scrollbar.")]
        public Tbool NoAlphaOnMouseOver
        {
            get { return (_NoAlphaOnMouseOver); }

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

                    OnPropertyChangedEx("NoAlphaOnMouseOver", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region ThumbBackground

        /// <summary>
        /// Gets or sets the Background of the Thumb element of the ScrollBar.
        /// </summary>
        [Description("Indicates the Background of the Thumb element of the ScrollBar")]
        public Background ThumbBackground
        {
            get
            {
                if (_ThumbBackground == null)
                {
                    _ThumbBackground = Background.Empty;

                    UpdateChangeHandler(null, _ThumbBackground);
                }

                return (_ThumbBackground);
            }

            set
            {
                if (value != _ThumbBackground)
                {
                    UpdateChangeHandler(_ThumbBackground, value);

                    _ThumbBackground = value;

                    OnPropertyChangedEx("ThumbBackground", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeThumbBackground()
        {
            return (_ThumbBackground != null && _ThumbBackground.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetThumbBackground()
        {
            ThumbBackground = null;
        }

        #endregion

        #region ThumbBorderColor

        /// <summary>
        /// Gets or sets the Thumb border color.
        /// </summary>
        [Description("Indicates the Thumb border color")]
        public Color ThumbBorderColor
        {
            get { return (_ThumbBorderColor); }

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

                    OnPropertyChangedEx("ThumbBorderColor", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeThumbBorderColor()
        {
            return (_ThumbBorderColor.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetThumbBorderColor()
        {
            ThumbBorderColor = Color.Empty;
        }

        #endregion

        #region ThumbColor

        /// <summary>
        /// Gets or sets the Color of the Thumb content element (hash marks) of the scrollBar.
        /// </summary>
        [Description("Indicates the Color of the Thumb content element (hash marks) of the scrollBar")]
        public Color ThumbColor
        {
            get { return (_ThumbColor); }

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

                    OnPropertyChangedEx("ThumbColor", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeThumbColor()
        {
            return (_ThumbColor.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetThumbColor()
        {
            ThumbColor = Color.Empty;
        }

        #endregion

        #region TrackBackground

        /// <summary>
        /// Gets or sets the Background of the Increase/Decrease Track elements of the ScrollBar.
        /// </summary>
        [Description("Indicates the Background of the Increase/Decrease Track elements of the ScrollBar")]
        public Background TrackBackground
        {
            get
            {
                if (_TrackBackground == null)
                {
                    _TrackBackground = Background.Empty;

                    UpdateChangeHandler(null, _TrackBackground);
                }

                return (_TrackBackground);
            }

            set
            {
                if (_TrackBackground != value)
                {
                    UpdateChangeHandler(_TrackBackground, value);

                    _TrackBackground = value;

                    OnPropertyChangedEx("TrackBackground", VisualChangeType.Render);
                }
            }
        }

        /// <summary>
        /// Gets whether property should be serialized.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private bool ShouldSerializeTrackBackground()
        {
            return (_TrackBackground != null && _TrackBackground.IsEmpty == false);
        }

        /// <summary>
        /// Resets property to its default value.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        private void ResetTrackBackground()
        {
            TrackBackground = null;
        }

        #endregion

        #region IsEmpty

        /// <summary>
        /// Gets whether the style is logically Empty.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Description("Gets whether the style is logically Empty.")]
        public override bool IsEmpty
        {
            get
            {
                return ((_ArrowBackground == null || _ArrowBackground.IsEmpty) &&
                    (_ArrowBorderColor.IsEmpty) &&
                    (_ArrowColor.IsEmpty) &&
                    (_BorderColor.IsEmpty) &&
                    (_NoAlphaOnMouseOver == Tbool.NotSet) &&
                    (_ThumbBackground == null || _ThumbBackground.IsEmpty) &&
                    (_ThumbBorderColor.IsEmpty) &&
                    (_ThumbColor.IsEmpty) &&
                    (_TrackBackground == null || _TrackBackground.IsEmpty) &&
                    (base.IsEmpty == true));
            }
        }

        #endregion

        #endregion

        #region GetColor

        internal Color GetColor(Color color, bool noAlpha)
        {
            if (noAlpha == false)
                return (color);

            uint argb = (uint)color.ToArgb() | 0xff000000;

            return (Color.FromArgb((int)argb));
        }

        #endregion

        #region ApplyStyle

        /// <summary>
        /// Applies the style to instance of this style.
        /// </summary>
        /// <param name="style">Style to apply.</param>
        public void ApplyStyle(ScrollBarVisualStyle style)
        {
            if (style != null)
            {
                base.ApplyStyle(style);

                if (style.ArrowBackground.IsEmpty == false)
                    ArrowBackground = style.ArrowBackground.Copy();

                if (style.ArrowBorderColor.IsEmpty == false)
                    ArrowBorderColor = style.ArrowBorderColor;

                if (style.ArrowColor.IsEmpty == false)
                    ArrowColor = style.ArrowColor;

                if (style.BorderColor.IsEmpty == false)
                    BorderColor = style.BorderColor;

                if (style.NoAlphaOnMouseOver != Tbool.NotSet)
                    NoAlphaOnMouseOver = style.NoAlphaOnMouseOver;

                if (style.ThumbBackground.IsEmpty == false)
                    ThumbBackground = style.ThumbBackground.Copy();

                if (style.ThumbBorderColor.IsEmpty == false)
                    ThumbBorderColor = style.ThumbBorderColor;

                if (style.ThumbColor.IsEmpty == false)
                    ThumbColor = style.ThumbColor;

                if (style.TrackBackground.IsEmpty == false)
                    TrackBackground = style.TrackBackground.Copy();
            }
        }

        #endregion

        #region ApplyDefaults

        public override void ApplyDefaults()
        {
            if (ArrowBackground.IsEmpty)
                ArrowBackground = new Background(Color.Gainsboro);

            if (ThumbBackground.IsEmpty)
                ThumbBackground = new Background(Color.White, Color.Gainsboro);

            if (TrackBackground.IsEmpty)
                TrackBackground = new Background(Color.Gainsboro);

            if (BorderColor.IsEmpty)
                BorderColor = Color.Gray;

            if (ThumbBorderColor.IsEmpty)
                ThumbBorderColor = Color.Gray;

            if (ArrowColor.IsEmpty)
                ArrowColor = Color.DimGray;

            if (ThumbColor.IsEmpty)
                ThumbColor = Color.Black;

            if (ArrowBorderColor.IsEmpty)
                ArrowBorderColor = Color.Gray;

            if (NoAlphaOnMouseOver == Tbool.NotSet)
                NoAlphaOnMouseOver = Tbool.False;

            base.ApplyDefaults();
        }

        #endregion

        #region Copy

        /// <summary>
        /// Returns the copy of the style.
        /// </summary>
        /// <returns>Copy of the style.</returns>
        public new ScrollBarVisualStyle Copy()
        {
            ScrollBarVisualStyle style = new ScrollBarVisualStyle();

            CopyTo(style);

            return (style);
        }

        #endregion

        #region CopyTo

        /// <summary>
        /// Returns the copy of the style.
        /// </summary>
        /// <returns>Copy of the style.</returns>
        public void CopyTo(ScrollBarVisualStyle style)
        {
            base.CopyTo(style);

            style.ArrowBackground = (_ArrowBackground != null ? _ArrowBackground.Copy() : null);

            style.ArrowBorderColor = _ArrowBorderColor;
            style.ArrowColor = _ArrowColor;
            style.BorderColor = _BorderColor;
            style.NoAlphaOnMouseOver = _NoAlphaOnMouseOver;

            style.ThumbBackground = (_ThumbBackground != null ? _ThumbBackground.Copy() : null);

            style.ThumbBorderColor = _ThumbBorderColor;
            style.ThumbColor = _ThumbColor;

            style.TrackBackground = (_TrackBackground != null ? _TrackBackground.Copy() : null);
        }

        #endregion

        #region GetSerialData

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

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

                sec.AddStartElement(serialName);
            }

            if (_ArrowBackground != null && _ArrowBackground.IsEmpty == false)
                sec.AddElement(_ArrowBackground.GetSerialData("ArrowBackground"));

            sec.AddValue("ArrowBorderColor", ArrowBorderColor, Color.Empty);
            sec.AddValue("ArrowColor", ArrowColor, Color.Empty);
            sec.AddValue("BorderColor", BorderColor, Color.Empty);
            sec.AddValue("NoAlphaOnMouseOver", NoAlphaOnMouseOver, Tbool.NotSet);

            if (_ThumbBackground != null && _ThumbBackground.IsEmpty == false)
                sec.AddElement(_ThumbBackground.GetSerialData("ThumbBackground"));

            sec.AddValue("ThumbBorderColor", ThumbBorderColor, Color.Empty);
            sec.AddValue("ThumbColor", ThumbColor, Color.Empty);

            if (_TrackBackground != null && _TrackBackground.IsEmpty == false)
                sec.AddElement(_TrackBackground.GetSerialData("TrackBackground"));

            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 "ArrowBorderColor":
                    ArrowBorderColor = se.GetValueColor();
                    break;

                case "ArrowColor":
                    ArrowColor = se.GetValueColor();
                    break;

                case "BorderColor":
                    BorderColor = se.GetValueColor();
                    break;

                case "NoAlphaOnMouseOver":
                    NoAlphaOnMouseOver = (Tbool)se.GetValueEnum(typeof(Tbool));
                    break;

                case "ThumbBorderColor":
                    ThumbBorderColor = se.GetValueColor();
                    break;

                case "ThumbColor":
                    ThumbColor = se.GetValueColor();
                    break;

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

        #endregion

        #region ProcessCollection

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

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

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

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

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

        #endregion

        #endregion

        #region IDisposable

        public override void Dispose()
        {
            ArrowBackground = null;
            ThumbBackground = null;
            TrackBackground = null;

            base.Dispose();
        }

        #endregion
    }
}