using Chernobyl.Event;
using Chernobyl.Values;

namespace Chernobyl.DesignPatterns.Extension
{
    /// <summary>
    /// Attaches/detaches an <see cref="IExtension{TExtended}"/> to/from an 
    /// <see cref="IExtendable"/> whenever either of them is modified.
    /// </summary>
    /// <typeparam name="T">The type of <see cref="IExtendable"/> that is to
    /// have the <see cref="IExtension{TExtended}"/> to it.</typeparam>
    class Attach<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Attach{T}"/> class.
        /// </summary>
        /// <param name="extendable"><paramref name="attachment" /> will be attached
        /// to the instance contained this <see cref="IValue{T}" />. If the
        /// instance is not yet provided (equal to null) then
        /// <paramref name="attachment" /> will be attached when it is. When the
        /// instance is modified, the <paramref name="attachment" /> will be
        /// removed from the old instance and placed on the new instance.</param>
        /// <param name="attachment">The <see cref="IExtension{TExtended}" />
        /// contained in this <see cref="IValue{T}" /> will be attached to
        /// <paramref name="extendable" />. If the <paramref name="attachment" />
        /// is not yet provided then it will be attached
        /// when it is. When the <paramref name="attachment" /> is modified, the
        /// old version will be detached and the new version will be attached.</param>
        public Attach(IValue<T> extendable, IValue<IExtension<T>> attachment)
        {
            extendable.Provide += OnExtendableProvided;
            attachment.Provide += OnAttachmentProvided;
        }

        /// <summary>
        /// Invoked when the extendable value is provided. This method attaches
        /// the attachment to the extendable provided.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The arguments containing the extendable value.</param>
        void OnExtendableProvided(object sender, ValueChangedEventArgs<T> e)
        {
            _extendable = e.NewValue;

            // Attach to the new value. This will also detach from the
            // old value.
            if (_attachment != null)
                _attachment.Extended = _extendable;
        }

        /// <summary>
        /// Invoked when the attachment value is provided. This method attaches
        /// the attachment to the extendable and detaches the old extendable.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The arguments containing the attachment value.</param>
        void OnAttachmentProvided(object sender, ValueChangedEventArgs<IExtension<T>> e)
        {
            // Detach the old attachment.
            if (_attachment != null)
                _attachment.Extended = default(T);

            _attachment = e.NewValue;

            // Attach the new attachment. It is OK if the _extendable is null
            // since it will just ignore the value passed in (provided it is
            // properly created).
            if (_attachment != null)
                _attachment.Extended = _extendable;
        }

        /// <summary>
        /// The instance <see cref="_attachment"/> is to be attached to.
        /// </summary>
        T _extendable;

        /// <summary>
        /// The instance to be attaached to <see cref="_extendable"/>.
        /// </summary>
        IExtension<T> _attachment;
    }

    /// <summary>
    /// Utility and extension methods for <see cref="Attach{T}"/> or its use.
    /// </summary>
    public static class AttachExtensions
    {
        /// <summary>
        /// Attaches/detaches an <see cref="IExtension{TExtended}"/> to/from an 
        /// <see cref="IExtendable"/> whenever either of them is modified.
        /// </summary>
        /// 
        /// <typeparam name="T">The type of <see cref="IExtendable"/> that is to
        /// have the <see cref="IExtension{TExtended}"/> to it.</typeparam>
        /// 
        /// <param name="extendable"><paramref name="attachment"/> will be attached
        /// to the instance contained this <see cref="IValue{T}"/>. If the 
        /// instance is not yet provided (equal to null) then 
        /// <paramref name="attachment"/> will be attached when it is. When the
        /// instance is modified, the <paramref name="attachment"/> will be
        /// removed from the old instance and placed on the new instance.</param>
        /// 
        /// <param name="attachment">The <see cref="IExtension{TExtended}"/> 
        /// contained in this <see cref="IValue{T}"/> will be attached to 
        /// <paramref name="extendable"/>. If the <paramref name="attachment"/> 
        /// is not yet provided then it will be attached 
        /// when it is. When the <paramref name="attachment"/> is modified, the
        /// old version will be detached and the new version will be attached.</param>
        public static void Attach<T>(this IValue<T> extendable, IValue<IExtension<T>> attachment)
            where T : IExtendable
        {
            Attach<T> attach = new Attach<T>(extendable, attachment);
        }
    }
}