using System.Collections.Generic;
using Kav.Extensions;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace Kav
{
    public class Renderer
    {
        private GraphicsDevice GraphicsDevice { get; }
        private int RenderDimensionsX { get; }
        private int RenderDimensionsY { get; }

        private RenderTarget2D DirectionalLightDepthTarget { get; }
        private SimpleDepthEffect SimpleDepthEffect { get; }

        private RenderTarget2D gPosition { get; }
        private RenderTarget2D gNormal { get; }
        private RenderTarget2D gAlbedo { get; }
        private RenderTarget2D gMetallicRoughness { get; }
        private RenderTarget2D deferredRenderTarget { get; }

        private VertexBuffer fullscreenTriangle { get; }

        private RenderTargetBinding[] GBuffer { get; }

        private DeferredPBREffect DeferredPBREffect { get; }

        private SpriteBatch SpriteBatch { get; }

        public Renderer(GraphicsDevice graphicsDevice, int renderDimensionsX, int renderDimensionsY)
        {
            GraphicsDevice = graphicsDevice;
            RenderDimensionsX = renderDimensionsX;
            RenderDimensionsY = renderDimensionsY;

            DirectionalLightDepthTarget = new RenderTarget2D(
                GraphicsDevice,
                1024,
                1024,
                false,
                SurfaceFormat.Single,
                DepthFormat.Depth24
            );

            gPosition = new RenderTarget2D(
                GraphicsDevice,
                renderDimensionsX,
                renderDimensionsY,
                false,
                SurfaceFormat.Vector4,
                DepthFormat.Depth24
            );

            gNormal = new RenderTarget2D(
                GraphicsDevice,
                renderDimensionsX,
                renderDimensionsY,
                false,
                SurfaceFormat.Vector4,
                DepthFormat.None
            );

            gAlbedo = new RenderTarget2D(
                GraphicsDevice,
                renderDimensionsX,
                renderDimensionsY,
                false,
                SurfaceFormat.Color,
                DepthFormat.None
            );

            gMetallicRoughness = new RenderTarget2D(
                GraphicsDevice,
                renderDimensionsX,
                renderDimensionsY,
                false,
                SurfaceFormat.HalfVector2,
                DepthFormat.None
            );

            GBuffer = new RenderTargetBinding[4] {
                new RenderTargetBinding(gPosition),
                new RenderTargetBinding(gNormal),
                new RenderTargetBinding(gAlbedo),
                new RenderTargetBinding(gMetallicRoughness)
            };
            
            deferredRenderTarget = new RenderTarget2D(
                GraphicsDevice,
                renderDimensionsX,
                renderDimensionsY
            );

            SimpleDepthEffect = new SimpleDepthEffect(GraphicsDevice);
            DeferredPBREffect = new DeferredPBREffect(GraphicsDevice);

            fullscreenTriangle = new VertexBuffer(GraphicsDevice, typeof(VertexPositionTexture), 3, BufferUsage.WriteOnly);
            fullscreenTriangle.SetData(new VertexPositionTexture[3] {
                new VertexPositionTexture(new Vector3(-1, -1, 0), new Vector2(0, 0)),
                new VertexPositionTexture(new Vector3(-1, 3, 0), new Vector2(0, -2)),
                new VertexPositionTexture(new Vector3(3, -1, 0), new Vector2(2, 0))
            });

            SpriteBatch = new SpriteBatch(GraphicsDevice);

            GraphicsDevice.SetRenderTarget(deferredRenderTarget);
            graphicsDevice.Clear(Color.White);

            GraphicsDevice.SetRenderTarget(DirectionalLightDepthTarget);
            GraphicsDevice.Clear(Color.White);

            GraphicsDevice.SetRenderTarget(null);
        }

        public void DeferredRender(
            Camera camera,
            IEnumerable<(Model, Matrix)> modelTransforms,
            IEnumerable<PointLight> pointLights,
            DirectionalLight directionalLight
        ) {
            var cameraViewProjectionMatrix = camera.View * camera.Projection;

            ShadowMapRender(
                modelTransforms,
                directionalLight,
                cameraViewProjectionMatrix
            );

            GraphicsDevice.SetRenderTargets(GBuffer);
            GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1f, 0);
            GraphicsDevice.DepthStencilState = DepthStencilState.Default;
            GraphicsDevice.BlendState = BlendState.Opaque;

            foreach (var (model, transform) in modelTransforms)
            {
                foreach (var modelMesh in model.Meshes)
                {
                    foreach (var meshPart in modelMesh.MeshParts)
                    {
                        GraphicsDevice.SetVertexBuffer(meshPart.VertexBuffer);
                        GraphicsDevice.Indices = meshPart.IndexBuffer;

                        if (meshPart.Effect is TransformEffect transformEffect)
                        {
                            transformEffect.World = transform;
                            transformEffect.View = camera.View;
                            transformEffect.Projection = camera.Projection;
                        }

                        foreach (var pass in meshPart.Effect.CurrentTechnique.Passes)
                        {
                            pass.Apply();

                            GraphicsDevice.DrawIndexedPrimitives(
                                PrimitiveType.TriangleList,
                                0,
                                0,
                                meshPart.VertexBuffer.VertexCount,
                                0,
                                meshPart.Triangles.Length
                            );
                        }
                    }
                }
            }

            GraphicsDevice.SetRenderTarget(null);
            GraphicsDevice.Clear(Color.CornflowerBlue);

            DeferredPBREffect.GPosition = gPosition;
            DeferredPBREffect.GAlbedo = gAlbedo;
            DeferredPBREffect.GNormal = gNormal;
            DeferredPBREffect.GMetallicRoughness = gMetallicRoughness;
            DeferredPBREffect.EyePosition = Matrix.Invert(camera.View).Translation;

            int i = 0;
            foreach (var pointLight in pointLights)
            {
                if (i > DeferredPBREffect.MaxPointLights) { break; }
                DeferredPBREffect.PointLights[i] = pointLight;
                i++;
            }

            DeferredPBREffect.DirectionalShadowMap = DirectionalLightDepthTarget;
            DeferredPBREffect.DirectionalLightDirection = directionalLight.Direction;
            DeferredPBREffect.DirectionalLightColor = directionalLight.Color.ToVector3() * directionalLight.Intensity;

            foreach (EffectPass pass in DeferredPBREffect.CurrentTechnique.Passes)
            {
                pass.Apply();
                GraphicsDevice.SetVertexBuffer(fullscreenTriangle);
                GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);
            }
        }

        // for shadow mapping
        public void ShadowMapRender(
            IEnumerable<(Model, Matrix)> modelTransforms,
            DirectionalLight directionalLight,
            Matrix cameraViewProjectionMatrix
        ) {
            GraphicsDevice.SetRenderTarget(DirectionalLightDepthTarget);
            GraphicsDevice.Clear(Color.White);
            GraphicsDevice.DepthStencilState = DepthStencilState.Default;
            GraphicsDevice.BlendState = BlendState.Opaque;
            
            var right = Vector3.Cross(Vector3.Up, directionalLight.Direction);
            var up = Vector3.Cross(directionalLight.Direction, right);

            var lightRotation = Matrix.CreateLookAt(Vector3.Zero, -directionalLight.Direction, up);

            var cameraBoundingFrustum = new BoundingFrustum(cameraViewProjectionMatrix);

            Vector3[] frustumCorners = cameraBoundingFrustum.GetCorners();
            for (var i = 0; i < frustumCorners.Length; i++)
            {
                frustumCorners[i] = Vector3.Transform(frustumCorners[i], lightRotation);
            }

            BoundingBox lightBox = BoundingBox.CreateFromPoints(frustumCorners);
            Vector3 boxSize = lightBox.Max - lightBox.Min;
            Vector3 halfBoxSize = boxSize * 0.5f;

            Vector3 lightPosition = lightBox.Min + halfBoxSize;
            lightPosition.Z = lightBox.Min.Z;
            lightPosition = Vector3.Transform(lightPosition, Matrix.Invert(lightRotation));

            SimpleDepthEffect.View = Matrix.CreateLookAt(lightPosition, lightPosition - directionalLight.Direction, up);
            SimpleDepthEffect.Projection = Matrix.CreateOrthographic(boxSize.X, boxSize.Y, -boxSize.Z, boxSize.Z);
            DeferredPBREffect.DirectionalLightMatrix = SimpleDepthEffect.View * SimpleDepthEffect.Projection;

            foreach (var (model, transform) in modelTransforms)
            {
                foreach (var modelMesh in model.Meshes)
                {
                    foreach (var meshPart in modelMesh.MeshParts)
                    {
                        GraphicsDevice.SetVertexBuffer(meshPart.VertexBuffer);
                        GraphicsDevice.Indices = meshPart.IndexBuffer;

                        SimpleDepthEffect.Model = transform;

                        foreach (var pass in SimpleDepthEffect.CurrentTechnique.Passes)
                        {
                            pass.Apply();

                            GraphicsDevice.DrawIndexedPrimitives(
                                PrimitiveType.TriangleList,
                                0,
                                0,
                                meshPart.VertexBuffer.VertexCount,
                                0,
                                meshPart.Triangles.Length
                            );
                        }
                    }
                }
            }
        }

        public void Render(
            Camera camera, 
            IEnumerable<(Model, Matrix)> modelTransforms, 
            IEnumerable<PointLight> pointLights,
            IEnumerable<DirectionalLight> directionalLights
        ) {
            Render(camera.View, camera.Projection, modelTransforms, pointLights, directionalLights);
        }

        private void Render(
            Matrix view,
            Matrix projection,
            IEnumerable<(Model, Matrix)> modelTransforms,
            IEnumerable<PointLight> pointLights,
            IEnumerable<DirectionalLight> directionalLights
        ) {
            foreach (var (model, transform) in modelTransforms)
            {
                foreach (var modelMesh in model.Meshes)
                {
                    foreach (var meshPart in modelMesh.MeshParts)
                    {
                        GraphicsDevice.SetVertexBuffer(meshPart.VertexBuffer);
                        GraphicsDevice.Indices = meshPart.IndexBuffer;

                        if (meshPart.Effect is TransformEffect transformEffect)
                        {
                            transformEffect.World = transform;
                            transformEffect.View = view;
                            transformEffect.Projection = projection;
                        }

                        if (meshPart.Effect is PointLightEffect pointLightEffect)
                        {
                            int i = 0;
                            foreach (var pointLight in pointLights)
                            {
                                if (i > pointLightEffect.MaxPointLights) { break; }
                                pointLightEffect.PointLights[i] = pointLight;
                                i++;
                            }
                        }

                        if (meshPart.Effect is DirectionalLightEffect directionalLightEffect)
                        {
                            int i = 0;
                            foreach (var directionalLight in directionalLights)
                            {
                                if (i > directionalLightEffect.MaxDirectionalLights) { break; }
                                directionalLightEffect.DirectionalLights[i] = directionalLight;
                                i++;
                            }
                        }

                        foreach (var pass in meshPart.Effect.CurrentTechnique.Passes)
                        {
                            pass.Apply();

                            GraphicsDevice.DrawIndexedPrimitives(
                                PrimitiveType.TriangleList,
                                0,
                                0,
                                meshPart.VertexBuffer.VertexCount,
                                0,
                                meshPart.Triangles.Length
                            );
                        }
                    }
                }
            }
        }
    }
}