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 BootHillHeroes.GameScreens;
using BootHillHeroes.Components;
using Skyboxes;
//using Microsoft.Xna.Framework.Net;
//using Microsoft.Xna.Framework.Storage;

namespace BHB_Code.Hall.FirstShader
{
	public enum EffectTechnique
	{
		Default,
		Ambient,
		Diffuse,
		Specular,
		SpecularTwo,
		Texture,
		NormalMap,
		Toon,
	}

	/// <summary>
	/// This is the main type for your game
	/// </summary>
	public class FirstShader
	{
		GraphicsDeviceManager graphics;
		SpriteBatch spriteBatch;

		Matrix world = Matrix.CreateTranslation(0, 0, 0);
		Matrix view = Matrix.CreateLookAt(new Vector3(0, 0, 10), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
		Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45), 800f / 600f, 0.1f, 100f);
		BasicEffect effect;
		Effect specularEffect;
		Effect specularTwoEffect;
		Effect ambientEffect;
		Effect diffuseEffect;
		Effect textureEffect;
		Effect normalMapEffect;
		Effect toonEffect;
		float angle = 0;
		float distance = 10;

		Texture2D texture;
		Texture2D normalMap;

		Model model;
		Vector3 viewVector;
		GraphicsDevice device;
		Vector3 camPosition = Vector3.Zero;
		List<EffectTechnique> effectTechniques = new List<EffectTechnique>() {
			EffectTechnique.Default,
			EffectTechnique.Ambient,
			EffectTechnique.Diffuse,
			EffectTechnique.Specular,
			EffectTechnique.SpecularTwo,
			EffectTechnique.Texture,
			EffectTechnique.NormalMap,
			EffectTechnique.Toon,
		};
		int effectIndex = 0;

		//For skybox
		Skybox skybox;

		//public FirstShader(GraphicsDeviceManager Graphics, SpriteBatch SpriteBatch)
		public FirstShader(GraphicsDevice Device)
		{
			device = Device;

			effect = new BasicEffect(device);
			//graphics = new GraphicsDeviceManager(this);
			//spriteBatch = SpriteBatch;
			model = DataManager.GetModel("Helicopter6", BaseGameState.PlayerContent);
			ambientEffect = DataManager.GetEffect("Ambient", BaseGameState.PlayerContent);
			diffuseEffect = DataManager.GetEffect("Diffuse", BaseGameState.PlayerContent);
			specularEffect = DataManager.GetEffect("Specular", BaseGameState.PlayerContent);
			specularTwoEffect = DataManager.GetEffect("Specular2", BaseGameState.PlayerContent);
			textureEffect = DataManager.GetEffect("Texture", BaseGameState.PlayerContent);
			texture = DataManager.GetMansionTexture("helicopterTexture", BaseGameState.PlayerContent);
			normalMapEffect = DataManager.GetEffect("NormalMap", BaseGameState.PlayerContent);
			normalMap = DataManager.GetMansionTexture("helicopterNormalMap", BaseGameState.PlayerContent);
			toonEffect = DataManager.GetEffect("Toon", BaseGameState.PlayerContent);

			//skybox
			skybox = new Skyboxes.Skybox();

		}



		public void Update(GameTime gameTime)
		{
			if (XRpgLibrary.InputHandler.KeyReleased(Keys.Right)) //move left
			{
				effectIndex++;
				if (effectIndex > effectTechniques.Count - 1)
					effectIndex = 0;
			}
			if (XRpgLibrary.InputHandler.KeyReleased(Keys.Left)) //move left
			{
				effectIndex--;
				if (effectIndex < 0)
					effectIndex = effectTechniques.Count - 1;
			}


			angle += 0.002f;

			//view = Matrix.CreateLookAt(distance * new Vector3((float)Math.Sin(angle), 0, (float)Math.Cos(angle)), new Vector3(0, 0, 0), new Vector3(0, 1, 0));


			Vector3 cameraLocation = distance * new Vector3((float)Math.Sin(angle), 0, (float)Math.Cos(angle));

			camPosition = cameraLocation;


			Vector3 cameraTarget = new Vector3(0, 0, 0);
			viewVector = Vector3.Transform(cameraTarget - cameraLocation, Matrix.CreateRotationY(0));
			viewVector.Normalize();

			//these two views are essentially the same
			view = Matrix.CreateLookAt(camPosition, new Vector3(0, 0, 0), Vector3.UnitY);
			//view = Matrix.CreateLookAt(cameraLocation, cameraTarget, new Vector3(0, 1, 0));

		}
		public void Draw(GameTime gameTime)
		{
			device.Clear(Color.Black);
			device.BlendState = BlendState.Opaque;
			device.DepthStencilState = DepthStencilState.Default;


			RasterizerState originalRasterizerState = device.RasterizerState;
			RasterizerState rasterizerState = new RasterizerState();
			rasterizerState.CullMode = CullMode.None;
			device.RasterizerState = rasterizerState;
			skybox.Draw(view, projection, camPosition);
			device.RasterizerState = originalRasterizerState;

			switch (effectTechniques[effectIndex])
			{
				case EffectTechnique.Default:
					DrawModel(model, world, view, projection);
					break;
				case EffectTechnique.Ambient:
					DrawModelWithAmbientEffect(model, world, view, projection);
					break;
				case EffectTechnique.Diffuse:
					DrawModelWithDiffuseEffect(model, world, view, projection);
					break;
				case EffectTechnique.Specular:
					DrawModelWithSpecularEffect(model, world, view, projection);
					break;
				case EffectTechnique.SpecularTwo:
					DrawModelWithSpecularTwoEffect(model, world, view, projection);
					break;
				case EffectTechnique.Texture:
					DrawModelWithTextureEffect(model, world, view, projection);
					break;
				case EffectTechnique.NormalMap:
					DrawModelWithNormalMapEffect(model, world, view, projection);
					break;
				case EffectTechnique.Toon:
					DrawModelWithToonEffect(model, world, view, projection);
					break;
				default:
					throw new Exception("technique not found");
			}


		}

