using System;
using System.Collections.Generic;
using System.Reflection;
using System.Collections.Concurrent;
using System.Linq;

namespace Unosquare.Swan.Reflection {
  /// <summary>
  /// A thread-safe cache of attributes belonging to a given key (MemberInfo or Type).
  /// 
  /// The Retrieve method is the most useful one in this class as it
  /// calls the retrieval process if the type is not contained
  /// in the cache.
  /// </summary>
  public class AttributeCache {
    private readonly Lazy<ConcurrentDictionary<Tuple<Object, Type>, IEnumerable<Object>>> _data =
        new Lazy<ConcurrentDictionary<Tuple<Object, Type>, IEnumerable<Object>>>(() =>
            new ConcurrentDictionary<Tuple<Object, Type>, IEnumerable<Object>>(), true);

    /// <summary>
    /// Initializes a new instance of the <see cref="AttributeCache"/> class.
    /// </summary>
    /// <param name="propertyCache">The property cache object.</param>
    public AttributeCache(PropertyTypeCache propertyCache = null) => this.PropertyTypeCache = propertyCache ?? Runtime.PropertyTypeCache;

    /// <summary>
    /// A PropertyTypeCache object for caching properties and their attributes.
    /// </summary>
    public PropertyTypeCache PropertyTypeCache {
      get;
    }

    /// <summary>
    /// Determines whether [contains] [the specified member].
    /// </summary>
    /// <typeparam name="T">The type of the attribute to be retrieved.</typeparam>
    /// <param name="member">The member.</param>
    /// <returns>
    ///   <c>true</c> if [contains] [the specified member]; otherwise, <c>false</c>.
    /// </returns>
    public Boolean Contains<T>(MemberInfo member) => this._data.Value.ContainsKey(new Tuple<Object, Type>(member, typeof(T)));

    /// <summary>
    /// Gets specific attributes from a member constrained to an attribute.
    /// </summary>
    /// <typeparam name="T">The type of the attribute to be retrieved.</typeparam>
    /// <param name="member">The member.</param>
    /// <param name="inherit"><c>true</c> to inspect the ancestors of element; otherwise, <c>false</c>.</param>
    /// <returns>An array of the attributes stored for the specified type.</returns>
    public IEnumerable<Object> Retrieve<T>(MemberInfo member, Boolean inherit = false)
        where T : Attribute {
      if(member == null) {
        throw new ArgumentNullException(nameof(member));
      }

      return this.Retrieve(new Tuple<Object, Type>(member, typeof(T)), t => member.GetCustomAttributes<T>(inherit));
    }

    /// <summary>
    /// Gets all attributes of a specific type from a member.
    /// </summary>
    /// <param name="member">The member.</param>
    /// <param name="type">The attribute type.</param>
    /// <param name="inherit"><c>true</c> to inspect the ancestors of element; otherwise, <c>false</c>.</param>
    /// <returns>An array of the attributes stored for the specified type.</returns>
    public IEnumerable<Object> Retrieve(MemberInfo member, Type type, Boolean inherit = false) {
      if(member == null) {
        throw new ArgumentNullException(nameof(member));
      }

      if(type == null) {
        throw new ArgumentNullException(nameof(type));
      }

      return this.Retrieve(
                new Tuple<Object, Type>(member, type),
                t => member.GetCustomAttributes(type, inherit));
    }

    /// <summary>
    /// Gets one attribute of a specific type from a member.
    /// </summary>
    /// <typeparam name="T">The attribute type.</typeparam>
    /// <param name="member">The member.</param>
    /// <param name="inherit"><c>true</c> to inspect the ancestors of element; otherwise, <c>false</c>.</param>
    /// <returns>An attribute stored for the specified type.</returns>
    public T RetrieveOne<T>(MemberInfo member, Boolean inherit = false)
        where T : Attribute {
      if(member == null) {
        return default;
      }

      IEnumerable<Object> attr = this.Retrieve(
                new Tuple<Object, Type>(member, typeof(T)),
                t => member.GetCustomAttributes(typeof(T), inherit));

      return ConvertToAttribute<T>(attr);
    }

    /// <summary>
    /// Gets one attribute of a specific type from a generic type.
    /// </summary>
    /// <typeparam name="TAttribute">The type of the attribute.</typeparam>
    /// <typeparam name="T">The type to retrieve the attribute.</typeparam>
    /// <param name="inherit">if set to <c>true</c> [inherit].</param>
    /// <returns>An attribute stored for the specified type.</returns>
    public TAttribute RetrieveOne<TAttribute, T>(Boolean inherit = false)
        where TAttribute : Attribute {
      IEnumerable<Object> attr = this.Retrieve(
          new Tuple<Object, Type>(typeof(T), typeof(TAttribute)),
          t => typeof(T).GetCustomAttributes(typeof(TAttribute), inherit));

      return ConvertToAttribute<TAttribute>(attr);
    }

    /// <summary>
    /// Gets all properties an their attributes of a given type constrained to only attributes.
    /// </summary>
    /// <typeparam name="T">The type of the attribute to retrieve.</typeparam>
    /// <param name="type">The type of the object.</param>
    /// <param name="inherit"><c>true</c> to inspect the ancestors of element; otherwise, <c>false</c>.</param>
    /// <returns>A dictionary of the properties and their attributes stored for the specified type.</returns>
    public Dictionary<PropertyInfo, IEnumerable<Object>> Retrieve<T>(Type type, Boolean inherit = false)
        where T : Attribute {
      if(type == null) {
        throw new ArgumentNullException(nameof(type));
      }

      return this.PropertyTypeCache.RetrieveAllProperties(type, true)
                .ToDictionary(x => x, x => this.Retrieve<T>(x, inherit));
    }

    /// <summary>
    /// Gets all properties and their attributes of a given type.
    /// </summary>
    /// <typeparam name="T">The object type used to extract the properties from.</typeparam>
    /// <param name="attributeType">Type of the attribute.</param>
    /// <param name="inherit"><c>true</c> to inspect the ancestors of element; otherwise, <c>false</c>.</param>
    /// <returns>
    /// A dictionary of the properties and their attributes stored for the specified type.
    /// </returns>
    public Dictionary<PropertyInfo, IEnumerable<Object>> RetrieveFromType<T>(Type attributeType, Boolean inherit = false) {
      if(attributeType == null) {
        throw new ArgumentNullException(nameof(attributeType));
      }

      return this.PropertyTypeCache.RetrieveAllProperties<T>(true)
                .ToDictionary(x => x, x => this.Retrieve(x, attributeType, inherit));
    }

    private static T ConvertToAttribute<T>(IEnumerable<Object> attr)
        where T : Attribute {
      if(attr?.Any() != true) {
        return default;
      }

      if(attr.Count() == 1) {
        return (T)Convert.ChangeType(attr.First(), typeof(T));
      }

      throw new AmbiguousMatchException("Multiple custom attributes of the same type found.");
    }

    private IEnumerable<Object> Retrieve(Tuple<Object, Type> key, Func<Tuple<Object, Type>, IEnumerable<Object>> factory) {
      if(factory == null) {
        throw new ArgumentNullException(nameof(factory));
      }

      return this._data.Value.GetOrAdd(key, k => factory.Invoke(k).Where(item => item != null));
    }
  }
}