using System;
using System.Collections;
using BLToolkit.Common;
using BLToolkit.Properties;
using BLToolkit.Reflection;
using BLToolkit.TypeBuilder;
using BLToolkit.TypeBuilder.Builders;

namespace BLToolkit.Patterns
{
    /// <summary>
    /// Duck typing implementation.
    /// In computer science, duck typing is a term for dynamic typing typical
    /// of some programming languages, such as Smalltalk, Python or ColdFusion,
    /// where a variable's value itself determines what the variable can do.
    /// Thus an object or set of objects having all the methods described in
    /// an interface can be made to implement that interface dynamically
    /// at runtime, even if the object�s class does not include the interface
    /// in its implements clause.
    /// </summary>
    public static class DuckTyping
    {
        #region Single Duck

        private static readonly Hashtable _duckTypes = new Hashtable();

        /// <summary>
        /// Build a proxy type which implements the requested interface by redirecting all calls to the supplied object type.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="objectType">Any type which expected to have all members of the given interface.</param>
        /// <returns>The duck object type.</returns>
        public static Type GetDuckType(Type interfaceType, Type objectType)
        {
            if (interfaceType == null)      throw new ArgumentNullException("interfaceType");
            if (!interfaceType.IsInterface) throw new ArgumentException(Resources.DuckTyping_InterfaceTypeMustBeAnInterface, "interfaceType");
            if (!interfaceType.IsPublic && !interfaceType.IsNestedPublic)
                throw new ArgumentException(Resources.DuckTyping_InterfaceMustBePublic, "interfaceType");

            Hashtable types = (Hashtable)_duckTypes[interfaceType];

            if (types == null)
            {
                lock (_duckTypes.SyncRoot)
                {
                    types = (Hashtable)_duckTypes[interfaceType];

                    if (types == null)
                        _duckTypes.Add(interfaceType, types = new Hashtable());
                }
            }

            Type type = (Type)types[objectType];

            if (type == null)
            {
                lock (types.SyncRoot)
                {
                    type = (Type)types[objectType];

                    if (type != null || types.ContainsKey(objectType))
                        return type;

                    type = TypeFactory.GetType(
                        new CompoundValue(interfaceType, objectType),
                        interfaceType, //objectType,
                        new DuckTypeBuilder(MustImplementAttribute.Default, interfaceType, new Type[] { objectType }));

                    types.Add(objectType, type);
                }
            }

            return type;
        }

        /// <summary>
        /// Implements the requested interface for supplied object.
        /// If the supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="baseObjectType">Any type which has all members of the given interface.
        /// When this parameter is set to null, the object type will be used.</param>
        /// <param name="obj">An object which type expected to have all members of the given interface.</param>
        /// <returns>An object which implements the interface.</returns>
        public static object Implement(Type interfaceType, Type baseObjectType, object obj)
        {
            if (obj == null) throw new ArgumentNullException("obj");

            Type objType = obj.GetType();

            if (TypeHelper.IsSameOrParent(interfaceType, objType))
                return obj;

            if (obj is DuckType)
            {
                DuckType duckObject = (DuckType)obj;
                if (duckObject.Objects.Length == 1)
                {
                    // Switch to underlying objects when a duck object was passed.
                    //
                    return Implement(interfaceType, baseObjectType, duckObject.Objects[0]);
                }

                // Re-aggregate underlying objects to expose new interface.
                //
                return Aggregate(interfaceType, duckObject.Objects);
            }

            if (baseObjectType == null)
                baseObjectType = objType;
            else if (!TypeHelper.IsSameOrParent(baseObjectType, objType))
                throw new ArgumentException(
                    string.Format(Resources.DuckTyping_NotASubtypeOf, objType.FullName, baseObjectType.FullName), "obj");

            Type duckType = GetDuckType(interfaceType, baseObjectType);

            if (duckType == null)
                return null;

            object duck = TypeAccessor.CreateInstanceEx(duckType);

            ((DuckType)duck).SetObjects(obj);

            return duck;
        }

