using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using System.Xml;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
using DarkWynter.Stream.PhysicsGpu;

namespace PlayerTrace
{
    public class Face
    {
        public Vector3 vert0;
        public Vector3 vert1;
        public Vector3 vert2;
        public Vector3 vert3;
        public Vector3 normal;

        public GpuVariable gpuTexture;

        private VertexDeclaration vertexDeclaration;
        VertexPositionTexture[] vertices;


        Shader shaderType = Shader.Textured;
        public enum Shader
        {
            Colored,
            Textured,
            PixelGrid,
            PlayerTrace,
            VisibilityTest
        };

        Texture2D texture;
        Color color;

        public Face(XmlNode node, GraphicsDevice gd, ContentManager content, Effect effect)
        {
            if (node.Name == "face")
            {
                try
                {
                    vert0.X = float.Parse(node.ChildNodes[0].Attributes["x"].Value);
                    vert0.Y = float.Parse(node.ChildNodes[0].Attributes["y"].Value);
                    vert0.Z = float.Parse(node.ChildNodes[0].Attributes["z"].Value);

                    vert1.X = float.Parse(node.ChildNodes[1].Attributes["x"].Value);
                    vert1.Y = float.Parse(node.ChildNodes[1].Attributes["y"].Value);
                    vert1.Z = float.Parse(node.ChildNodes[1].Attributes["z"].Value);

                    vert2.X = float.Parse(node.ChildNodes[2].Attributes["x"].Value);
                    vert2.Y = float.Parse(node.ChildNodes[2].Attributes["y"].Value);
                    vert2.Z = float.Parse(node.ChildNodes[2].Attributes["z"].Value);

                    vert3.X = float.Parse(node.ChildNodes[3].Attributes["x"].Value);
                    vert3.Y = float.Parse(node.ChildNodes[3].Attributes["y"].Value);
                    vert3.Z = float.Parse(node.ChildNodes[3].Attributes["z"].Value);

                    normal.X = float.Parse(node.ChildNodes[4].Attributes["x"].Value);
                    normal.Y = float.Parse(node.ChildNodes[4].Attributes["y"].Value);
                    normal.Z = float.Parse(node.ChildNodes[4].Attributes["z"].Value);

                    vertices = new VertexPositionTexture[6];

                    vertices[0].Position = vert0;
                    vertices[0].TextureCoordinate.X = 0;
                    vertices[0].TextureCoordinate.Y = 0;

                    vertices[1].Position = vert1;
                    vertices[1].TextureCoordinate.X = 0;
                    vertices[1].TextureCoordinate.Y = 1;

                    vertices[2].Position = vert2;
                    vertices[2].TextureCoordinate.X = 1;
                    vertices[2].TextureCoordinate.Y = 1;

                    vertices[3].Position = vert0;
                    vertices[3].TextureCoordinate.X = 0;
                    vertices[3].TextureCoordinate.Y = 0;

                    vertices[4].Position = vert2;
                    vertices[4].TextureCoordinate.X = 1;
                    vertices[4].TextureCoordinate.Y = 1;

                    vertices[5].Position = vert3;
                    vertices[5].TextureCoordinate.X = 1;
                    vertices[5].TextureCoordinate.Y = 0;

                    vertexDeclaration = new VertexDeclaration(gd, VertexPositionTexture.VertexElements);
                    gpuTexture = new GpuVariable(gd, "PixelGrid", effect.Parameters["modelTexture1"], true, 0.0f, 1.0f);

                    texture = content.Load<Texture2D>("CreditScreen");
                    color = Color.DarkGreen;

                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
            }
        }

        public void Draw(GraphicsDevice device, Effect effect)
        {
            Matrix worldMatrix = Matrix.Identity;

            // Set Shader Parameters
            if (shaderType == Shader.Colored)
            {
                // Draw with a set color
                effect.CurrentTechnique = effect.Techniques["Colored"];
                effect.Parameters["World"].SetValue(worldMatrix);
                effect.Parameters["Color"].SetValue(new Vector4(color.R, color.G, color.B, color.A));
            }
            else if (shaderType == Shader.Textured)
            {
                // Displays a texture allowing visual inspection of the Face orientations.
                effect.CurrentTechnique = effect.Techniques["Textured"];
                effect.Parameters["World"].SetValue(worldMatrix);
                effect.Parameters["modelTexture1"].SetValue(texture);
            }
            else if (shaderType == Shader.PixelGrid)
            {
                // Demonstrates the gpuTextures pixel size when mapped onto Face.
                effect.CurrentTechnique = effect.Techniques["PixelGrid"];
                effect.Parameters["World"].SetValue(worldMatrix);
                effect.Parameters["modelTexture1"].SetValue(gpuTexture._read);
            }
            else if (shaderType == Shader.VisibilityTest)
            {
                effect.CurrentTechnique = effect.Techniques["VisibilityTest"];
                effect.Parameters["World"].SetValue(worldMatrix);
                effect.Parameters["modelTexture1"].SetValue(gpuTexture._read);
            }
            else if (shaderType == Shader.PlayerTrace)
            {
                effect.CurrentTechnique = effect.Techniques["PlayerTrace"];
                effect.Parameters["World"].SetValue(worldMatrix);
                effect.Parameters["modelTexture1"].SetValue(gpuTexture._read);
            }

            // Draw
            effect.Begin();
            foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            {
                pass.Begin();

                device.VertexDeclaration = vertexDeclaration;
                device.DrawUserPrimitives(PrimitiveType.TriangleList, vertices, 0, 2);

                pass.End();
            }
            effect.End();
        }

        public void Draw_GPUProcessor()
        {
            //Matrix worldMatrix = Matrix.Identity;
            //effect.CurrentTechnique = effect.Techniques["Textured"];
            //effect.Parameters["World"].SetValue(worldMatrix);
            //effect.Parameters["modelTexture1"].SetValue(texture._read);
            //effect.Begin();
            //foreach (EffectPass pass in effect.CurrentTechnique.Passes)
            //{
            //    pass.Begin();

            //    device.VertexDeclaration = vertexDeclaration;
            //    device.DrawUserPrimitives(PrimitiveType.TriangleList, vertices, 0, 2);

            //    pass.End();
            //}
            //effect.End();
        }
    }
}