using System;
using Chernobyl.Event;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Material.Shader.Parameters;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Effects
{
    /// <summary>
    /// The base class for all XNA shader parameters.
    /// </summary>
    /// <typeparam name="TValue">The type of the value being set into the shader parameter.</typeparam>
    public abstract class XnaShaderParameter<TValue> : Drawable, IShaderParameter<TValue>
    {
        /// <summary>
        /// Invoked right after the value of the shader parameter changes.
        /// </summary>
        public event EventHandler<ValueChangedEventArgs<TValue>> ValueChanged
        {
            add {ValueChangedMethod += value; }
            remove { ValueChangedMethod -=  value; }
        }

        /// <summary>
        /// The value of the shader parameter.
        /// </summary>
        public abstract TValue Value { get; set; }

        /// <summary>
        /// The name of the shader parameter within the shader.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// The <see cref="IShaderParameter"/> that controls that implements the
        /// shader parameter. Usually, this controller is an
        /// <see cref="IShaderParameter"/> that controls the shader parameter
        /// from a graphics API like OpenGL or XNA. If this property is null,
        /// then the effect has no controller. This class will always return null.
        /// </summary>
        public IShaderParameter Controller
        {
            get { return null; }
        }

        /// <summary>
        /// Creates a new instance that is a shallow copy of this instance.
        /// </summary>
        /// <returns>The new shallow copied instance.</returns>
        public abstract IShaderParameter<TValue> ShallowClone();

        /// <summary>
        /// Creates a new instance that is a shallow copy of this instance.
        /// </summary>
        /// <returns>The new shallow copied instance.</returns>
        IShaderParameter IShallowCloneable<IShaderParameter>.ShallowClone()
        {
            return ShallowClone();
        }

        /// <summary>
        /// Shallow copies the data from this instance into the instance provided.
        /// </summary>
        /// <param name="destination">The XNA parameter that is to take the copied
        /// data. </param>
        public void ShallowCopyTo(XnaShaderParameter<TValue> destination)
        {
            ((Drawable)this).ShallowCopyTo(destination);
            destination.XnaEffect = XnaEffect;
            destination.EffectParameter = EffectParameter;
            destination.Name = Name;
            destination.Value = Value;
        }

        /// <summary>
        /// The method used to handle the <see cref="ValueChanged"/> event. This 
        /// method is needed because derived classes cannot read/write the 
        /// <see cref="ValueChanged"/> event.
        /// </summary>
        protected EventHandler<ValueChangedEventArgs<TValue>> ValueChangedMethod { get; set; }

        /// <summary>
        /// The XNA effect that holds the shader parameter represented by this
        /// shader parameter class.
        /// </summary>
        protected XnaEffect XnaEffect { get; set; } 

        /// <summary>
        /// The XNA effect parameter.
        /// </summary>
        protected EffectParameter EffectParameter { get; set; }
    }
}