using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

using Krypton.Lights;
using Krypton.Common;


namespace Krypton
{
    public enum LightMapSize
    {
        Full = 1,
        Fourth = 2,
        Eighth = 4,
    }

    /// <summary>
    /// A GPU-based 2D lighting engine
    /// </summary>
    public class KryptonEngine : DrawableGameComponent
    {
        // The Krypton Effect
        private string mEffectAssetName;
        private Effect mEffect;
        private CullMode mCullMode = CullMode.CullCounterClockwiseFace;

        // The goods
        private List<ShadowHull> mHulls = new List<ShadowHull>();
        private List<ILight2D> mLights = new List<ILight2D>();

        // World View Projection matrix, and it's min and max view bounds
        private Matrix mWVP = Matrix.Identity;
        private bool mSpriteBatchCompatabilityEnabled = false;
        private BoundingRect mBounds = BoundingRect.MinMax;

        // Blur
        private float mBluriness = 0.25f;
        private RenderTarget2D mMapBlur;

        // Light maps
        private RenderTarget2D mMap;
        private Color mAmbientColor = new Color(35,35,35);
        private LightMapSize mLightMapSize = LightMapSize.Full;

        /// <summary>
        /// Krypton's render helper. It helps render. It also needs to be re-written.
        /// </summary>
        public KryptonRenderHelper RenderHelper { get; private set; }

        /// <summary>
        /// Gets or sets a value indicating how Krypton should cull geometry. The default value is CullMode.CounterClockwise
        /// </summary>
        public CullMode CullMode
        {
            get { return this.mCullMode; }
            set { this.mCullMode = value; }
        }

        /// <summary>
        /// The collection of lights krypton uses to render shadows
        /// </summary>
        public List<ILight2D> Lights { get { return this.mLights; } }

        /// <summary>
        /// The collection of hulls krypton uses to render shadows
        /// </summary>
        public List<ShadowHull> Hulls { get { return this.mHulls; } }

