using System;
using Chernobyl.Utility;
using Chernobyl.Values;

namespace Chernobyl.Conversion
{
    /// <summary>
    /// Converts a value contained within an <see cref="IDynamicContainer{T}"/> 
    /// to and from another value and maintains that conversion.
    /// </summary>
    /// <typeparam name="T1">The first type to be converted to and from.</typeparam>
    /// <typeparam name="T2">The second type to be converted to and from.</typeparam>
    public class TwoWayConversion<T1, T2> : FromSourceConversion<T1, T2>, IDynamicContainer<T2>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="TwoWayConversion{T1,T2}"/> class.
        /// </summary>
        /// <param name="container">The instance whose contained value is to be
        /// converted.</param>
        /// <param name="oneToTwo">The method that performs the conversion of 
        /// <typeparamref name="T1"/> to <typeparamref name="T2"/>.</param>
        /// <param name="twoToOne">The method that performs the conversion of 
        /// <typeparamref name="T2"/> to <typeparamref name="T1"/>.</param>
        public TwoWayConversion(IDynamicContainer<T1> container,
                                Func<T1, T2> oneToTwo,
                                Func<T2, T1> twoToOne)
            : base(container, oneToTwo)
        {
            container.ThrowIfNull("container");
            _container = container;

            twoToOne.ThrowIfNull("twoToOne");
            _twoToOne = twoToOne;
        }

        /// <summary>
        /// The value held by this instance. If the value has not yet been
        /// provided it will be equal to <c>default(T)</c>.
        /// </summary>
        public new T2 Value
        {
            get { return base.Value; }
            set
            {
                // The base class will update the contained value when the
                // _container is updated.
                _container.Value = _twoToOne(value);
            }
        }

        /// <summary>
        /// The method that performs the conversion of <typeparamref name="T2"/>
        /// to <typeparamref name="T1"/>.
        /// </summary>
        readonly Func<T2, T1> _twoToOne;

        /// <summary>
        /// The instance whose contained value is to be converted.
        /// </summary>
        readonly IDynamicContainer<T1> _container;
    }

    /// <summary>
    /// Utility and extensions methods for
    /// <see cref="TwoWayConversion{T1,T2}"/> and its dependencies.
    /// </summary>
    public static class TwoWayConversionExtensions
    {
        /// <summary>
        /// Returns an <see cref="IDynamicContainer{T}"/> that holds and 
        /// maintains a conversion to and from another <see cref="IValue{T}"/>.
        /// </summary>
        /// <typeparam name="T1">The first type to be converted to and from.</typeparam>
        /// <typeparam name="T2">The second type to be converted to and from.</typeparam>
        /// <param name="container">The instance whose contained value is to be
        /// converted.</param>
        /// <param name="oneToTwo">The method that performs the conversion of 
        /// <typeparamref name="T1"/> to <typeparamref name="T2"/>.</param>
        /// <param name="twoToOne">The method that performs the conversion of 
        /// <typeparamref name="T2"/> to <typeparamref name="T1"/>.</param>
        /// <returns>The <see cref="IDynamicContainer{T}"/> which holds and 
        /// maintains the conversion.</returns>
        public static IDynamicContainer<T2> Convert<T1, T2>(
            this IDynamicContainer<T1> container,
            Func<T1, T2> oneToTwo,
            Func<T2, T1> twoToOne)
        {
            return new TwoWayConversion<T1, T2>(container, oneToTwo, twoToOne);
        }
    }
}