using System;
using System.Collections.Generic;
using System.Diagnostics;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Material;
using Chernobyl.Graphics.Material.Shader.Parameters;
using Chernobyl.Readiness;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Effects
{
    /// <summary>
    /// Represents an XNA effect.
    /// </summary>
    public class XnaEffect : Drawable, IEffect
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="XnaEffect"/> class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other systems.</param>
        public XnaEffect(IEventCollection<object> services)
        {
            services.Inject(this);
        }

        /// <summary>
        /// The XNA effect that gives this effect it's abilities.
        /// </summary>
        public Effect Effect { get; set; }

        /// <summary>
        /// True if this instance has been readied, false if otherwise.
        /// </summary>
        public bool IsReady
        {
            get { return _isReady; }
            protected set
            {
                bool previousValue = _isReady;
                _isReady = value;

                if (previousValue == false && _isReady == true &&
                    _becameReady != null)
                    _becameReady(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// An event that is thrown right after this <see cref="IReadyable"/>
        /// has been readied. If an event handler is added to this event
        /// after it has become ready, then that event handler will be
        /// invoked immediately.
        /// </summary>
        public event EventHandler BecameReady
        {
            add
            {
                if (IsReady == true)
                    value(this, EventArgs.Empty);

                _becameReady += value;
            }
            remove { _becameReady -= value; }
        }

        /// <summary>
        /// Disposes of the XNA effect held by this class.
        /// </summary>
        public virtual void Dispose()
        { 
            Effect.Dispose(); 
        }

        /// <summary>
        /// The parameters that the effect takes usually for the purpose of
        /// setting variables in a shader.
        /// </summary>
        public IEnumerable<IShaderParameter> Parameters
        {
            get
            {
                if(_parameters == null)
                {
                    if(IsReady == false)
                        throw new NotReadyException("Unable to return the " + 
                        "parameters as this instance is not ready. Listen to " + 
                        "IReadyable.BecameReady event on this instance to " + 
                        "know when this instance is ready.");

                    List<IShaderParameter> parameters = new List<IShaderParameter>(Effect.Parameters.Count);

                    foreach (EffectParameter effectParameter in Effect.Parameters)
                    {
                        IShaderParameter shaderParam = ParameterConverter(effectParameter);
                        if(shaderParam == null)
                        {
                            // the parameter converter method could not handle the 
                            // effect parameter so we are going to try using one 
                            // of the effect parameter converters
                            Func<EffectParameter, IShaderParameter> parameterConverter;
                            if (EffectParameterConverters.TryGetValue(effectParameter.ParameterType, out parameterConverter) == true)
                                shaderParam = parameterConverter(effectParameter);
                        }
                            
                        if(shaderParam != null)
                            parameters.Add(shaderParam);
                        else
                        {
                            XnaPlugin.Trace.TraceEvent(TraceEventType.Warning, 0,
                                "Failed to convert the XNA EffectParameter \"" + effectParameter.Name + "\" to a Chernobyl IShaderParameter. " +
                                "The \"" + typeof(XnaEffect).FullName + ".ParameterConverter(EffectParameter)\" " +
                                "method did not convert the XNA EffectParameter and there was no converter for an \"" +
                                effectParameter.ParameterType + "\" in the \"" + EffectParameterConverters.GetType().FullName +
                                "\" service.");
                        }
                    }

                    _parameters = parameters;
                }

                return _parameters;
            }
        }

        /// <summary>
        /// Converts the XNA <see cref="EffectParameter"/> to a Chernobyl 
        /// <see cref="IShaderParameter"/>. This method always returns null. 
        /// Overload it to provide your own functionality.
        /// </summary>
        /// <param name="param">The <see cref="EffectParameter"/> to convert.</param>
        /// <returns>The converted <see cref="IShaderParameter"/> or null if the 
        /// parameter could not be converted.</returns>
        protected virtual IShaderParameter ParameterConverter(EffectParameter param)
        {
            return null;
        }

        /// <summary>
        /// A <see cref="SortedList{TKey, TValue}"/> that holds mappings of an
        /// <see cref="EffectParameterType"/> to converter methods. These 
        /// converter methods are responsible for converting the passed in XNA
        /// <see cref="EffectParameter"/> (which of type <see cref="EffectParameterType"/>) 
        /// to a Chernobyl <see cref="IShaderParameter"/>.
        /// </summary>
        [Inject]
        public SortedList<EffectParameterType, Func<EffectParameter, IShaderParameter>> EffectParameterConverters
        {
            get { return _effectParameterConverters; }
            set
            {
                _effectParameterConverters = value;
                IsReady = CheckIfReady();
            }
        }

        /// <summary>
        /// Overrides <see cref="IEffect"/>.
        /// </summary>
        public IEffect Controller { get; private set; }

        /// <summary>
        /// Determines whether this instance is ready and returns a value 
        /// indicating that readiness.
        /// </summary>
        /// <returns>True if this instance is ready, false if otherwise.</returns>
        protected virtual bool CheckIfReady()
        {
            return (_effectParameterConverters != null);
        }

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

        /// <summary>
        /// The backing field to <see cref="BecameReady"/>.
        /// </summary>
        EventHandler _becameReady;

        /// <summary>
        /// The backing field to <see cref="Parameters"/>.
        /// </summary>
        IEnumerable<IShaderParameter> _parameters;

        /// <summary>
        /// The backing field to <see cref="EffectParameterConverters"/>.
        /// </summary>
        SortedList<EffectParameterType, Func<EffectParameter, IShaderParameter>> _effectParameterConverters;
    }
}