using System;

namespace Chernobyl.Values
{
    /// <summary>
    /// This class is used to delay the computation or creation of some value 
    /// until it is actually needed.
    /// </summary>
    /// <typeparam name="T">The type whose value is to be delayed until needed.</typeparam>
    public class LazyValue<T> : HeldValue<T>, IContainer<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="LazyValue{T}"/> class.
        /// </summary>
        /// <param name="func">The func.</param>
        public LazyValue(Func<T> func)
        {
            Func = func;
            HasValue = false;
        }

        /// <summary>
        /// Returns the value in question. If the value has not been computed or 
        /// created, then it will be and that value will be returned. Otherwise, 
        /// the already computed/created value will be returned.
        /// </summary>
        public new T Value
        {
            get
            {
                if (HasValue == false)
                {
                    _value = Func();
                    HasValue = true;
                }

                return _value;
            }
        }

        /// <summary>
        /// True if this instance's <see cref="Value"/> has already been 
        /// computed/created, false if otherwise.
        /// </summary>
        public bool HasValue { get; private set; }

        /// <summary>
        /// The method that is to be invoked to generate the value.
        /// </summary>
        Func<T> Func { get; set; }

        /// <summary>
        /// The backing field to <see cref="Value"/>.
        /// </summary>
        T _value;
    }
}