        /// <summary>
        /// Gets or sets the matrix used to draw the light map. This should match your scene's matrix.
        /// </summary>
        public Matrix Matrix
        {
            get { return this.mWVP; }
            set
            {
                if (this.mWVP != value)
                {
                    this.mWVP = value;

                    // This is totally ghetto, but it works for now. :)
                    // Compute the world-space bounds of the given matrix
                    var inverse = Matrix.Invert(value);

                    var v1 = Vector2.Transform(new Vector2(1, 1), inverse);
                    var v2 = Vector2.Transform(new Vector2(1, -1), inverse);
                    var v3 = Vector2.Transform(new Vector2(-1, -1), inverse);
                    var v4 = Vector2.Transform(new Vector2(-1, 1), inverse);

                    this.mBounds.Min = v1;
                    this.mBounds.Min = Vector2.Min(this.mBounds.Min, v2);
                    this.mBounds.Min = Vector2.Min(this.mBounds.Min, v3);
                    this.mBounds.Min = Vector2.Min(this.mBounds.Min, v4);

                    this.mBounds.Max = v1;
                    this.mBounds.Max = Vector2.Max(this.mBounds.Max, v2);
                    this.mBounds.Max = Vector2.Max(this.mBounds.Max, v3);
                    this.mBounds.Max = Vector2.Max(this.mBounds.Max, v4);

                    this.mBounds = BoundingRect.MinMax;
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating weither or not to use SpriteBatch's matrix when drawing lightmaps
        /// </summary>
        public bool SpriteBatchCompatablityEnabled
        {
            get { return this.mSpriteBatchCompatabilityEnabled; }
            set { this.mSpriteBatchCompatabilityEnabled = value; }
        }

        /// <summary>
        /// Ambient color of the light map. Lights + AmbientColor = Final 
        /// </summary>
        public Color AmbientColor
        {
            get { return this.mAmbientColor; }
            set { this.mAmbientColor = value; }
        }

        /// <summary>
        /// Gets or sets the value used to determine light map size
        /// </summary>
        public LightMapSize LightMapSize
        {
            get { return this.mLightMapSize; }
            set
            {
                if (this.mLightMapSize != value)
                {
                    this.mLightMapSize = value;
                    this.DisposeRenderTargets();
                    this.CreateRenderTargets();
                }
            }
        }

        /// <summary>
        /// Gets or sets a value indicating how much to blur the final light map. If the value is zero, the lightmap will not be blurred
        /// </summary>
        public float Bluriness
        {
            get { return this.mBluriness; }
            set { this.mBluriness = Math.Max(0, value); }
        }

        /// <summary>
        /// Constructs a new instance of krypton
        /// </summary>
        /// <param name="game">Your game object</param>
        /// <param name="effectAssetName">The asset name of Krypton's effect file, which must be included in your content project</param>
        public KryptonEngine(Game game, string effectAssetName)
            : base(game)
        {
            this.mEffectAssetName = effectAssetName;
        }

        /// <summary>
        /// Initializes Krpyton, and hooks itself to the graphics device
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();

            this.GraphicsDevice.DeviceReset += new EventHandler<EventArgs>(GraphicsDevice_DeviceReset);
        }

        /// <summary>
        /// Resets kryptons graphics device resources
        /// </summary>
        private void GraphicsDevice_DeviceReset(object sender, EventArgs e)
        {
            this.DisposeRenderTargets();
            this.CreateRenderTargets();
        }

        /// <summary>
        /// Load's the graphics related content required to draw light maps
        /// </summary>
        protected override void LoadContent()
        {
            // This needs to better handle content loading...
            // if the window is resized, Krypton needs to notice.
            this.mEffect = this.Game.Content.Load<Effect>(this.mEffectAssetName);
            this.RenderHelper = new KryptonRenderHelper(this.GraphicsDevice, this.mEffect);

            this.CreateRenderTargets();
        }

        /// <summary>
        /// Unload's the graphics content required to draw light maps
        /// </summary>
        protected override void UnloadContent()
        {
            this.DisposeRenderTargets();
        }

        /// <summary>
        /// Creates render targets
        /// </summary>
        private void CreateRenderTargets()
        {
            var targetWidth = GraphicsDevice.Viewport.Width / (int)(this.mLightMapSize);
            var targetHeight = GraphicsDevice.Viewport.Height / (int)(this.mLightMapSize);

            this.mMap = new RenderTarget2D(GraphicsDevice, targetWidth, targetHeight, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PlatformContents);
            this.mMapBlur = new RenderTarget2D(GraphicsDevice, targetWidth, targetHeight, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PlatformContents);
        }

        /// <summary>
        /// Disposes of render targets
        /// </summary>
        private void DisposeRenderTargets()
        {
            KryptonEngine.TryDispose(this.mMap);
            KryptonEngine.TryDispose(this.mMapBlur);
        }

        /// <summary>
        /// Attempts to dispose of disposable objects, and assigns them a null value afterward
        /// </summary>
        /// <param name="obj"></param>
        private static void TryDispose(IDisposable obj)
        {
            if (obj != null)
            {
                obj.Dispose();
                obj = null;
            }
        }

        /// <summary>
        /// Draws the light map to the current render target
        /// </summary>
        /// <param name="gameTime">N/A - Required</param>
        public override void Draw(GameTime gameTime)
        {
            this.LightMapPresent();
        }

        /// <summary>
        /// Prepares the light map to be drawn (pre-render)
        /// </summary>
        public void LightMapPrepare()
        {
            // Prepare and set the matrix
            var viewWidth = this.GraphicsDevice.ScissorRectangle.Width;
            var viewHeight = this.GraphicsDevice.ScissorRectangle.Height;

            // Prepare the matrix with optional settings and assign it to an effect parameter
            Matrix lightMapMatrix = this.LightmapMatrixGet();
            this.mEffect.Parameters["Matrix"].SetValue(lightMapMatrix);

            // Obtain the original rendering states
            var originalRenderTargets = this.GraphicsDevice.GetRenderTargets();

            // Set and clear the target
            this.GraphicsDevice.SetRenderTarget(this.mMap);
            this.GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.Stencil, this.mAmbientColor, 0, 1);

            // Make sure we're culling the right way!
            this.GraphicsDevice.RasterizerState = KryptonEngine.RasterizerStateGetFromCullMode(this.mCullMode);

            // put the render target's size into a more friendly format
            var targetSize = new Vector2(this.mMap.Width, this.mMap.Height);

            // Render Light Maps
            foreach (var light in this.mLights)
            {
                // Loop through each light within the view frustum
                if (light.Bounds.Intersects(this.mBounds))
                {
                    // Clear the stencil and set the scissor rect (because we're stretching geometry past the light's reach)
                    this.GraphicsDevice.Clear(ClearOptions.Stencil, Color.Black, 0, 1);
                    this.GraphicsDevice.ScissorRectangle = KryptonEngine.ScissorRectCreateForLight(light, lightMapMatrix, targetSize);
                    
                    // Draw the light!
                    light.Draw(this.RenderHelper, this.mHulls);
                }
            }

            if (this.mBluriness > 0)
            {
                // Blur the shadow map horizontally to the blur target
                this.GraphicsDevice.SetRenderTarget(this.mMapBlur);
                this.RenderHelper.BlurTextureToTarget(this.mMap, LightMapSize.Full, BlurTechnique.Horizontal, this.mBluriness);

                // Blur the shadow map vertically back to the final map
                this.GraphicsDevice.SetRenderTarget(this.mMap);
                this.RenderHelper.BlurTextureToTarget(this.mMapBlur, LightMapSize.Full, BlurTechnique.Vertical, this.mBluriness);
            }

            // Reset to the original rendering states
            this.GraphicsDevice.SetRenderTargets(originalRenderTargets);
        }

        /// <summary>
        /// Returns the final, modified matrix used to render the lightmap.
        /// </summary>
        /// <returns></returns>
        private Matrix LightmapMatrixGet()
        {
            if (this.mSpriteBatchCompatabilityEnabled)
            {
                float xScale = (this.GraphicsDevice.Viewport.Width > 0) ? (1f / this.GraphicsDevice.Viewport.Width) : 0f;
                float yScale = (this.GraphicsDevice.Viewport.Height > 0) ? (-1f / this.GraphicsDevice.Viewport.Height) : 0f;

                // This is the default matrix used to render sprites via spritebatch
                var matrixSpriteBatch = new Matrix()
                {
                    M11 = xScale * 2f,
                    M22 = yScale * 2f,
                    M33 = 1f,
                    M44 = 1f,
                    M41 = -1f - xScale,
                    M42 = 1f - yScale,
                };

                // Return krypton's matrix, compensated for use with SpriteBatch
                return this.mWVP * matrixSpriteBatch;
            }
            else
            {
                // Return krypton's matrix
                return this.mWVP;
            }
        }

        /// <summary>
        /// Gets a pixel-space rectangle which contains the light passed in
        /// </summary>
        /// <param name="light">The light used to create the rectangle</param>
        /// <param name="matrix">the WorldViewProjection matrix being used to render</param>
        /// <param name="targetSize">The rendertarget's size</param>
        /// <returns></returns>
        private static Rectangle ScissorRectCreateForLight(ILight2D light, Microsoft.Xna.Framework.Matrix matrix, Vector2 targetSize)
        {
            // This needs refining, but it works as is (I believe)
            var lightBounds = light.Bounds;

            var min = KryptonEngine.VectorToPixel(lightBounds.Min, matrix, targetSize);
            var max = KryptonEngine.VectorToPixel(lightBounds.Max, matrix, targetSize);

            var min2 = Vector2.Min(min, max);
            var max2 = Vector2.Max(min, max);

            min = Vector2.Clamp(min2, Vector2.Zero, targetSize);
            max = Vector2.Clamp(max2, Vector2.Zero, targetSize);

            return new Rectangle((int)(min.X), (int)(min.Y), (int)(max.X - min.X), (int)(max.Y - min.Y));
        }

        /// <summary>
        /// Takes a screen-space vector and puts it in to pixel space
        /// </summary>
        /// <param name="v"></param>
        /// <param name="matrix"></param>
        /// <param name="targetSize"></param>
        /// <returns></returns>
        private static Vector2 VectorToPixel(Vector2 v, Matrix matrix, Vector2 targetSize)
        {
            Vector2.Transform(ref v, ref matrix, out v);

            v.X = (1 + v.X) * (targetSize.X / 2f);
            v.Y = (1 - v.Y) * (targetSize.Y / 2f);

            return v;
        }

        /// <summary>
        /// Takes a screen-space size vector and converts it to a pixel-space size vector
        /// </summary>
        /// <param name="v"></param>
        /// <param name="matrix"></param>
        /// <param name="targetSize"></param>
        /// <returns></returns>
        private static Vector2 ScaleToPixel(Vector2 v, Matrix matrix, Vector2 targetSize)
        {
            v.X *= matrix.M11 * (targetSize.X / 2f);
            v.Y *= matrix.M22 * (targetSize.Y / 2f);

            return v;
        }

        /// <summary>
        /// Retrieves a rasterize state by using the cull mode as a lookup
        /// </summary>
        /// <param name="cullMode">The cullmode used to lookup the rasterize state</param>
        /// <returns></returns>
        private static RasterizerState RasterizerStateGetFromCullMode(CullMode cullMode)
        {
            switch (cullMode)
            {
                case (CullMode.CullCounterClockwiseFace):
                    return RasterizerState.CullCounterClockwise;

                case (CullMode.CullClockwiseFace):
                    return RasterizerState.CullClockwise;

                default:
                    return RasterizerState.CullNone;
            }
        }

        /// <summary>
        /// Presents the light map to the current render target
        /// </summary>
        private void LightMapPresent()
        {
            RenderHelper.DrawTextureToTarget(this.mMap, this.mLightMapSize, BlendTechnique.Multiply);
        }
    }
}