		private void DrawModel(Model model, Matrix world, Matrix view, Matrix projection)
		{
			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{
					part.Effect = effect;
					effect.EnableDefaultLighting();
					effect.PreferPerPixelLighting = true;
					//effect.TextureEnabled = true;
					//effect.Texture = texture;
					effect.World = world * mesh.ParentBone.Transform;
					effect.View = view;
					effect.Projection = projection;
				}

				mesh.Draw();
			}
		}

		private void DrawModelWithAmbientEffect(Model model, Matrix world, Matrix view, Matrix projection)
		{

			device.DepthStencilState = DepthStencilState.Default;

			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{
					part.Effect = ambientEffect;
					ambientEffect.Parameters["World"].SetValue(world * mesh.ParentBone.Transform);
					ambientEffect.Parameters["View"].SetValue(view);
					ambientEffect.Parameters["Projection"].SetValue(projection);
					ambientEffect.Parameters["AmbientColor"].SetValue(Color.Green.ToVector4());
					ambientEffect.Parameters["AmbientIntensity"].SetValue(0.5f);
				}
				mesh.Draw();
			}
		}


		private void DrawModelWithDiffuseEffect(Model model, Matrix world, Matrix view, Matrix projection)
		{

			device.DepthStencilState = DepthStencilState.Default;

			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{
					part.Effect = diffuseEffect;
					diffuseEffect.Parameters["World"].SetValue(world * mesh.ParentBone.Transform);
					diffuseEffect.Parameters["View"].SetValue(view);
					diffuseEffect.Parameters["Projection"].SetValue(projection);
					Matrix worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(mesh.ParentBone.Transform * world));
					diffuseEffect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
				}
				mesh.Draw();
			}
		}


		private void DrawModelWithSpecularEffect(Model model, Matrix world, Matrix view, Matrix projection)
		{


			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{

					part.Effect = specularEffect;
					specularEffect.Parameters["World"].SetValue(world * mesh.ParentBone.Transform);
					specularEffect.Parameters["View"].SetValue(view);
					specularEffect.Parameters["Projection"].SetValue(projection);
					specularEffect.Parameters["ViewVector"].SetValue(viewVector);

					Matrix worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(mesh.ParentBone.Transform * world));
					specularEffect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
				}
				mesh.Draw();
			}
		}



		private void DrawModelWithSpecularTwoEffect(Model model, Matrix world, Matrix view, Matrix projection)
		{


			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{

					part.Effect = specularTwoEffect;
					specularTwoEffect.Parameters["World"].SetValue(world * mesh.ParentBone.Transform);
					specularTwoEffect.Parameters["View"].SetValue(view);
					specularTwoEffect.Parameters["Projection"].SetValue(projection);
					specularTwoEffect.Parameters["CamPosition"].SetValue(camPosition);

					Matrix worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(mesh.ParentBone.Transform * world));
					specularTwoEffect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
				}
				mesh.Draw();
			}
		}



		private void DrawModelWithTextureEffect(Model model, Matrix world, Matrix view, Matrix projection)
		{
			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{

					part.Effect = textureEffect;
					textureEffect.Parameters["World"].SetValue(world * mesh.ParentBone.Transform);
					textureEffect.Parameters["View"].SetValue(view);
					textureEffect.Parameters["Projection"].SetValue(projection);
					textureEffect.Parameters["ViewVector"].SetValue(viewVector);
					textureEffect.Parameters["ModelTexture"].SetValue(texture);

					Matrix worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(mesh.ParentBone.Transform * world));
					textureEffect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
				}
				mesh.Draw();
			}
		}

		private void DrawModelWithNormalMapEffect(Model model, Matrix world, Matrix view, Matrix projection)
		{
			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{

					part.Effect = normalMapEffect;
					normalMapEffect.Parameters["World"].SetValue(world * mesh.ParentBone.Transform);
					normalMapEffect.Parameters["View"].SetValue(view);
					normalMapEffect.Parameters["Projection"].SetValue(projection);
					normalMapEffect.Parameters["ViewVector"].SetValue(viewVector);
					normalMapEffect.Parameters["ModelTexture"].SetValue(texture);
					normalMapEffect.Parameters["NormalMap"].SetValue(normalMap); //remember that if this brings it might be because the tangents frames are not generated.  You can fix this by checking "GenerateTangentFrames" on the MG pipeline
					//although it may take a few rebuilds to work
					Matrix worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(mesh.ParentBone.Transform * world));
					normalMapEffect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
				}
				mesh.Draw();
			}
		}



		private void DrawModelWithToonEffect(Model model, Matrix world, Matrix view, Matrix projection)
		{
			foreach (ModelMesh mesh in model.Meshes)
			{
				foreach (ModelMeshPart part in mesh.MeshParts)
				{

					part.Effect = textureEffect;
					textureEffect.Parameters["World"].SetValue(world * mesh.ParentBone.Transform);
					textureEffect.Parameters["View"].SetValue(view);
					textureEffect.Parameters["Projection"].SetValue(projection);
					textureEffect.Parameters["ViewVector"].SetValue(viewVector);
					textureEffect.Parameters["ModelTexture"].SetValue(texture);

					Matrix worldInverseTransposeMatrix = Matrix.Transpose(Matrix.Invert(mesh.ParentBone.Transform * world));
					textureEffect.Parameters["WorldInverseTranspose"].SetValue(worldInverseTransposeMatrix);
				}
				mesh.Draw();
			}
		}
	}
}