using System;
using Chernobyl.Event;
using Chernobyl.Values;

namespace Chernobyl.Conversion
{
    /// <summary>
    /// Converts a value contained within an <see cref="IValue{T}"/> to another
    /// value and maintains that conversion.
    /// </summary>
    /// <typeparam name="TFrom">The type to be converted.</typeparam>
    /// <typeparam name="TTo">The type to convert the value to.</typeparam>
    public class FromSourceConversion<TFrom, TTo> : HeldValue<TTo>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="FromSourceConversion{TFrom,TTo}"/> class.
        /// </summary>
        /// <param name="value">The instance whose contained value is to be
        /// converted.</param>
        /// <param name="converter">The method that performs the conversion.</param>
        public FromSourceConversion(IValue<TFrom> value, Func<TFrom, TTo> converter)
        {
            _converter = converter;

            // Assign the event after configuring this instance in case the event
            // is invoked immediately.
            value.Provide += OnProvide;
        }

        /// <summary>
        /// Converts the value contained within the <see cref="IValue{T}"/> to 
        /// the value requested.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ValueChangedEventArgs{TConvert}"/> 
        /// instance containing the event data.</param>
        void OnProvide(object sender, ValueChangedEventArgs<TFrom> e)
        {
            Value = _converter(e.NewValue);
        }

        /// <summary>
        /// The method that performs the conversion.
        /// </summary>
        readonly Func<TFrom, TTo> _converter;
    }

    /// <summary>
    /// Utility and extensions methods for
    /// <see cref="FromSourceConversion{TFrom,TTo}"/> and its dependencies.
    /// </summary>
    public static class FromSourceConversionExtensions
    {
        /// <summary>
        /// Returns an <see cref="IValue{T}"/> that holds and maintains a
        /// converted version of another <see cref="IValue{T}"/>.
        /// </summary>
        /// <typeparam name="TFrom">The type to be converted.</typeparam>
        /// <typeparam name="TTo">The type to convert the value to.</typeparam>
        /// <param name="value">The instance whose contained value is to be
        /// converted.</param>
        /// <param name="converter">The method that performs the conversion.</param>
        /// <returns>The <see cref="IValue{T}"/> which holds and maintains the
        /// converted value.</returns>
        public static IValue<TTo> Convert<TFrom, TTo>(
            this IValue<TFrom> value, Func<TFrom, TTo> converter)
        {
            return new FromSourceConversion<TFrom, TTo>(value, converter);
        }
    }
}