using System.Collections.Generic;
using Chernobyl.Event;

namespace Chernobyl.Values
{
    /// <summary>
    /// An <see cref="IValue{T}"/> that gets its value from another
    /// <see cref="IValue{T}"/> that may not always be present.
    /// </summary>
    public class SourceValue<T> : BasicValue<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SourceValue{T}"/> class
        /// that uses null for the <see cref="Source"/> and
        /// <see cref="EqualityComparer{T}.Default"/> for the
        /// <see cref="BasicValue{T}.Comparer"/>.
        /// </summary>
        public SourceValue() : this(null)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="SourceValue{T}"/> class
        /// that uses <see cref="EqualityComparer{T}.Default"/>
        /// for the <see cref="BasicValue{T}.Comparer"/>.
        /// </summary>
        /// <param name="source">The <see cref="IContainer{T}"/> that acts as the 
        /// source for <see cref="Value"/> or null if this source has not yet 
        /// been provided.</param>
        public SourceValue(IValue<T> source)
            : this(source, EqualityComparer<T>.Default)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="SourceValue{T}"/> class.
        /// </summary>
        /// <param name="source">The <see cref="IContainer{T}"/> that acts as the 
        /// source for <see cref="Value"/> or null if this source has not yet 
        /// been provided.</param>
        /// <param name="comparer">The instance used to compare new and previous
        /// values of <see cref="Value"/> to determine if 
        /// <see cref="IValue{T}.Provide"/> should be raised.</param>
        public SourceValue(IValue<T> source, IEqualityComparer<T> comparer)
            : base(comparer)
        {
            Source = source;
        }

        /// <summary>
        /// The <see cref="IValue{T}"/> that acts as the source for this instance 
        /// or null if this source has not yet been provided.
        /// </summary>
        public IValue<T> Source
        {
            get { return _source; }
            set
            {
                if (_source != value)
                {
                    IValue<T> previousValue = _source;
                    _source = value;

                    // Don't call NotNeeded() here since we don't want to modify
                    // any internal state when IsNeeded is true.
                    if (previousValue != null && IsNeeded)
                        previousValue.Provide -= OnSourceProvided;

                    bool haveValue = _source != null;
                    if (haveValue && IsNeeded)
                        Needed();

                    IsReady = haveValue;
                }
            }
        }

        /// <summary>
        /// Invoked when <see cref="BasicValue{T}.IsNeeded"/> is changed to true.
        /// Implementations of this method should invoke the base class method.
        /// </summary>
        protected override void Needed()
        {
            if(_source != null)
                _source.Provide += OnSourceProvided;

            base.Needed();
        }

        /// <summary>
        /// Invoked when <see cref="BasicValue{T}.IsNeeded"/> is changed to false.
        /// Implementations of this method should invoke the base class method.
        /// </summary>
        protected override void NotNeeded()
        {
            if (_source != null)
                _source.Provide -= OnSourceProvided;

            base.NotNeeded();
        }

        /// <summary>
        /// The backing property or implementation to <see cref="Value" />. This
        /// property should just set and get the value. The <see cref="Value" />
        /// property handles setting of <see cref="BasicValue{T}.IsReady" /> and
        /// <see cref="PreviousValue" /> and the raising of 
        /// <see cref="IValue{T}.Provide" />.
        /// </summary>
        protected override T BackingValue { get; set; }

        /// <summary>
        /// The previous value of <see cref="Value" />.
        /// </summary>
        protected override T PreviousValue { get; set; }

        /// <summary>
        /// An event handler that invokes <see cref="IValue{T}.Provide" />
        /// on this instance when invoked. This method is used to forward
        /// <see cref="_source" /> through <c>this</c>.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="ValueChangedEventArgs{T}"/> instance 
        /// containing the event data.</param>
        void OnSourceProvided(object sender, ValueChangedEventArgs<T> e)
        {
            if (ProvideHandler != null)
                ProvideHandler(this, e);
        }

        /// <summary>
        /// The backing field to <see cref="Source"/>.
        /// </summary>
        IValue<T> _source;
    }
}