package renderEngine;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.atriaSoft.etk.math.Matrix4f;
import org.atriaSoft.etk.math.Vector2f;
import org.atriaSoft.etk.math.Vector3f;

import org.lwjgl.opengl.GL11;

import entities.Camera;
import entities.Entity;
import entities.Light;
import models.TexturedModel;
import shaders.StaticShader;
import shaders.TerrainShader;
import terrains.Terrain;

public class MasterRenderer {
	private static final float FOV = 70;
	private static final float NEAR_PLANE = 0.1f;
	private static final float FAR_PLANE = 10000;
	private static final Vector3f SKY_COLOUR = new Vector3f(0.5f, 0.5f, 0.5f);
	
	private Matrix4f projectionMatrix;
	
	private StaticShader shader = new StaticShader();
	private EntityRenderer renderer;
	
	private TerrainRenderer terrainRenderer;
	private TerrainShader terrainShader = new TerrainShader();
	
	private Map<TexturedModel, List<Entity>> entities = new HashMap<TexturedModel, List<Entity>>();
	private List<Terrain> terrains = new ArrayList<Terrain>();
	
	public MasterRenderer() {
		enableCulling();
		GL11.glEnable(GL11.GL_BLEND);
		GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
		createProjectionMatrix();
		renderer = new EntityRenderer(shader, projectionMatrix);
		terrainRenderer = new TerrainRenderer(terrainShader, projectionMatrix);
	}

	public static void enableCulling() {
		GL11.glEnable(GL11.GL_CULL_FACE);
		GL11.glEnable(GL11.GL_BACK);
	}
	public static void disableCulling() {
		GL11.glDisable(GL11.GL_CULL_FACE);
		GL11.glDisable(GL11.GL_BACK);
	}
	
	public void render(Light sun, Camera camera) {
		prepare();
		shader.start();
		shader.loadSkyColour(SKY_COLOUR);
		shader.loadLight(sun);
		shader.loadViewMatrix(camera);
		renderer.render(entities);
		shader.stop();
		entities.clear();
		terrainShader.start();
		terrainShader.loadSkyColour(SKY_COLOUR);
		terrainShader.loadLight(sun);
		terrainShader.loadViewMatrix(camera);
		terrainRenderer.render(terrains); 
		terrainShader.stop();
		terrains.clear();
	}
	
	public  void processTerrain(Terrain terrain) {
		terrains.add(terrain);
	}
	
	public void processEntity(Entity entity) {
		TexturedModel entityModel = entity.getModel();
		List<Entity> batch = entities.get(entityModel);
		if (batch != null) {
			batch.add(entity);
		} else {
			List<Entity> newBatch = new ArrayList<Entity>();
			newBatch.add(entity);
			entities.put(entityModel, newBatch);
		}
	}

	public void prepare() {
		GL11.glEnable(GL11.GL_DEPTH_TEST);
		GL11.glClear(GL11.GL_COLOR_BUFFER_BIT|GL11.GL_DEPTH_BUFFER_BIT);
		GL11.glClearColor(SKY_COLOUR.x, SKY_COLOUR.y, SKY_COLOUR.z, 1.0f);
	}
	
	
	public void cleanUp () {
		shader.cleanUp();
		terrainShader.cleanUp();
	}
	
	private void createProjectionMatrix() {
		//float aspectRatio = (float) Display.getWidth() / (float) Display.getHeight();
		Vector2f windowsSize = DisplayManager.getSize();
		float aspectRatio = windowsSize.x / windowsSize.y;
//		float y_scale = (float) ((1f/Math.atan(Math.toRadians(FOV/2f))) * aspectRatio);
//		float x_scale = y_scale / aspectRatio;
//		float frustrum_length = FAR_PLANE - NEAR_PLANE;
//		
//		projectionMatrix = new Matrix4f();
//		projectionMatrix.m00 = x_scale;
//		projectionMatrix.m11 = y_scale;
//		projectionMatrix.m22 = -((FAR_PLANE + NEAR_PLANE) / frustrum_length);
//		projectionMatrix.m23 = -1;;
//		projectionMatrix.m32 = -((2*FAR_PLANE * NEAR_PLANE) / frustrum_length);
//		projectionMatrix.m33 = 0;
		projectionMatrix = Matrix4f.createMatrixPerspective(FOV, aspectRatio, NEAR_PLANE, FAR_PLANE);
	}
	

	
	
}