namespace AntdWpf.Controls
{
    using System;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Windows;
    using System.Windows.Documents;
    using System.Windows.Media;

    using AntdWpf.Utils;

    /// <summary>
    /// Semantic vector graphics.
    /// </summary>
    public class Icon : FrameworkElement, ISpinable
    {
        #region Fields

        private Geometry definingGeometry;

        #endregion

        #region Document Properties

        /// <summary>
        /// DependencyProperty for <see cref="FontSize" /> property.
        /// </summary>
        public static readonly DependencyProperty FontSizeProperty =
            TextElement.FontSizeProperty.AddOwner(typeof(Icon));

        /// <summary>
        /// The FontSize property specifies the size of the font.
        /// </summary>
        [TypeConverter(typeof(FontSizeConverter))]
        [Localizability(LocalizationCategory.None)]
        public double FontSize
        {
            get { return (double)GetValue(FontSizeProperty); }
            set { SetValue(FontSizeProperty, value); }
        }

        /// <summary>
        /// DependencyProperty setter for <see cref="FontSize" /> property.
        /// </summary>
        /// <param name="element">The element to which to write the attached property.</param>
        /// <param name="value">The property value to set</param>
        public static void SetFontSize(DependencyObject element, double value)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            element.SetValue(FontSizeProperty, value);
        }

        /// <summary>
        /// DependencyProperty getter for <see cref="FontSize" /> property.
        /// </summary>
        /// <param name="element">The element from which to read the attached property.</param>
        [TypeConverter(typeof(FontSizeConverter))]
        public static double GetFontSize(DependencyObject element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            return (double)element.GetValue(FontSizeProperty);
        }

        /// <summary>
        /// DependencyProperty for <see cref="Foreground" /> property.
        /// </summary>
        public static readonly DependencyProperty ForegroundProperty =
            TextElement.ForegroundProperty.AddOwner(typeof(Icon));

        /// <summary>
        /// The Foreground property specifies the foreground brush of an element's text content.
        /// </summary>
        public Brush Foreground
        {
            get { return (Brush)GetValue(ForegroundProperty); }
            set { SetValue(ForegroundProperty, value); }
        }

