using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using Tango.Core.DI;

namespace Tango.FSE.Common.Resolution
{
    public static class ResolutionHelper
    {
        private static List<FrameworkElement> _elements;
        private static IResolutionService _resolutionService;

        static ResolutionHelper()
        {
            _elements = new List<FrameworkElement>();
            var resolutionService = TangoIOC.Default.GetInstance<IResolutionService>();
            _resolutionService = resolutionService;

            if (resolutionService != null)
            {
                resolutionService.ResolutionModeChanged += ResolutionService_ResolutionModeChanged;
                resolutionService.ResolutionChanged += ResolutionService_ResolutionChanged;
            }
        }

        private static void ResolutionService_ResolutionChanged(object sender, SizeChangedEventArgs e)
        {
            foreach (var element in _elements)
            {
                ApplyElementSetting(element);
            }
        }

        private static void ResolutionService_ResolutionModeChanged(object sender, ResolutionMode mode)
        {
            foreach (var element in _elements)
            {
                ApplyElementSetting(element);
            }
        }

        private static void ApplyElementSetting(FrameworkElement element)
        {
            if (_resolutionService != null)
            {
                var mode = GetMode(element);
                if (mode != ResolutionMode.None)
                {
                    if (mode == _resolutionService.Resolution)
                    {
                        element.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        element.Visibility = Visibility.Collapsed;
                    }
                }

                var width = GetMinWidth(element);

                if (!Double.IsNaN(width))
                {
                    if (_resolutionService.ResolutionWidth >= width)
                    {
                        element.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        element.Visibility = Visibility.Collapsed;
                    }
                }

                var height = GetMinHeight(element);

                if (!Double.IsNaN(height))
                {
                    if (_resolutionService.ResolutionHeight >= height)
                    {
                        element.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        element.Visibility = Visibility.Collapsed;
                    }
                }

                if (!Double.IsNaN(width) && !Double.IsNaN(height))
                {
                    if (_resolutionService.ResolutionWidth >= width && _resolutionService.ResolutionHeight >= height)
                    {
                        element.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        element.Visibility = Visibility.Collapsed;
                    }
                }

                var lowResolutionMargin = GetLowResolutionMargin(element);
                var highResolutionMargin = GetHighResolutionMargin(element);

                if (_resolutionService.Resolution == ResolutionMode.High)
                {
                    if (highResolutionMargin != null)
                    {
                        element.Margin = highResolutionMargin.Value;
                    }
                }
                else if (_resolutionService.Resolution == ResolutionMode.Low)
                {
                    if (lowResolutionMargin != null)
                    {
                        element.Margin = lowResolutionMargin.Value;
                    }
                }
            }
        }

        #region Mode

        /// <summary>
        /// Determined the resolution mode for the trigger.
        /// </summary>
        public static readonly DependencyProperty ModeProperty =
            DependencyProperty.RegisterAttached("Mode",
            typeof(ResolutionMode), typeof(ResolutionHelper),
            new FrameworkPropertyMetadata(ResolutionMode.None, OnModeChanged));

