using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;

namespace DevComponents.DotNetBar.SuperGrid.Style
{
    /// <summary>
    /// Represents the visual style of a Row.
    /// </summary>
    [ToolboxItem(false), DesignTimeVisible(false)]
    [TypeConverter(typeof(ExpandableObjectConverter))]
    public class VisualStyle : BaseVisualStyle
    {
        #region Private variables

        private Background _Background;
        private BorderColor _BorderColor;
        private BorderPattern _BorderPattern;
        private Thickness _BorderThickness;

        private Color _TextColor = Color.Empty;

        private Padding _Margin;
        private Padding _Padding;

        private Font _Font;

        #endregion

        #region Public properties

        #region Background

        /// <summary>
        /// Gets or sets the style background.
        /// </summary>
        [Description("Indicates the style background")]
        public Background Background
        {
            get
            {
                if (_Background == null)
                {
                    _Background = Background.Empty;

                    UpdateChangeHandler(null, _Background);
                }

                return (_Background);
            }

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

                    _Background = value;

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

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

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

        #endregion

        #region BorderColor

        /// <summary>
        /// Gets or sets the style border color.
        /// </summary>
        [Description("Indicates the style Border Color")]
        public BorderColor BorderColor
        {
            get
            {
                if (_BorderColor == null)
                {
                    _BorderColor = BorderColor.Empty;

                    UpdateChangeHandler(null, _BorderColor);
                }

                return (_BorderColor);
            }

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

                    _BorderColor = value;

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

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

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

        #endregion

        #region BorderPattern

        /// <summary>
        /// Gets or sets the style border pattern (Solid, Dash, ...)
        /// </summary>
        [Description("Indicates the style border pattern (Solid, Dash, ...)")]
        public BorderPattern BorderPattern
        {
            get
            {
                if (_BorderPattern == null)
                {
                    _BorderPattern = BorderPattern.Empty;

                    UpdateChangeHandler(null, _BorderPattern);
                }

                return (_BorderPattern);
            }

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

                    _BorderPattern = value;

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

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

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

        #endregion

        #region BorderThickness

        /// <summary>
        /// Gets or sets the style border thickness.
        /// </summary>
        [Description("Indicates the style border thickness")]
        public Thickness BorderThickness
        {
            get
            {
                if (_BorderThickness == null)
                {
                    _BorderThickness = Thickness.Empty;

                    UpdateChangeHandler(null, _BorderThickness);
                }

                return (_BorderThickness);
            }

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

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

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

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

        #endregion

        #region Font

        /// <summary>
        /// Gets or sets the style Font
        /// </summary>
        [DefaultValue(null)]
        [Description("Indicates the style Font")]
        public Font Font
        {
            get { return (_Font); }

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

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

        #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 ((_Background == null || _Background.IsEmpty == true) &&
                        (_BorderColor == null || _BorderColor.IsEmpty == true) &&
                        (_BorderPattern == null || _BorderPattern.IsEmpty == true) &&
                        (_BorderThickness == null || _BorderThickness.IsEmpty == true) &&
                        (_Margin == null || _Margin.IsEmpty == true) &&
                        (_Padding == null || _Padding.IsEmpty == true) &&
                        (_Font == null) &&
                        (_TextColor.IsEmpty == true || _TextColor == Color.Black) &&

                        (base.IsEmpty == true)); }
        }

        #endregion

        #region Margin

        /// <summary>
        /// Gets or sets the spacing between the border and outside content.
        /// </summary>
        [Description("Indicates the spacing between the border and outside content")]
        public Padding Margin
        {
            get
            {
                if (_Margin == null)
                {
                    _Margin = Padding.Empty;

                    UpdateChangeHandler(null, _Margin);
                }

                return (_Margin);
            }

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

                    _Margin = value;

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

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

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

        #endregion

        #region Padding

        /// <summary>
        /// Gets or sets spacing between the content and edges of the element.
        /// </summary>
        [Description("Indicates the spacing between the content and edges of the element")]
        public Padding Padding
        {
            get
            {
                if (_Padding == null)
                {
                    _Padding = Padding.Empty;

                    UpdateChangeHandler(null, _Padding);
                }

                return (_Padding);
            }

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

                    _Padding = value;

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

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

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

        #endregion

        #region TextColor

        /// <summary>
        /// Gets or sets the Text color
        /// </summary>
        [Description("Indicates the Text color")]
        public Color TextColor
        {
            get { return (_TextColor); }

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

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

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

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

        #endregion

        #endregion

        #region ApplyStyle

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

                if (style._Background != null && style._Background.IsEmpty == false)
                    Background = style._Background.Copy();

                if (style._BorderColor != null && style._BorderColor.IsEmpty == false)
                    BorderColor = style._BorderColor.Copy();

                if (style._BorderPattern != null && style._BorderPattern.IsEmpty == false)
                    BorderPattern.ApplyPattern(style._BorderPattern);

                if (style._BorderThickness != null && style._BorderThickness.IsZero == false)
                    BorderThickness = style._BorderThickness.Copy();

                if (style.Font != null)
                    Font = style.Font;

                if (style._Margin != null && style._Margin.IsEmpty == false)
                    Margin = style.Margin.Copy();

                if (style._Padding != null && style._Padding.IsEmpty == false)
                    Padding = style.Padding.Copy();

                if (style._TextColor.IsEmpty == false)
                    TextColor = style._TextColor;
            }
        }

        #endregion

        #region RenderBorder

        internal void RenderBorder(Graphics g, Rectangle r)
        {
            if (_BorderPattern == null || BorderThickness == null || BorderColor == null)
                return;

            SmoothingMode sm = g.SmoothingMode;
            g.SmoothingMode = SmoothingMode.None;

            if (BorderColor.IsUniform == true &&
                BorderThickness.IsUniform == true && BorderPattern.IsUniform == true)
            {
                if (_BorderPattern.Top != LinePattern.None  &&
                    (_BorderThickness.Top > 0 && _BorderColor.Top.IsEmpty == false))
                {
                    using (Pen pen = new 
                        Pen(_BorderColor.Top, Dpi.Width(_BorderThickness.Top)))
                    {
                        LinePattern pattern = (_BorderPattern.Top == LinePattern.NotSet)
                            ? LinePattern.Solid : _BorderPattern.Top;

                        if (pen.Width == 1)
                        {
                            r.Width--;
                            r.Height--;
                        }
                        else
                        {
                            pen.Alignment = PenAlignment.Inset;
                        }

                        pen.DashStyle = (DashStyle)pattern;

                        g.DrawRectangle(pen, r);
                    }
                }
            }
            else
            {
                Pen[] pens = GetBorderPens();

                if (pens[(int) BorderSide.Right] != null)
                {
                    int right = r.Right - 
                        (Dpi.Width(_BorderThickness.Right) + 1) / 2;

                    g.DrawLine(pens[(int)BorderSide.Right],
                        right, r.Top, right, r.Bottom - 1);
                }

                if (pens[(int) BorderSide.Bottom] != null)
                {
                    int bottom = r.Bottom - 
                        (Dpi.Height(_BorderThickness.Bottom) + 1) / 2;

                    g.DrawLine(pens[(int)BorderSide.Bottom],
                        r.X, bottom, r.Right - 1, bottom);
                }

                if (pens[(int)BorderSide.Left] != null)
                {
                    int left = r.Left + Dpi.Width(_BorderThickness.Left) / 2;

                    g.DrawLine(pens[(int)BorderSide.Left],
                        left, r.Top, left, r.Bottom - 1);
                }

                if (pens[(int)BorderSide.Top] != null)
                {
                    int top = r.Top + Dpi.Height(_BorderThickness.Top) / 2;

                    g.DrawLine(pens[(int) BorderSide.Top],
                        r.X, top, r.Right - 1, top);
                }

                foreach (Pen pen in pens)
                {
                    if (pen != null)
                        pen.Dispose();
                }
            }

            g.SmoothingMode = sm;
        }

        #endregion

        #region GetBorderSize

        internal Size GetBorderSize(bool inclPadding)
        {
            Size size = Size.Empty;

            size.Width += (BorderThickness.Horizontal + Margin.Horizontal);
            size.Height += (BorderThickness.Vertical + Margin.Vertical);

            if (inclPadding == true)
            {
                size.Width += Padding.Horizontal;
                size.Height += Padding.Vertical;
            }

            return (Dpi.Size(size));
        }

        #endregion

        #region GetBorderPens

        internal Pen[] GetBorderPens()
        {
            Pen[] pens = new Pen[4];

            pens[(int)BorderSide.Top] = GetBorderPen(pens,
                BorderColor.Top, Dpi.Height(BorderThickness.Top), BorderPattern.Top);

            pens[(int)BorderSide.Left] = GetBorderPen(pens,
                BorderColor.Left, Dpi.Width(BorderThickness.Left), BorderPattern.Left);

            pens[(int)BorderSide.Bottom] = GetBorderPen(pens,
                BorderColor.Bottom, Dpi.Height(BorderThickness.Bottom), BorderPattern.Bottom);

            pens[(int)BorderSide.Right] = GetBorderPen(pens,
                BorderColor.Right, Dpi.Width(BorderThickness.Right), BorderPattern.Right);

            return (pens);
        }

        #endregion

        #region GetBorderPen

        private Pen GetBorderPen(IEnumerable<Pen> pens,
            Color color, int width, LinePattern pattern)
        {
            if (color.IsEmpty == true ||
                pattern == LinePattern.None || width <= 0)
            {
                return (null);
            }

            foreach (Pen pen in pens)
            {
                if (pen != null)
                {
                    if (pen.Color == color && pen.Width == width &&
                        pen.DashStyle == (DashStyle)pattern)
                    {
                        return (pen);
                    }
                }
            }

            Pen npen = new Pen(color, width);

            if (pattern == LinePattern.NotSet)
                pattern = LinePattern.Solid;

            npen.DashStyle = (DashStyle)pattern;

            return (npen);
        }

        #endregion

        #region Copy

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

            CopyTo(style);

            return (style);
        }

        #endregion

        #region CopyTo

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

            copy.TextColor = _TextColor;

            if (_Background != null)
                copy.Background = _Background.Copy();

            if (_BorderColor != null)
                copy.BorderColor = _BorderColor.Copy();

            if (_BorderPattern != null)
                copy.BorderPattern = _BorderPattern.Copy();

            if (_BorderPattern != null)
                copy.BorderPattern = _BorderPattern.Copy();

            if (_BorderThickness != null)
                copy.BorderThickness = _BorderThickness.Copy();

            if (_Font != null)
                copy.Font = (Font)_Font.Clone();

            if (_Margin != null)
                copy.Margin = _Margin.Copy();

            if (_Padding != null)
                copy.Padding = _Padding.Copy();
        }

        #endregion

        #region IDisposable

        /// <summary>
        /// Dispose
        /// </summary>
        public override void Dispose()
        {
            Background = null;
            BorderColor = null;
            BorderPattern = null;
            BorderThickness = null;
            Margin = null;
            Padding = null;

            base.Dispose();
        }

        #endregion
    }
}