        /// <summary>
        /// DependencyProperty setter for <see cref="Foreground" /> property.
        /// </summary>
        /// <param name="element">The element to which to write the attached property.</param>
        /// <param name="value">The property value to set</param>
        public static void SetForeground(DependencyObject element, Brush value)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            element.SetValue(ForegroundProperty, value);
        }

        /// <summary>
        /// DependencyProperty getter for <see cref="Foreground" /> property.
        /// </summary>
        /// <param name="element">The element from which to read the attached property.</param>
        public static Brush GetForeground(DependencyObject element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            return (Brush)element.GetValue(ForegroundProperty);
        }

        public static readonly DependencyProperty BackgroundProperty =
         TextElement.BackgroundProperty.AddOwner(
                 typeof(Icon),
                 new FrameworkPropertyMetadata(
                         Brushes.Transparent,
                         FrameworkPropertyMetadataOptions.AffectsRender));

        /// <summary>
        /// The Background property defines the brush used to fill the content area.
        /// </summary>
        public Brush Background
        {
            get { return (Brush)GetValue(BackgroundProperty); }
            set { SetValue(BackgroundProperty, value); }
        }

        #endregion

        #region Properties

        /// <summary>
        /// Get the geometry that defines this icon.
        /// </summary>
        protected Geometry DefiningGeometry
        {
            get
            {
                if (definingGeometry == null)
                {
                    if (!string.IsNullOrEmpty(Type))
                    {
                        var key = "anticon." + Type.ToLower();

                        // With theme suffix.
                        if (Theme == IconTheme.Filled)
                        {
                            key += ".fill";
                        } else if (Theme == IconTheme.Colorful)
                        {
                            key += ".colorful";
                        }

                        definingGeometry = TryFindResource(key) as Geometry ?? Geometry.Empty;
                    }
                    else
                    {
                        definingGeometry = Geometry.Empty;
                    }
                }

                return definingGeometry;
            }
        }

        public static readonly DependencyProperty TypeProperty =
            DependencyProperty.Register("Type", typeof(string), typeof(Icon),
                new FrameworkPropertyMetadata(null, 
                    FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, OnSpinChanged));

        /// <summary>
        /// Gets/sets the type of the ant design icon.
        /// </summary>
        public string Type
        {
            get { return (string)GetValue(TypeProperty); }
            set { SetValue(TypeProperty, value); }
        }

        public static readonly DependencyProperty ThemeProperty =
            DependencyProperty.Register("Theme", typeof(IconTheme), typeof(Icon), 
                new FrameworkPropertyMetadata(IconTheme.Outlined, FrameworkPropertyMetadataOptions.AffectsRender));


        /// <summary>
        /// Gets/sets the theme of the ant design icon.
        /// </summary>
        public IconTheme Theme
        {
            get { return (IconTheme)GetValue(ThemeProperty); }
            set { SetValue(ThemeProperty, value); }
        }

        public static readonly DependencyProperty SpinProperty =
            DependencyProperty.Register("Spin", typeof(bool?), typeof(Icon), new PropertyMetadata(null, OnSpinChanged));

        /// <summary>
        /// Gets/sets whether the icon has a spin animation.
        /// </summary>
        public bool? Spin
        {
            get { return (bool?)GetValue(SpinProperty); }
            set { SetValue(SpinProperty, value); }
        }

        private static void OnSpinChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            (d as Icon).SetSpinAnimation();
        }

        #endregion

        #region Attached Propperties

        /// <summary>
        /// Why is it not a dependency property?
        /// icons are introduced by way of resources. if you define them as dependency properties, you will lose more flexibility.
        /// For example, each icon needs to use different stretch parameters.
        /// </summary>
        public static readonly DependencyProperty ViewBoxProperty =
            DependencyProperty.RegisterAttached("ViewBox", typeof(Rect), typeof(Icon), new PropertyMetadata(new Rect(0, 0, 1024, 1024)), OnViewBoxValidate);

        private static bool OnViewBoxValidate(object value)
        {
            var viewBox = (Rect)value;
            return viewBox.IsEmpty || (viewBox.Width >= 0 && viewBox.Height >= 0);
        }

        /// <summary>
        /// Gets the rectangular area of the geometric stretch.
        /// </summary>
        [AttachedPropertyBrowsableForType(typeof(Geometry))]
        public static Rect GetViewBox(DependencyObject obj)
        {
            return (Rect)obj.GetValue(ViewBoxProperty);
        }

        /// <summary>
        /// Sets the rectangular area of the geometric stretch.
        /// </summary>
        public static void SetViewBox(DependencyObject obj, Rect value)
        {
            obj.SetValue(ViewBoxProperty, value);
        }

        /// <summary>
        /// When you need colorful icons, you need to be able to support custom brushes.
        /// </summary>
        public static readonly DependencyProperty FillProperty =
            DependencyProperty.RegisterAttached("Fill", typeof(Brush), typeof(Icon), new PropertyMetadata(null));

        /// <summary>
        /// Gets the brush that fill the geometry.
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        [AttachedPropertyBrowsableForType(typeof(Geometry))]
        public static Brush GetFill(DependencyObject obj)
        {
            return (Brush)obj.GetValue(FillProperty);
        }

        /// <summary>
        /// Sets the brush to fill the geometry. Valid when Theme is colorful.
        /// </summary>
        public static void SetFill(DependencyObject obj, Brush value)
        {
            obj.SetValue(FillProperty, value);
        }

        #endregion

        #region Constructors

        static Icon()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(Icon), new FrameworkPropertyMetadata(typeof(Icon)));
        }

        public Icon()
        {
            Loaded += (s, e) => SetSpinAnimation();
        }

        #endregion

        #region Overrides

        /// <summary>
        /// Notification that a specified property has been invalidated.
        /// </summary>
        /// <param name="e">EventArgs that contains the property, metadata, old value, and new value for this change</param>
        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
        {
            if (e.NewValue != e.OldValue && (e.Property == TypeProperty || e.Property == ThemeProperty))
            {
                // Reset definition geometry.
                definingGeometry = null;
            }

            base.OnPropertyChanged(e);
        }

        /// <summary>
        /// Updates DesiredSize of the icon.  Called by parent UIElement during is the first pass of layout.
        /// </summary>
        /// <param name="constraint">Constraint size is an "upper limit" that should not exceed.</param>
        /// <returns>icon desired size.</returns>
        protected override Size MeasureOverride(Size constraint)
        {
            return GetRenderSize(constraint, FontSize);
        }

        /// <summary>
        /// Compute the rendered geometry.
        /// </summary>
        /// <param name="finalSize"></param>
        /// <returns></returns>
        protected override Size ArrangeOverride(Size finalSize)
        {
            return GetRenderSize(finalSize, FontSize);
        }

        /// <summary>
        /// Render callback.
        /// </summary>
        protected override void OnRender(DrawingContext dc)
        {
            Geometry rendered;
            var geometry   = DefiningGeometry;

            Debug.Assert(geometry != null);

            var foreground = Foreground;
            var matrix     = GetStretchMatrix(geometry, FontSize);

            // Need to use colorful render.
            if (geometry is GeometryGroup)
            {
                Brush brush;
                int index        = 0;
                var isSolidColor = foreground is SolidColorBrush;
                var children     = ((GeometryGroup)geometry).Children;
        
                foreach (var child in children)
                {
                    rendered = GetRenderedGeometry(child, matrix);

                    if (rendered != Geometry.Empty)
                    {
                        brush = rendered.GetValue(FillProperty) as Brush;

                        // It may need to be tinted
                        if (brush == null)
                        {
                            if (!isSolidColor || index == 0 || index == 6 || index > 9)
                            {
                                brush = foreground;
                            }else
                            {
                                brush = new SolidColorBrush(ColorPalette.Toning(((SolidColorBrush)foreground).Color, index));
                            }

                            index++;
                        }

                        dc.DrawGeometry(brush, null, rendered);
                    }
                }

            } else
            {
                rendered = GetRenderedGeometry(geometry, matrix);

                if (rendered != Geometry.Empty)
                {
                    dc.DrawGeometry(foreground, null, rendered);
                }
            }

            // Without background, the mouse can penetrate geometry and cause event failure.
            var background = Background;

            if (background != null)
            {
                dc.DrawRectangle(background, null, new Rect(0, 0, RenderSize.Width, RenderSize.Height));
            }
        }

        #endregion

        #region Private Methods

        private void SetSpinAnimation()
        {
            var spin = Spin ?? Type == "loading";

            if (spin)
            {
                this.BeginSpin(1d);
            }
            else
            {
                this.StopSpin();
            }
        }

        private Size GetRenderSize(Size availableSize, double fontSize)
        {
            if (IsGeometryEmpty(DefiningGeometry))
            {
                return new Size(0d, 0d);
            }

            return new Size(Math.Min(availableSize.Width, fontSize), Math.Min(availableSize.Height, fontSize));
        }

        private bool IsGeometryEmpty(Geometry geometry)
        {
            return geometry.IsEmpty() || geometry.Bounds.IsEmpty;
        }

        /// <summary>
        /// Get the rendered geometry.
        /// </summary>
        private Geometry GetRenderedGeometry(Geometry geometry, Matrix matrix)
        {
            var rendered = geometry.CloneCurrentValue();

            if (ReferenceEquals(geometry, rendered))
            {
                rendered = rendered.Clone();
            }

            var transform = rendered.Transform;

            if (transform == null)
            {
                rendered.Transform = new MatrixTransform(matrix);
            }
            else
            {
                rendered.Transform = new MatrixTransform(transform.Value * matrix);
            }

            return rendered;
        }

        /// <summary>
        /// Get the stretch matrix of the geometry.
        /// </summary>
        private Matrix GetStretchMatrix(Geometry geometry, double size)
        {
            var matrix  = Matrix.Identity;

            if (!IsGeometryEmpty(geometry))
            {
                double scaleX, scaleY;
                var viewBox = (Rect)geometry.GetValue(ViewBoxProperty);

                if (viewBox.IsEmpty)
                {
                    viewBox = geometry.Bounds;
                    scaleX  = size / viewBox.Right;
                    scaleY  = size / viewBox.Bottom;

                    if (scaleX > scaleY)
                    {
                        scaleX = scaleY;
                    } else
                    {
                        scaleY = scaleX;
                    }

                } else
                {
                    scaleX = size / viewBox.Width;
                    scaleY = size / viewBox.Height;
                    matrix.Translate(-(scaleX * viewBox.X), -(scaleY * viewBox.Y));
                }

                matrix.Scale(scaleX, scaleY);
            }

            return matrix;
        }

        #endregion
    }

    public enum IconTheme : byte
    {
        Filled, Outlined, Colorful
    }
}