using System;
using System.Linq;
using System.Reflection;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Readiness;

namespace Chernobyl.Reflection.Template
{
    /// <summary>
    /// An interface used for working with types that define a particular state 
    /// of some object. This interface allows for that value of an object's 
    /// constructor and method parameters, properties, and fields to be held for 
    /// later recreation into that object.
    /// </summary>
    public interface IInstance : IComponent, IReadyable
    {
        /// <summary>
        /// The object that this <see cref="IInstance"/> represents. If the object 
        /// has not yet been created, then the <see cref="IInstance"/> will not 
        /// create the object until this property is called.
        /// </summary>
        object TheInstance { get; set; }

        /// <summary>
        /// The name of the assembly where this instance is located.
        /// </summary>
        AssemblyName Assembly { get; }

        /// <summary>
        /// The type of this instance.
        /// </summary>
        Type Type { get; }
    }

    /// <summary>
    /// A default instance object that can be used to hold information about
    /// an instance or be used to help make the creation of new derived 
    /// IInstance types easier.
    /// </summary>
    public class Instance : Component, IInstance
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance to use when injecting 
        /// or receiving dependencies from created instances.</param>
        public Instance(IEventCollection<object> services)
            : this(services, string.Empty, new AssemblyName(), string.Empty, string.Empty)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance to use when injecting 
        /// or receiving dependencies from created instances.</param>
        /// <param name="name">The name of this instance template.</param>
        /// <param name="type">The type of this instance or null if this instance
        /// has no type.</param>
        public Instance(IEventCollection<object> services, string name, Type type)
            : this(services, name, type == null ? null : type.Assembly.GetName(),
              type == null ? string.Empty : type.Namespace,
              type == null ? string.Empty : type.Name)
        {
            Type = type;
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance to use when injecting 
        /// or receiving dependencies from created instances.</param>
        /// <param name="name">The name of this instance template.</param>
        /// <param name="assembly">The name of the assembly where this instance is located.</param>
        /// <param name="nameSpace">The namespace where this instance is located.</param>
        /// <param name="typeName">The name of this instances type.</param>
        public Instance(IEventCollection<object> services, string name, AssemblyName assembly, string nameSpace, string typeName) 
            : base(services, nameSpace, name)
        {
            _assembly = assembly;
            _typeName = typeName;
        }

        /// <summary>
        /// The object that this <see cref="IInstance"/> represents. If the object 
        /// has not yet been created, then the <see cref="IInstance"/> will not 
        /// create the object until this property is called.
        /// </summary>
        public virtual object TheInstance
        {
            get { return _theInstance; }
            set
            {
                _theInstance = value;
                IsReady = true;
            }
        }

        /// <summary>
        /// The name of the assembly where this instance is located.
        /// </summary>
        public virtual AssemblyName Assembly
        {
            get { return _assembly; }
            protected set { _assembly = value; }
        }

        /// <summary>
        /// The type of this instance.
        /// </summary>
        public Type Type 
        { 
            get
            {
                if (_type == null && Assembly != null && string.IsNullOrEmpty(Assembly.Name) == false)
                {
                    // grab the assembly 
                    Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
                    Assembly assembly = assemblies.First(asm => AssemblyName.ReferenceMatchesDefinition(asm.GetName(), Assembly) == true);

                    // find the type in the assembly
                    _type = assembly.GetType(FullTypeName);
                }

                return _type;
            }
            private set { _type = value; }
        }

        /// <summary>
        /// The name of this component which can be used to generate code for 
        /// this component.
        /// </summary>
        public override string CodeName
        {
            get
            {
                if (string.IsNullOrEmpty(_codeName) == true)
                    _codeName = GenerateCodeName(this);

                return _codeName;
            }
        }

        /// <summary>
        /// Generates the name of an <see cref="IInstance"/> component that can 
        /// be used in code.
        /// </summary>
        /// <param name="instance">The instance to generate the name for.</param>
        /// <returns>The name that has been created.</returns>
        public static string GenerateCodeName(IInstance instance)
        {
            // "Clean" the type name.

            // Remove the brackets if this is an array.
            string cleanTypeName = instance.Type.Name.Replace("[]", "_Array");

            // Remove the '`' if this is a generic.
            cleanTypeName = cleanTypeName.Replace("`", "_Generic");

            return cleanTypeName + "_" + instance.GetHashCode();
        }

        /// <summary>
        /// True if the <see cref="TheInstance"/> property has been set, false
        /// if otherwise.
        /// </summary>
        public bool IsReady
        {
            get { return _isReady; }
            protected set
            {
                bool previousValue = _isReady;
                _isReady = value;

                if (previousValue == false && _isReady == true)
                {
                    if (_becameReady != null)
                        _becameReady(this, EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// An event that is thrown right after the <see cref="TheInstance"/>
        /// property has been set. If an event handler is assigned to this event
        /// after it has become ready, then that event handler will be
        /// immediately invoked.
        /// </summary>
        public event EventHandler BecameReady
        {
            add
            {
                if (IsReady == true)
                    value(this, EventArgs.Empty);

                _becameReady += value;
            }
            remove { _becameReady -= value; }
        }

        /// <summary>
        /// The full type name of this instance as "Namespace.TypeName".
        /// </summary>
        string FullTypeName
        {
            get
            {
                if (_fullTypeName == null)
                {
                    string nameSpace = Prefix.Length == 0 ? Prefix : Prefix.PadRight(Prefix.Length + 1, '.');
                    _fullTypeName = nameSpace + _typeName;
                }

                return _fullTypeName;
            }
        }

        /// <summary>
        /// Holds the name of the type.
        /// </summary>
        string _typeName;

        /// <summary>
        /// The backing field to <see cref="TheInstance"/>.
        /// </summary>
        object _theInstance;

        /// <summary>
        /// The backing property to <see cref="Assembly"/>.
        /// </summary>
// ReSharper disable InconsistentNaming
        protected AssemblyName _assembly { get; set; }
// ReSharper restore InconsistentNaming

        /// <summary>
        /// The backing field to <see cref="FullTypeName"/>.
        /// </summary>
        string _fullTypeName;

        /// <summary>
        /// The backing field to <see cref="CodeName"/>.
        /// </summary>
        string _codeName;

        /// <summary>
        /// The backing field to <see cref="Type"/>.
        /// </summary>
        Type _type;

        /// <summary>
        /// The backing field to <see cref="IsReady"/>.
        /// </summary>
        bool _isReady;

        /// <summary>
        /// The backing field to <see cref="BecameReady"/>.
        /// </summary>
        EventHandler _becameReady;
    }

    /// <summary>
    /// An <see cref="IInstance"/> type that pulls the assembly name, namespace, 
    /// and type name from the template parameter 
    /// <typeparamref name="TInstance"/>.
    /// </summary>
    /// <typeparam name="TInstance">The type of the instance.</typeparam>
    public class Instance<TInstance> : Instance
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance to use when injecting 
        /// or receiving dependencies from created instances.</param>
        public Instance(IEventCollection<object> services)
            : this(services, string.Empty)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance to use when injecting 
        /// or receiving dependencies from created instances.</param>
        /// <param name="name">The name of this instance template.</param>
        public Instance(IEventCollection<object> services, string name)
            : this(services, default(TInstance), name)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance to use when injecting 
        /// or receiving dependencies from created instances.</param>
        /// <param name="theInstance">The instance that will be returned when
        /// created is called on this class.</param>
        /// <param name="name">The name of this instance template.</param>
        public Instance(IEventCollection<object> services, TInstance theInstance, string name)
            : base(services, name, typeof(TInstance))
        {
            TheGenericInstance = theInstance;
        }

        /// <summary>
        /// Same as <see cref="TheInstance"/> except in generic form.
        /// </summary>
        public TInstance TheGenericInstance
        {
            get { return _theGenericInstance; }
            set
            {
                _theGenericInstance = value;
                IsReady = true;
            }
        }

        /// <summary>
        /// The object that this <see cref="IInstance"/> represents. If the object 
        /// has not yet been created, then the <see cref="IInstance"/> will not 
        /// create the object until this property is called.
        /// </summary>
        public override object TheInstance
        {
            get { return TheGenericInstance; }
            set { TheGenericInstance = (TInstance)value; }
        }

        /// <summary>
        /// The backing field to <see cref="TheGenericInstance"/>.
        /// </summary>
        TInstance _theGenericInstance;
    }
}