using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Chernobyl.Event;
using Chernobyl.Utility;

namespace Chernobyl.Values
{
    /// <summary>
    /// A basic implementation of an <see cref="IValue{T}"/> intended to make
    /// the creation of <see cref="IValue{T}"/> easier.
    /// </summary>
    /// <typeparam name="T">The type held by <see cref="BasicValue{T}"/>.</typeparam>
    public abstract class BasicValue<T> : IValue<T>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="BasicValue{T}" /> class.
        /// </summary>
        protected BasicValue()
            : this(EqualityComparer<T>.Default)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="BasicValue{T}" /> class.
        /// </summary>
        /// <param name="comparer">The instance used to compare new and previous
        /// values of <see cref="Value" /> to determine if <see cref="Provide" />
        /// should be raised.</param>
        protected BasicValue(IEqualityComparer<T> comparer)
        {
            Comparer = comparer;
        }

        /// <summary>
        /// An event that is raised immediately after the value held by this
        /// instance has been modified.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<T>> Provide
        {
            add
            {
                ProvideHandler += value;

                if (IsReady)
                    value(this, new ValueChangedEventArgs<T>(PreviousValue, Value));
                
                IsNeeded = true;
            }
            remove
            {
                ProvideHandler -= value;

                if(ProvideHandler.GetInvocationList().Length == 0)
                    IsNeeded = false;
            }
        }

        /// <summary>
        /// The value held by this instance. If the value has not yet been
        /// provided it will be equal to <c>default(T)</c>. Setting this property
        /// will make this instance ready.
        /// </summary>
        protected T Value
        {
            get
            {
                // Don't set IsNeeded to true since this property is protected
                // and the only instances accessing the get of this property will
                // be types who have control over readiness.
                return BackingValue;
            }
            set
            {
                if (IsReady == false || Comparer.Equals(BackingValue, value) == false)
                {
                    PreviousValue = BackingValue;
                    BackingValue = value;

                    // Setting IsReady to true when it was previously false will
                    // raise Provide. Otherwise, raise Provide since setting
                    // IsReady to true when it is already true will not raise
                    // Provide.
                    if (IsReady == false)
                        IsReady = true;
                    else if (ProvideHandler != null)
                        ProvideHandler(this, new ValueChangedEventArgs<T>(PreviousValue, Value));
                }
            }
        }

        /// <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 abstract T BackingValue { get; set; }

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

        /// <summary>
        /// The instance used to compare new and previous values of
        /// <see cref="Value"/> to determine if <see cref="Provide"/> should be
        /// raised.
        /// </summary>
        /// <exception cref="ArgumentNullException">Thrown if the value set on
        /// this property is null.</exception>
        public IEqualityComparer<T> Comparer
        {
            get { return _comparer; }
            protected set
            {
                value.ThrowIfNull("value");
                _comparer = value;
            }
        }

        /// <summary>
        /// True if event handlers set on <see cref="Provide"/> should be 
        /// invoked with the current value, false if otherwise. Setting this
        /// property to true when it was previously false will cause the
        /// <see cref="Provide"/> event to be raised. This property is made true
        /// when the <see cref="Value"/> is set. By default this property is false.
        /// </summary>
        protected bool IsReady
        {
            get { return _isReady; }
            set
            {
                if (_isReady != value)
                {
                    _isReady = value;

                    if (_isReady && ProvideHandler != null)
                        ProvideHandler(this, new ValueChangedEventArgs<T>(PreviousValue, Value));
                }
            }
        }

        /// <summary>
        /// Set to true when client code subscribes to the 
        /// <see cref="IValue{T}.Provide"/> event.
        /// </summary>
        protected bool IsNeeded
        {
            get { return _isNeeded; }
            set
            {
                if (_isNeeded != value)
                {
                    _isNeeded = value;

                    if (_isNeeded)
                        Needed();
                    else
                        NotNeeded();
                }
            }
        }

        /// <summary>
        /// Invoked when <see cref="BasicValue{T}.IsNeeded"/> is changed to true.
        /// Implementations of this method should invoke the base class method.
        /// </summary>
        protected virtual void 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 virtual void NotNeeded() { }

        /// <summary>
        /// The backing field to <see cref="Provide"/>.
        /// </summary>
        protected EventHandler<ValueChangedEventArgs<T>> ProvideHandler { get; private set; }

        /// <summary>
        /// The backing field to <see cref="Comparer"/>.
        /// </summary>
        IEqualityComparer<T> _comparer;

        /// <summary>
        /// The backing field to <see cref="IsReady"/>.
        /// </summary>
        bool _isReady;

        /// <summary>
        /// The backing field to <see cref="IsNeeded"/>.
        /// </summary>
        bool _isNeeded;
    }
}