using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace nullmaterials.Effects
{
    public class NullMaterial : NullEffect, INullMaterial
    {
        private EffectTechnique _compositeTechnique;
        private EffectTechnique _depthpassTechnique;
        private Vector3 _diffuseColor;
        private EffectParameter _diffuseColorParam;
        private Texture2D _diffuseTexture;
        private EffectParameter _diffuseTextureParam;
        private float _farClip;
        private EffectParameter _farClipParam;
        private float _fresnelPower;
        private EffectParameter _fresnelPowerParam;
        private Vector2 _invViewport;
        private EffectParameter _invViewportParam;
        private Texture2D _normalMap;
        private EffectParameter _normalMapParam;
        private EffectTechnique _prepassTechnique;
        private Matrix _projection;
        private Vector3 _specularColor;
        private EffectParameter _specularColorParam;
        private float _specularPower;
        private EffectParameter _specularPowerParam;
        private Matrix _view;
        private Matrix _viewInverseTranspose;
        private Matrix _viewProjection;
        private EffectParameter _vitProjParam;
        private Matrix _world;
        private EffectParameter _worldParam;
        private Matrix _worldView;
        private Matrix _worldViewInverseTranspose;
        private Matrix _worldViewProjection;
        private EffectParameter _wvParam;
        private EffectParameter _wvitProjParam;
        private EffectParameter _wvpParam;
        private EffectTechnique _normalMappedPrepassTechnique;
        private EffectTechnique _texturedCompositeTechnique;
        private EffectTechnique _technique;

        public NullMaterial(Effect cloneSource)
            : base(cloneSource)
        {
            SetupMaterial();
        }


        public Texture2D NormalMap
        {
            get { return _normalMap; }
            set
            {
                _normalMap = value;
                _normalMapParam.SetValue(value);
            }
        }

        public Texture2D DiffuseTexture
        {
            get { return _diffuseTexture; }
            set
            {
                _diffuseTexture = value;
                _diffuseTextureParam.SetValue(value);
            }
        }

        public Vector3 DiffuseColor
        {
            get { return _diffuseColor; }
            set
            {
                _diffuseColor = value;
                _diffuseColorParam.SetValue(value);
            }
        }

        public Vector3 SpecularColor
        {
            get { return _specularColor; }
            set
            {
                _specularColor = value;
                _specularColorParam.SetValue(value);
            }
        }

        public float SpecularPower
        {
            get { return _specularPower; }
            set
            {
                _specularPower = value;
                _specularPowerParam.SetValue(value);
            }
        }

        public float FresnelPower
        {
            get { return _fresnelPower; }
            set
            {
                _fresnelPower = value;
                _fresnelPowerParam.SetValue(value);
            }
        }

        #region INullMaterial Members

        public Matrix ViewProjection
        {
            get { return _viewProjection; }
            set { _viewProjection = value; }
        }

        public Vector2 InverseViewport
        {
            get { return _invViewport; }
            set
            {
                _invViewport = value;
                _invViewportParam.SetValue(value);
            }
        }

        public Matrix World
        {
            get { return _world; }
            set { _world = value; }
        }

        public Matrix View
        {
            get { return _view; }
            set { _view = value; }
        }

        public Matrix Projection
        {
            get { return _projection; }
            set { _projection = value; }
        }

        public float FarClip
        {
            get { return _farClip; }
            set
            {
                _farClip = value;
                _farClipParam.SetValue(value);
            }
        }

        public void ApplyDepthPass()
        {
            Matrix wvp;
            Matrix.Multiply(ref _world, ref _viewProjection, out wvp);
            _wvpParam.SetValue(wvp);

            CurrentTechnique = _depthpassTechnique;
            _depthpassTechnique.Passes[0].Apply();
        }

        public void ApplyPrePass()
        {
            _technique = _normalMap == null ? _prepassTechnique : _normalMappedPrepassTechnique;
            CurrentTechnique = _technique;
            _technique.Passes[0].Apply();
        }

        public void ApplyCompositePass()
        {
            _technique = _diffuseTexture == null ? _compositeTechnique : _texturedCompositeTechnique;
            CurrentTechnique = _technique;
            _technique.Passes[0].Apply();
        }

        public new INullMaterial Clone()
        {
            return new NullMaterial(this)
                       {
                           DiffuseColor = DiffuseColor,
                           DiffuseTexture = DiffuseTexture,
                           SpecularColor = SpecularColor,
                           SpecularPower = SpecularPower,
                           NormalMap = NormalMap,
                           FresnelPower = FresnelPower
                       };
        }

        public void PrepareDraw()
        {
            Matrix.Multiply(ref _world, ref _view, out _worldView);
            Matrix.Transpose(ref _worldView, out _worldViewInverseTranspose);
            Matrix.Invert(ref _worldViewInverseTranspose, out _worldViewInverseTranspose);

            Matrix.Multiply(ref _worldView, ref _projection, out _worldViewProjection);

            Matrix.Transpose(ref _view, out _viewInverseTranspose);
            Matrix.Invert(ref _viewInverseTranspose, out _viewInverseTranspose);

            _worldParam.SetValue(_world);
            _wvitProjParam.SetValue(_worldViewInverseTranspose);
            _vitProjParam.SetValue(_viewInverseTranspose);
            _wvParam.SetValue(_worldView);
            _wvpParam.SetValue(_worldViewProjection);
        }

        #endregion

        private void SetupMaterial()
        {
            _diffuseTextureParam = Parameters["DiffuseTexture"];
            _diffuseColorParam = Parameters["DiffuseColor"];
            _specularColorParam = Parameters["SpecularColor"];
            _specularPowerParam = Parameters["SpecularPower"];
            _fresnelPowerParam = Parameters["FresnelPower"];

            _normalMapParam = Parameters["NormalTexture"];

            _worldParam = Parameters["World"];
            _wvParam = Parameters["WorldView"];
            _wvpParam = Parameters["WorldViewProjection"];
            _wvitProjParam = Parameters["WorldViewInverseTranspose"];
            _vitProjParam = Parameters["ViewInverseTranspose"];
            _farClipParam = Parameters["FarClip"];
            _invViewportParam = Parameters["InverseViewportDimensions"];

            _prepassTechnique = Techniques["FlatPrepassTechnique"];
            _normalMappedPrepassTechnique = Techniques["NormalMappedPrepassTechnique"];
            _compositeTechnique = Techniques["CompositeTechnique"];
            _texturedCompositeTechnique = Techniques["TexturedCompositeTechnique"];
            _depthpassTechnique = Techniques["DepthTechnique"];
        }
    }
}