using System;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Event;

namespace Chernobyl.Game.Destruction
{
    /// <summary>
    /// A basic implementation of an <see cref="IDestroyable"/>.
    /// </summary>
    public class Destroyable : Extension<object>, IDestroyable
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Destroyable"/> class
        /// that has a <see cref="Health"/> of <see cref="DefaultHealth"/> and 
        /// a <see cref="MaxHealth"/> equal to <see cref="DefaultMaxHealth"/>.
        /// </summary>
        public Destroyable()
            : this(DefaultHealth)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="Destroyable" /> class
        /// that has a <see cref="MaxHealth" /> equal to <see cref="DefaultMaxHealth" />.
        /// </summary>
        /// <param name="health">A 0 to 1 value that represents the health of 
        /// this instance. If this value is 0 then this instance has been 
        /// destroyed. If this value is 1 then this instance has full health.</param>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if 
        /// <paramref name="health"/> is below zero or above 1.</exception>
        public Destroyable(float health)
            : this(health, DefaultMaxHealth)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Destroyable"/> class.
        /// </summary>
        /// <param name="health">A 0 to 1 value that represents the health of 
        /// this instance. If this value is 0 then this instance has been 
        /// destroyed. If this value is 1 then this instance has full health.</param>
        /// <param name="maxHealth">The maximum amount of health this instance 
        /// can have. This value is NOT clamped between 0 and 1 but cannot go 
        /// below 0 (for example it could be 100). Note that the minimum amount 
        /// of health is always 0.</param>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if 
        /// <paramref name="health"/> is below zero or above 1. Also thrown if
        /// <paramref name="maxHealth"/> is zero or below.</exception>
        public Destroyable(float health, float maxHealth)
        {
            MaxHealth = 100;
            Health = 1;
        }

        /// <summary>
        /// A 0 to 1 value that represents the health of this instance. If this
        /// value is 0 then this instance has been destroyed. If this value is
        /// 1 then this instance has full health.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the value
        /// set on this property is below zero or above 1.</exception>
        public float Health
        {
            get { return _health; }
            set
            {
                if (value < 0)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The Health property cannot be below zero.");

                if (value > 1)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The Health property cannot be greater than 1 as this " +
                        "value is a normalized value.");

                float previousValue = _health;
                _health = value;
                float changeAmount = _health - previousValue;

                if (changeAmount != 0)
                {
                    ValueChangedEventArgs<float> eventArgs =
                        new ValueChangedEventArgs<float>(previousValue, _health);

                    if (changeAmount < 0)
                    {
                        // This instance took damage.

                        if (Damaged != null)
                            Damaged(this, eventArgs);

                        if (_health == 0 && Destroyed != null)
                            Destroyed(this, eventArgs);
                    }

                    if (changeAmount > 0)
                    {
                        // This instance gained health.

                        if (Healed != null)
                            Healed(this, eventArgs);

                        if (previousValue == 0 && Revived != null)
                            Revived(this, eventArgs);
                    }
                }
            }
        }

        /// <summary>
        /// The maximum amount of health this instance can have. This value is
        /// NOT clamped between 0 and 1 but cannot go below 0 (for example it
        /// could be 100). Note that the minimum amount of health is always 0.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the value
        /// set on this property is zero or below.</exception>
        public float MaxHealth
        {
            get { return _maxHealth; }
            set
            {
                if (value >= 0)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The maximum amount of health cannot be equal to or less " +
                        "than zero.");

                _maxHealth = value;
            }
        }

        /// <summary>
        /// An event that is raised when this instance is damaged. The
        /// <see cref="ValueChangedEventArgs{T}"/> type passed as the event
        /// argument represents the old value and the new value of the
        /// <see cref="Health"/> property.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<float>> Damaged;

        /// <summary>
        /// An event that is raised when this object has been killed or will no
        /// longer be used until a later point.
        /// </summary>
        public event EventHandler Destroyed;

        /// <summary>
        /// An event that is raised when this object has been fully restored
        /// back to life. In other words, when <see cref="Health"/> is zero and
        /// then becomes a number greater than zero. The
        /// <see cref="ValueChangedEventArgs{T}"/> type passed as the event
        /// argument represents the old value (always 0) and the new value of
        /// the <see cref="Health"/> property.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<float>> Revived;

        /// <summary>
        /// An event that occurs when this instance gains health.  The
        /// <see cref="ValueChangedEventArgs{T}"/> type passed as the event
        /// argument represents the old value and the new value of the
        /// <see cref="Health"/> property.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<float>> Healed;

        /// <summary>
        /// The default value for <see cref="Health"/> when the value is not
        /// specified in the constructor.
        /// </summary>
        public const float DefaultHealth = 1;

        /// <summary>
        /// The default value for <see cref="MaxHealth"/> when the value is not
        /// specified in the constructor.
        /// </summary>
        public const float DefaultMaxHealth = 100;

        /// <summary>
        /// Attaches this extension to the passed in object so that is can be
        /// extended.
        /// </summary>
        /// <param name="extended">The object to extend.</param>
        protected override void AttachTo(object extended)
        {}

        /// <summary>
        /// Removes this extension from an object so that it is no longer extended.
        /// </summary>
        /// <param name="extended">The object to remove the extension from.</param>
        protected override void DetachFrom(object extended)
        {}

        /// <summary>
        /// The backing field to <see cref="Health"/>.
        /// </summary>
        float _health;

        /// <summary>
        /// The backing field to <see cref="MaxHealth"/>.
        /// </summary>
        float _maxHealth;
    }
}