using System;
using Chernobyl.Event;

namespace Chernobyl.Values
{
    /// <summary>
    /// An interface which is used to work with types that provided an instance
    /// that comes from some source.
    /// </summary>
    /// <typeparam name="T">The type being held within this instance.</typeparam>
    public interface IValue<T>
    {
        /// <summary>
        /// An event that is raised immediately after the value held by this
        /// instance has been modified or become ready. If an event handler is 
        /// added to this event after the value has become ready, then that 
        /// event handler will be invoked immediately.
        /// </summary>
        event EventHandler<ValueChangedEventArgs<T>> Provide;
    }

    /// <summary>
    /// Utility and extension code for <see cref="IValue{T}"/> types.
    /// </summary>
    public static class Value
    {
        /// <summary>
        /// Invokes the specified method once when <see cref="IValue{T}.Provide"/>
        /// is raised. The specified method will not be invoked a second time.
        /// </summary>
        /// <typeparam name="T">The type being held within this instance.</typeparam>
        /// <param name="value">The instance whose <see cref="IValue{T}.Provide"/>
        /// is to be used to invoke <paramref name="method"/>.</param>
        /// <param name="method">The method that is to be invoked once when
        /// <see cref="IValue{T}.Provide"/> is raised.</param>
        public static void Request<T>(this IValue<T> value, EventHandler<ValueChangedEventArgs<T>> method)
        {
            EventHandler<ValueChangedEventArgs<T>> invokeOnce = null;
            invokeOnce = (sender, e) =>
            {
                method(sender, e);
                value.Provide -= invokeOnce;
            };
            value.Provide += invokeOnce;
        }

        /// <summary>
        /// Invokes the specified method whenever the <see cref="IValue{T}"/>
        /// is changed and ends the invocation if the method returns false.
        /// </summary>
        /// <typeparam name="T">The type being held within this instance.</typeparam>
        /// <param name="value">The instance whose <see cref="IValue{T}.Provide"/>
        /// is to be used to invoke <paramref name="method"/>.</param>
        /// <param name="method">The method that is to be invoked whenever the
        /// <see cref="IValue{T}"/> is changed. This method should return true
        /// if it wishes to continue to be invoked, false if it wishes invocation
        /// to end.</param>
        public static void Notify<T>(this IValue<T> value, Func<object, ValueChangedEventArgs<T>, bool> method)
        {
            EventHandler<ValueChangedEventArgs<T>> invoke = null;
            bool firstInvoke = true;
            invoke = (sender, e) =>
            {
                if (firstInvoke == false)
                {
                    if (method(sender, e) == false)
                        value.Provide -= invoke;
                }
                firstInvoke = false;
            };
            value.Provide += invoke;
        }

        /// <summary>
        /// Invokes the specified method whenever the <see cref="IValue{T}"/>
        /// is changed.
        /// </summary>
        /// <typeparam name="T">The type being held within this instance.</typeparam>
        /// <param name="value">The instance whose <see cref="IValue{T}.Provide"/>
        /// is to be used to invoke <paramref name="method"/>.</param>
        /// <param name="method">The method that is to be invoked whenever the
        /// <see cref="IValue{T}"/> is changed.</param>
        public static void Notify<T>(this IValue<T> value, EventHandler<ValueChangedEventArgs<T>> method)
        {
            value.Notify((o, args) =>
            {
                method(o, args);
                return true;
            });
        }

        /// <summary>
        /// Returns an <see cref="IValue{T}"/> whose internal value is set to
        /// null.
        /// </summary>
        /// <typeparam name="T">The type of the internal value.</typeparam>
        /// <returns>The nulled <see cref="IValue{T}"/>.</returns>
        public static IValue<T> Null<T>()
            where T : class
        {
            return Default<T>();
        }

        /// <summary>
        /// Returns an <see cref="IValue{T}"/> whose internal value is set to
        /// <c>default(T)</c>.
        /// </summary>
        /// <typeparam name="T">The type of the internal value.</typeparam>
        /// <returns>The defaulted <see cref="IValue{T}"/>.</returns>
        public static IValue<T> Default<T>()
        {
            return new BasicContainer<T>(default(T));
        }
    }
}