using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Event;
using Chernobyl.Graphics.Material.Shader.Parameters;
using Chernobyl.Graphics.Material.Shader.Parameters.Semantics;
using Chernobyl.Graphics.Texture;
using Chernobyl.Graphics.Xna.Controllers;
using Chernobyl.Graphics.Xna.Controllers.Shaders;
using Chernobyl.Mathematics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Effects
{
    /// <summary>
    /// XNA's BasicEffect wrapped around an XnaEffect.
    /// </summary>
    public class BasicEffect : XnaEffect
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The service object to retrieve the services from.</param>
        public BasicEffect(IEventCollection<object> services) : base(services)
        {
            Services = services;
            services.Inject(this);
        }

        /// <summary>
        /// Disposes of the XNA basic effect.
        /// </summary>
        public override void Dispose()
        {
            if (_xnaEffect != null)
                _xnaEffect.Dispose();
        }

        /// <summary>
        /// Called before the draw method.
        /// </summary>
        public override void PreDraw()
        {
            if (_xnaEffect != null)
            {
                //////////////////////////////////////////////////////////////////////////
                // Set required parameters of the effect
                //////////////////////////////////////////////////////////////////////////
                Matrix tempMatrix;

                // view
                Utility.ToXNAMatrix(out tempMatrix, ViewMatrix.Value);
                _xnaEffect.Parameters[ViewMatrixName].SetValue(tempMatrix);

                // world
                Utility.ToXNAMatrix(out tempMatrix, WorldMatrix.Value);
                _xnaEffect.Parameters[WorldMatrixName].SetValue(tempMatrix);

                // projection
                Utility.ToXNAMatrix(out tempMatrix, ProjectionMatrix.Value);
                _xnaEffect.Parameters[ProjectionMatrixName].SetValue(tempMatrix);

                //_xnaEffect.VertexColorEnabled = true;

                //////////////////////////////////////////////////////////////////////////
                // make sure we are aware of all changes to the matrices
                //////////////////////////////////////////////////////////////////////////
                ViewMatrix.ValueChanged += OnViewMatrixChanged;
                WorldMatrix.ValueChanged += OnWorldMatrixChanged;
                ProjectionMatrix.ValueChanged += OnProjectionMatrixChanged;

                _xnaEffect.Begin();
            }
        }

        /// <summary>
        /// Called when the effect should render itself
        /// and it's children drawables.
        /// </summary>
        public override uint Draw()
        {
            uint result = 0;

            if (_xnaEffect != null)
            {
                foreach (EffectPass pass in _xnaEffect.CurrentTechnique.Passes)
                {
                    pass.Begin();

                    // draw all of the children
                    result = base.Draw();

                    pass.End();
                }
            }

            return result;
        }

        /// <summary>
        /// Called after the draw method.
        /// </summary>
        public override void PostDraw() 
        {
            if (_xnaEffect != null)
            {
                _xnaEffect.End();

                ViewMatrix.ValueChanged -= OnViewMatrixChanged;
                WorldMatrix.ValueChanged -= OnWorldMatrixChanged;
                ProjectionMatrix.ValueChanged -= OnProjectionMatrixChanged;
            }
        }

        /// <summary>
        /// Converts the XNA <see cref="EffectParameter"/> to a Chernobyl
        /// <see cref="IShaderParameter"/>.
        /// </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 override IShaderParameter ParameterConverter(EffectParameter param)
        {
            IShaderParameter chernobylParam = null;

            if (param == _xnaEffect.Parameters[BasicTextureName])
            {
                Microsoft.Xna.Framework.Graphics.Texture2D xnaTexture = param.GetValueTexture2D();
                ITexture texture = xnaTexture == null ? null : new XnaTexture2D(Services, xnaTexture);
                chernobylParam = new ColorTextureParameter(Services, new XnaTextureParameter(Services, this, param, texture, param.Name));
            }

            return chernobylParam;
        }

        /// <summary>
        /// The parameter used to set the view matrix.
        /// </summary>
        [Inject]
        public IViewMatrixParameter ViewMatrix
        {
            get { return _viewMatrix; }
            set
            {
                _viewMatrix = value;
                IsReady = CheckIfReady();
            }
        }

        /// <summary>
        /// The parameter used to set the world matrix.
        /// </summary>
        [Inject]
        public IWorldMatrixParameter WorldMatrix
        {
            get { return _worldMatrix; }
            set
            {
                _worldMatrix = value;
                IsReady = CheckIfReady();
            }
        }

        /// <summary>
        /// The parameter used to set the projection matrix.
        /// </summary>
        [Inject]
        public IProjectionMatrixParameter ProjectionMatrix
        {
            get { return _projectionMatrix; }
            set
            {
                _projectionMatrix = value;
                IsReady = CheckIfReady();
            }
        }

        /// <summary>
        /// The <see cref="ContentManager"/> instance used by XNA to manage 
        /// content produced by the content pipeline.
        /// </summary>
        [Inject]
        public ContentManager Content
        {
            get { return _content; }
            set
            {
                _content = value;

                // dispose of the old XNA effect
                if (_xnaEffect != null)
                    _xnaEffect.Dispose();

                Effect = _xnaEffect = _content.Load<Effect>(SimpleEffectFileName);

                IsReady = CheckIfReady();
            }
        }

        /// <summary>
        /// Called when the view matrix is changed during rendering.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event arguments.</param>
        void OnViewMatrixChanged(object sender, ValueChangedEventArgs<Matrix4> e)
        {
            Matrix matrix;
            Utility.ToXNAMatrix(out matrix, e.NewValue);
            _xnaEffect.Parameters[ViewMatrixName].SetValue(matrix);
            _xnaEffect.CommitChanges();
        }

        /// <summary>
        /// Called when the world matrix is changed during rendering.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event arguments.</param>
        void OnWorldMatrixChanged(object sender, ValueChangedEventArgs<Matrix4> e)
        {
            Matrix matrix;
            Utility.ToXNAMatrix(out matrix, e.NewValue);
            _xnaEffect.Parameters[WorldMatrixName].SetValue(matrix);
            _xnaEffect.CommitChanges();
        }

        /// <summary>
        /// Called when the projection matrix is changed during rendering.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The event arguments.</param>
        void OnProjectionMatrixChanged(object sender, ValueChangedEventArgs<Matrix4> e)
        {
            Matrix matrix;
            Utility.ToXNAMatrix(out matrix, e.NewValue);
            _xnaEffect.Parameters[ProjectionMatrixName].SetValue(matrix);
            _xnaEffect.CommitChanges();
        }

        /// <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 override bool CheckIfReady()
        {
            return (base.CheckIfReady() == true && ViewMatrix != null && 
                    WorldMatrix != null && ProjectionMatrix != null &&
                    Content != null);
        }

        /// <summary>
        /// The name of the simple effect file used by this instance.
        /// </summary>
        const string SimpleEffectFileName = "simple_effect";

        /// <summary>
        /// The name of the projection matrix in the simple effect file.
        /// </summary>
        const string WorldMatrixName = "World";

        /// <summary>
        /// The name of the projection matrix in the simple effect file.
        /// </summary>
        const string ViewMatrixName = "View";

        /// <summary>
        /// The name of the projection matrix in the simple effect file.
        /// </summary>
        const string ProjectionMatrixName = "Projection";

        /// <summary>
        /// The name of the basic texture used as a color texture.
        /// </summary>
        const string BasicTextureName = "BasicTexture";

        /// <summary>
        /// The instance that gives out services for use by this type and takes 
        /// services from this type for use by other systems.
        /// </summary>
        IEventCollection<object> Services { get; set; }

        /// <summary>
        /// The XNA basic effect that provides actual rendering.
        /// </summary>
        Effect _xnaEffect;

        /// <summary>
        /// The backing field to <see cref="ViewMatrix"/>.
        /// </summary>
        IViewMatrixParameter _viewMatrix;

        /// <summary>
        /// The backing field to <see cref="WorldMatrix"/>.
        /// </summary>
        IWorldMatrixParameter _worldMatrix;

        /// <summary>
        /// The backing field to <see cref="ProjectionMatrix"/>.
        /// </summary>
        IProjectionMatrixParameter _projectionMatrix;

        /// <summary>
        /// The backing field to <see cref="Content"/>.
        /// </summary>
        ContentManager _content;
    }
}