        private static void OnModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!_elements.Contains(d as FrameworkElement))
            {
                _elements.Add(d as FrameworkElement);
                ApplyElementSetting(d as FrameworkElement);
            }
        }

        /// <summary>
        /// Sets the Mode attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetMode(FrameworkElement element, ResolutionMode value)
        {
            element.SetValue(ModeProperty, value);
        }

        /// <summary>
        /// Gets the Mode attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static ResolutionMode GetMode(FrameworkElement element)
        {
            return (ResolutionMode)element.GetValue(ModeProperty);
        }

        #endregion

        #region MinWidth

        /// <summary>
        /// Determined the resolution MinWidth for the trigger.
        /// </summary>
        public static readonly DependencyProperty MinWidthProperty =
            DependencyProperty.RegisterAttached("MinWidth",
            typeof(double), typeof(ResolutionHelper),
            new FrameworkPropertyMetadata(double.NaN, OnMinWidthChanged));

        private static void OnMinWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!_elements.Contains(d as FrameworkElement))
            {
                _elements.Add(d as FrameworkElement);
                ApplyElementSetting(d as FrameworkElement);
            }
        }

        /// <summary>
        /// Sets the MinWidth attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetMinWidth(FrameworkElement element, double value)
        {
            element.SetValue(MinWidthProperty, value);
        }

        /// <summary>
        /// Gets the MinWidth attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static double GetMinWidth(FrameworkElement element)
        {
            return (double)element.GetValue(MinWidthProperty);
        }

        #endregion

        #region MinHeight

        /// <summary>
        /// Determined the resolution MinHeight for the trigger.
        /// </summary>
        public static readonly DependencyProperty MinHeightProperty =
            DependencyProperty.RegisterAttached("MinHeight",
            typeof(double), typeof(ResolutionHelper),
            new FrameworkPropertyMetadata(double.NaN, OnMinHeightChanged));

        private static void OnMinHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!_elements.Contains(d as FrameworkElement))
            {
                _elements.Add(d as FrameworkElement);
                ApplyElementSetting(d as FrameworkElement);
            }
        }

        /// <summary>
        /// Sets the MinHeight attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetMinHeight(FrameworkElement element, double value)
        {
            element.SetValue(MinHeightProperty, value);
        }

        /// <summary>
        /// Gets the MinHeight attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static double GetMinHeight(FrameworkElement element)
        {
            return (double)element.GetValue(MinHeightProperty);
        }

        #endregion

        #region LowResolutionMargin

        /// <summary>
        /// Determined the resolution LowResolutionMargin for the trigger.
        /// </summary>
        public static readonly DependencyProperty LowResolutionMarginProperty =
            DependencyProperty.RegisterAttached("LowResolutionMargin",
            typeof(Thickness?), typeof(ResolutionHelper),
            new FrameworkPropertyMetadata(null, OnLowResolutionMarginChanged));

        private static void OnLowResolutionMarginChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!_elements.Contains(d as FrameworkElement))
            {
                _elements.Add(d as FrameworkElement);
                ApplyElementSetting(d as FrameworkElement);
            }
        }

        /// <summary>
        /// Sets the LowResolutionMargin attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetLowResolutionMargin(FrameworkElement element, Thickness? value)
        {
            element.SetValue(LowResolutionMarginProperty, value);
        }

        /// <summary>
        /// Gets the LowResolutionMargin attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static Thickness? GetLowResolutionMargin(FrameworkElement element)
        {
            return (Thickness?)element.GetValue(LowResolutionMarginProperty);
        }

        #endregion

        #region HighResolutionMargin

        /// <summary>
        /// Determined the resolution HighResolutionMargin for the trigger.
        /// </summary>
        public static readonly DependencyProperty HighResolutionMarginProperty =
            DependencyProperty.RegisterAttached("HighResolutionMargin",
            typeof(Thickness?), typeof(ResolutionHelper),
            new FrameworkPropertyMetadata(null, OnHighResolutionMarginChanged));

        private static void OnHighResolutionMarginChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (!_elements.Contains(d as FrameworkElement))
            {
                _elements.Add(d as FrameworkElement);
                ApplyElementSetting(d as FrameworkElement);
            }
        }

        /// <summary>
        /// Sets the HighResolutionMargin attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="value">if set to <c>true</c> [value].</param>
        public static void SetHighResolutionMargin(FrameworkElement element, Thickness? value)
        {
            element.SetValue(HighResolutionMarginProperty, value);
        }

        /// <summary>
        /// Gets the HighResolutionMargin attached property.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <returns></returns>
        public static Thickness? GetHighResolutionMargin(FrameworkElement element)
        {
            return (Thickness?)element.GetValue(HighResolutionMarginProperty);
        }

        #endregion
    }
}