        /// <summary>
        /// Implements the requested interface.
        /// If the supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="obj">An object which type expected to have all members of the given interface.</param>
        /// <returns>An object which implements the interface.</returns>
        public static object Implement(Type interfaceType, object obj)
        {
            return Implement(interfaceType, null, obj);
        }

        /// <summary>
        /// Implements the requested interface for all supplied objects.
        /// If any of supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="baseObjectType">Any type which has all members of the given interface.
        /// When this parameter is set to null, the object type will be used.</param>
        /// <param name="objects">An object array which types expected to have all members of the given interface.
        /// All objects may have different types.</param>
        /// <returns>An array of object which implements the interface.</returns>
        public static object[] Implement(Type interfaceType, Type baseObjectType, params object[] objects)
        {
            if (objects == null) throw new ArgumentNullException("objects");

            object[] result = new object[objects.Length];
    
            for (int i = 0; i < objects.Length; i++)
                result[i] = Implement(interfaceType, baseObjectType, objects[i]);

            return result;
        }

        /// <summary>
        /// Implements the requested interface for all supplied objects.
        /// If any of supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="objects">An object array which types expected to have all members of the given interface.
        /// All objects may have different types.</param>
        /// <returns>An array of object which implements the interface.</returns>
        public static object[] Implement(Type interfaceType, params object[] objects)
        {
            return Implement(interfaceType, (Type)null, objects);
        }

        /// <summary>
        /// Implements the requested interface for supplied object.
        /// If the supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <typeparam name="I">An interface type to implement.</typeparam>
        /// <param name="obj">An object which type expected to have all members of the given interface.</param>
        /// <returns>An object which implements the interface.</returns>
        public static I Implement<I>(object obj)
            where I : class
        {
            return (I)Implement(typeof(I), null, obj);
        }

        /// <summary>
        /// Implements the requested interface for supplied object.
        /// If the supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <typeparam name="I">An interface type to implement.</typeparam>
        /// <typeparam name="T">Any type which has all members of the given interface.</typeparam>
        /// <param name="obj">An object which type expected to have all members of the given interface.</param>
        /// <returns>An object which implements the interface.</returns>
        public static I Implement<I,T>(T obj)
            where I : class
        {
            return (I)Implement(typeof(I), typeof(T), obj);
        }

        /// <summary>
        /// Implements the requested interface for all supplied objects.
        /// If any of supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <typeparam name="I">An interface type to implement.</typeparam>
        /// <param name="objects">An object array which types expected to have all members of the given interface.
        /// All objects may have different types.</param>
        /// <returns>An array of object which implements the interface.</returns>
        public static I[] Implement<I>(params object[] objects)
            where I : class
        {
            if (objects == null) throw new ArgumentNullException("objects");

            I[] result = new I[objects.Length];

            for (int i = 0; i < objects.Length; i++)
                result[i] = Implement<I>(objects[i]);

            return result;
        }

        /// <summary>
        /// Implements the requested interface for all supplied objects.
        /// If any of supplied object implements the interface, the object itself will be returned.
        /// Otherwise a convenient duck object will be created.
        /// </summary>
        /// <typeparam name="I">An interface type to implement.</typeparam>
        /// <typeparam name="T">Any type which has all members of the given interface.</typeparam>
        /// <param name="objects">An object array which types expected to have all members of the given interface.
        /// All objects may have different types.</param>
        /// <returns>An array of object which implements the interface.</returns>
        public static I[] Implement<I,T>(params T[] objects)
            where I : class
        {
            if (objects == null) throw new ArgumentNullException("objects");

            I[] result = new I[objects.Length];

            for (int i = 0; i < objects.Length; i++)
                result[i] = Implement<I,T>(objects[i]);

            return result;
        }

        private static bool _allowStaticMembers;
        public  static bool  AllowStaticMembers
        {
            get { return _allowStaticMembers;  }
            set { _allowStaticMembers = value; }
        }

        #endregion

        #region Multiple Duck

