using System;
using System.Reflection;

namespace Chernobyl.Reflection.Template
{
    /// <summary>
    /// An <see cref="IInstance"/> that allows for at runtime switching of
    /// it's implementation and makes creating new <see cref="IInstance"/>s
    /// easier through the use of other <see cref="IInstance"/> implementations.
    /// </summary>
    public abstract class InstanceDecorator : ComponentDecorator, IInstance
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="InstanceDecorator"/> class.
        /// Note to implementors: this constructor immediately configures the
        /// <see cref="DecoratedInstance"/> using the 
        /// <see cref="ComponentDecorator.ConfigureImplementer()"/> method. This 
        /// assumes the <see cref="DecoratedInstance"/> is ready to use.
        /// </summary>
        protected InstanceDecorator() 
            : this(true)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="InstanceDecorator"/> class.
        /// </summary>
        /// <param name="configure">True if this instance should be configured
        /// immediately, false if the 
        /// <see cref="ComponentDecorator.ConfigureImplementer()"/> method will be 
        /// invoked at a later time by the implementing type.</param>
        protected InstanceDecorator(bool configure) : base(configure)
        { }

        /// <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 object TheInstance
        {
            get { return DecoratedInstance.TheInstance; }
            set { DecoratedInstance.TheInstance = value; }
        }

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

        /// <summary>
        /// The type of this instance.
        /// </summary>
        public virtual Type Type
        {
            get { return DecoratedInstance.Type; }
        }

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

        /// <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 { DecoratedInstance.BecameReady += value; }
            remove { DecoratedInstance.BecameReady -= value; }
        }

        /// <summary>
        /// The <see cref="IComponent"/> instance that implements the
        /// functionality of this class.
        /// </summary>
        protected override IComponent DecoratedComponent
        {
            get { return DecoratedInstance; }
        }

        /// <summary>
        /// The <see cref="IInstance"/> instance that implements the
        /// functionality of this class.
        /// </summary>
        public abstract IInstance DecoratedInstance { get; }
    }
}