using System;
using System.ComponentModel;
using System.Linq;
using System.Reflection;

namespace Core.Common.Gui.PropertyBag
{
    /// <summary>
    /// This class represents a single property.
    /// </summary>
    public class PropertySpec
    {
        private readonly System.Reflection.PropertyInfo propertyInfo;

        /// <summary>
        /// Initializes a new instance of the <see cref="PropertySpec"/> class for a given
        /// property meta-data object.
        /// </summary>
        /// <param name="propertyInfo">The property information.</param>
        /// <exception cref="ArgumentException">When <paramref name="propertyInfo"/> is 
        /// an index property.</exception>
        public PropertySpec(System.Reflection.PropertyInfo propertyInfo)
        {
            if (propertyInfo.GetIndexParameters().Length > 0)
            {
                throw new ArgumentException("Index properties are not allowed.", "propertyInfo");
            }

            this.propertyInfo = propertyInfo;
            Name = propertyInfo.Name;
            TypeName = propertyInfo.PropertyType.AssemblyQualifiedName;

            var attributeList = propertyInfo.GetCustomAttributes(true).OfType<Attribute>().Select(attrib => attrib).ToList();
            if (propertyInfo.GetSetMethod() == null)
            {
                attributeList.Add(new ReadOnlyAttribute(true));
            }
            Attributes = attributeList.ToArray();
        }

        /// <summary>
        /// Gets or sets a collection of additional <see cref="Attribute"/>s for this property. 
        /// This can be used to specify attributes beyond those supported intrinsically by the
        /// <see cref="PropertySpec"/> class, such as <see cref="System.ComponentModel.ReadOnlyAttribute"/> 
        /// and <see cref="BrowsableAttribute"/>.
        /// </summary>
        public Attribute[] Attributes { get; set; }

        /// <summary>
        /// Gets the name of the property.
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// Gets the fully qualified name of the type of this property.
        /// </summary>
        public string TypeName { get; private set; }

        /// <summary>
        /// Sets the property represented by this instance of some object instance.
        /// </summary>
        /// <param name="instance">The instance to be updated.</param>
        /// <param name="newValue">The new value for the property.</param>
        /// <exception cref="ArgumentException">When
        /// <list type="bullet">
        /// <item>Represented property is an index-property.</item>
        /// <item>Property setter is not available.</item>
        /// <item><paramref name="instance"/> does not match the target type.</item>
        /// <item>Property is an instance property but <paramref name="instance"/> is null.</item>
        /// <item><paramref name="newValue"/> is of incorrect type.</item>
        /// <item>An error occurred while setting the property value. The <see cref="Exception.InnerException"/>
        /// property indicates the reason for the error.</item>
        /// </list></exception>
        /// <exception cref="InvalidOperationException">Calling this method while property
        /// has no setter.</exception>
        public void SetValue(object instance, object newValue)
        {
            var setMethodInfo = propertyInfo.GetSetMethod();
            if (setMethodInfo == null)
            {
                throw new InvalidOperationException("Property lacks public setter!");
            }

            try
            {
                setMethodInfo.Invoke(instance, new[]
                {
                    newValue
                });
            }
            catch (TargetException e)
            {
                object type = instance == null ? null : instance.GetType();
                var message = string.Format("Are you calling SetValue on the correct instance? Expected '{0}', but was '{1}'",
                                            propertyInfo.DeclaringType, type);
                throw new ArgumentException(message, "instance", e);
            }
            catch (TargetInvocationException e)
            {
                var message = string.Format("Something went wrong while setting property with value '{0}'; Check InnerException for more information.",
                                            newValue);
                throw new ArgumentException(message, "newValue", e);
            }
        }

        /// <summary>
        /// Gets the property value represented by this instance of some object instance.
        /// </summary>
        /// <param name="instance">The instance that holds the property to be retrieved.</param>
        /// <exception cref="ArgumentException">When
        /// <list type="bullet">
        /// <item>Represented property is an index-property.</item>
        /// <item>Property getter is not available.</item>
        /// <item><paramref name="instance"/> does not match the target type.</item>
        /// <item>Property is an instance property but <paramref name="instance"/> is null.</item>
        /// <item>An error occurred while setting the property value. The <see cref="Exception.InnerException"/>
        /// property indicates the reason for the error.</item>
        /// </list></exception>
        /// <exception cref="InvalidOperationException">Calling this method while property
        /// has no getter.</exception>
        public object GetValue(object instance)
        {
            var getMethodInfo = propertyInfo.GetGetMethod();
            if (getMethodInfo == null)
            {
                throw new InvalidOperationException("Property lacks public getter!");
            }

            try
            {
                return getMethodInfo.Invoke(instance, new object[0]);
            }
            catch (TargetException e)
            {
                object type = instance == null ? null : instance.GetType();
                var message = string.Format("Are you calling GetValue on the correct instance? Expected '{0}', but was '{1}'",
                                            propertyInfo.DeclaringType, type);
                throw new ArgumentException(message, "instance", e);
            }
            catch (TargetInvocationException e)
            {
                throw new ArgumentException("Something went wrong while getting property; Check InnerException for more information.", "instance", e);
            }
        }

        /// <summary>
        /// Determines whether the captured property is decorated with <see cref="TypeConverterAttribute"/>[is non custom expandable object property].
        /// that is configured to use <see cref="ExpandableObjectConverter"/>.
        /// </summary>
        /// <returns>Returns true if a <see cref="TypeConverterAttribute"/> is declared using
        /// <see cref="ExpandableObjectConverter"/>, false if no match has been found or when
        /// the type converter inherits from <see cref="ExpandableObjectConverter"/>.</returns>
        /// <remarks>Custom implementations of <see cref="ExpandableObjectConverter"/> is
        /// likely to have behavior that Core.Common.Gui namespace cannot account for. As
        /// such those properties will be considered not having the expandable object type converter.</remarks>
        public bool IsNonCustomExpandableObjectProperty()
        {
            var typeConverterClassName = propertyInfo.GetCustomAttributes(typeof(TypeConverterAttribute), false)
                                                        .OfType<TypeConverterAttribute>()
                                                        .Select(tca => tca.ConverterTypeName)
                                                        .Where(n => !string.IsNullOrEmpty(n));
            foreach (string typeName in typeConverterClassName)
            {
                try
                {
                    var type = Type.GetType(typeName);
                    if (type != null)
                    {
                        if (typeof(ExpandableObjectConverter) == type)
                        {
                            return true;
                        }
                    }
                }
                catch (Exception)
                {
                    // gulp
                }
            }
            return false;
        }
    }
}