        /// <summary>
        /// Build a proxy type which implements the requested interface by redirecting all calls to the supplied object type.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="objectTypes">Array of types which expected to have all members of the given interface.</param>
        /// <returns>The duck object type.</returns>
        public static Type GetDuckType(Type interfaceType, Type[] objectTypes)
        {
            if (interfaceType == null)      throw new ArgumentNullException("interfaceType");
            if (!interfaceType.IsInterface) throw new ArgumentException(Resources.DuckTyping_InterfaceTypeMustBeAnInterface, "interfaceType");
            if (!interfaceType.IsPublic && !interfaceType.IsNestedPublic)
                throw new ArgumentException(Resources.DuckTyping_InterfaceMustBePublic, "interfaceType");

            Hashtable types = (Hashtable)_duckTypes[interfaceType];

            if (types == null)
            {
                lock (_duckTypes.SyncRoot)
                {
                    types = (Hashtable)_duckTypes[interfaceType];

                    if (types == null)
                        _duckTypes.Add(interfaceType, types = new Hashtable());
                }
            }

            object key  = new CompoundValue(objectTypes);
            Type   type = (Type)types[key];

            if (type == null)
            {
                lock (types.SyncRoot)
                {
                    type = (Type)types[key];

                    if (type != null || types.ContainsKey(key))
                        return type;

                    type = TypeFactory.GetType(
                        new CompoundValue(interfaceType, key),
                        interfaceType,
                        new DuckTypeBuilder(MustImplementAttribute.Aggregate, interfaceType, objectTypes));

                    types.Add(key, type);
                }
            }

            return type;
        }

        /// <summary>
        /// Implements the requested interface from supplied set of objects.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="baseObjectTypes">Array of types which have all members of the given interface.
        /// When this parameter is set to null, the object type will be used.</param>
        /// <param name="objs">Array of objects which types expected to have all members of the given interface.</param>
        /// <returns>An object which implements the interface.</returns>
        public static object Aggregate(Type interfaceType, Type[] baseObjectTypes,params object[] objs)
        {
            if (objs == null) throw new ArgumentNullException("objs");

            if (baseObjectTypes == null)
            {
                baseObjectTypes = new Type[objs.Length];

                for (int i = 0; i < objs.Length; i++)
                    if (objs[i] != null)
                        baseObjectTypes[i] = objs[i].GetType();
            }
            else
            {
                if (baseObjectTypes.Length != objs.Length)
                    throw new ArgumentException(Resources.DuckTyping_InvalidNumberOfObjs, "baseObjectTypes");

                for (int i = 0; i < objs.Length; i++)
                {
                    Type objType = objs[i].GetType();

                    if (!TypeHelper.IsSameOrParent(baseObjectTypes[i], objType))
                        throw new ArgumentException(
                            string.Format(Resources.DuckTyping_NotASubtypeOf, objType.FullName, baseObjectTypes[i].FullName), "objs");
                }
            }

            Type duckType = GetDuckType(interfaceType, baseObjectTypes);

            if (duckType == null)
                return null;

            object duck = TypeAccessor.CreateInstanceEx(duckType);

            ((DuckType)duck).SetObjects(objs);

            return duck;
        }

        /// <summary>
        /// Implements the requested interface from supplied set of objects.
        /// </summary>
        /// <param name="interfaceType">An interface type to implement.</param>
        /// <param name="objs">Array of object which types expected to have of the given interface.</param>
        /// <returns>An object which implements the interface.</returns>
        public static object Aggregate(Type interfaceType,params object[] objs)
        {
            return Aggregate(interfaceType, (Type[])null, objs);
        }

        /// <summary>
        /// Implements the requested interface from supplied set of objects.
        /// </summary>
        /// <typeparam name="I">An interface type to implement.</typeparam>
        /// <param name="objs">Array of object which type expected to have all members of the given interface.</param>
        /// <returns>An object which implements the interface.</returns>
        public static I Aggregate<I>(params object[] objs)
            where I : class
        {
            return (I)Aggregate(typeof(I), null, objs);
        }

        #endregion
    }
}