using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;

namespace mt.Shared.Base
{

    /// <summary>
    /// A base class for objects of which the properties must be observable.
    /// 
    /// </summary>
    public class ObservableObject : INotifyPropertyChanged
    {
        private PropertyInfo[] _properties;
        [Browsable(false)]
        public PropertyInfo[] Properties => _properties ??
                                            (_properties = GetType().GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));


        /// <summary>
        /// Provides access to the PropertyChanged event handler to derived classes.
        /// 
        /// </summary>
        protected PropertyChangedEventHandler PropertyChangedHandler => PropertyChanged;

        /// <summary>
        /// Occurs after a property value changes.
        /// 
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Verifies that a property name exists in this ViewModel. This method
        ///             can be called before the property is used, for instance before
        ///             calling RaisePropertyChanged. It avoids errors when a property name
        ///             is changed but some places are missed.
        /// 
        /// </summary>
        /// 
        /// <remarks>
        /// This method is only active in DEBUG mode.
        /// </remarks>
        /// <param name="propertyName">The name of the property that will be
        ///             checked.</param>
        [Conditional("DEBUG")]
        [DebuggerStepThrough]
        public void VerifyPropertyName(string propertyName)
        {
            Type type = GetType();
            if (!string.IsNullOrEmpty(propertyName) && type.GetTypeInfo().GetDeclaredProperty(propertyName) == null)
                throw new ArgumentException(@"Property not found", propertyName);
        }

        /// <summary>
        /// Raises the PropertyChanged event if needed.
        /// 
        /// </summary>
        /// 
        /// <remarks>
        /// If the propertyName parameter
        ///             does not correspond to an existing property on the current class, an
        ///             exception is thrown in DEBUG configuration only.
        /// </remarks>
        /// <param name="propertyName">(optional) The name of the property that
        ///             changed.</param>
        protected virtual void RaisePropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChangedEventHandler changedEventHandler = PropertyChanged;
            changedEventHandler?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        /// <summary>
        /// Raises the PropertyChanged event if needed.
        /// 
        /// </summary>
        /// <typeparam name="T">The type of the property that
        ///             changed.</typeparam><param name="propertyExpression">An expression identifying the property
        ///             that changed.</param>
        protected virtual void RaisePropertyChanged<T>(Expression<Func<T>> propertyExpression)
        {
            PropertyChangedEventHandler changedEventHandler = PropertyChanged;
            if (changedEventHandler == null)
                return;
            string propertyName = GetPropertyName(propertyExpression);
            changedEventHandler(this, new PropertyChangedEventArgs(propertyName));
        }

        /// <summary>
        /// Extracts the name of a property from an expression.
        /// 
        /// </summary>
        /// <typeparam name="T">The type of the property.</typeparam><param name="propertyExpression">An expression returning the property's name.</param>
        /// <returns>
        /// The name of the property returned by the expression.
        /// </returns>
        /// <exception cref="T:System.ArgumentNullException">If the expression is null.</exception><exception cref="T:System.ArgumentException">If the expression does not represent a property.</exception>
        public string GetPropertyName<T>(Expression<Func<T>> propertyExpression)
        {
            if (propertyExpression == null)
                throw new ArgumentNullException(nameof(propertyExpression));

            if (!(propertyExpression.Body is MemberExpression memberExpression))
                throw new ArgumentException(@"Invalid argument", nameof(propertyExpression));

            var propertyInfo = memberExpression.Member as PropertyInfo;
            if (propertyInfo == null)
                throw new ArgumentException(@"Argument is not a property", nameof(propertyExpression));

            return propertyInfo.Name;
        }

        /// <summary>
        /// Assigns a new value to the property. Then, raises the
        ///             PropertyChanged event if needed.
        /// 
        /// </summary>
        /// <typeparam name="T">The type of the property that
        ///             changed.</typeparam><param name="propertyExpression">An expression identifying the property
        ///             that changed.</param><param name="field">The field storing the property's value.</param><param name="newValue">The property's value after the change
        ///             occurred.</param>
        /// <returns>
        /// True if the PropertyChanged event has been raised,
        ///             false otherwise. The event is not raised if the old
        ///             value is equal to the new value.
        /// </returns>
        protected bool Set<T>(Expression<Func<T>> propertyExpression, ref T field, T newValue)
        {
            if (EqualityComparer<T>.Default.Equals(field, newValue))
                return false;
            field = newValue;
            RaisePropertyChanged(propertyExpression);
            return true;
        }

        /// <summary>
        /// Assigns a new value to the property. Then, raises the
        ///             PropertyChanged event if needed.
        /// 
        /// </summary>
        /// <typeparam name="T">The type of the property that
        ///             changed.</typeparam><param name="propertyName">The name of the property that
        ///             changed.</param><param name="field">The field storing the property's value.</param><param name="newValue">The property's value after the change
        ///             occurred.</param>
        /// <returns>
        /// True if the PropertyChanged event has been raised,
        ///             false otherwise. The event is not raised if the old
        ///             value is equal to the new value.
        /// </returns>
        protected bool Set<T>(string propertyName, ref T field, T newValue)
        {
            if (EqualityComparer<T>.Default.Equals(field, newValue))
                return false;
            field = newValue;
            // ReSharper disable once ExplicitCallerInfoArgument
            RaisePropertyChanged(propertyName);

            return true;
        }

        /// <summary>
        /// Assigns a new value to the property. Then, raises the
        ///             PropertyChanged event if needed.
        /// 
        /// </summary>
        /// <typeparam name="T">The type of the property that
        ///             changed.</typeparam><param name="field">The field storing the property's value.</param><param name="newValue">The property's value after the change
        ///             occurred.</param><param name="propertyName">(optional) The name of the property that
        ///             changed.</param>
        /// <returns>
        /// True if the PropertyChanged event has been raised,
        ///             false otherwise. The event is not raised if the old
        ///             value is equal to the new value.
        /// </returns>
        protected bool Set<T>(ref T field, T newValue, [CallerMemberName] string propertyName = null)
        {
            return Set(propertyName, ref field, newValue);
        }

        public string GetDisplayName(Expression<Func<object>> expression)
        {
            var propertyName = GetPropertyName(expression);

            return GetDisplayName(propertyName);
        }

        /// <summary>
        /// Returns the display name of a property via it's string name
        /// </summary>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        public string GetDisplayName(string propertyName)
        {
            var propertyInfo = (from p in Properties
                                where p.Name == propertyName
                                select p).FirstOrDefault();

            return GetDisplayName(propertyInfo);
        }

        /// <summary>
        /// Returns the display name of a property via propertyInfo
        /// </summary>
        /// <param name="propertyInfo"></param>
        /// <returns></returns>
        public string GetDisplayName(PropertyInfo propertyInfo)
        {
            var displayAttribute = Attribute.GetCustomAttributes(propertyInfo, typeof(DisplayAttribute)).FirstOrDefault() as DisplayAttribute;
            if (displayAttribute != null)
            {
                return displayAttribute.GetName();
            }

            return propertyInfo.Name;
        }

    }
}