package net.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;

import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;
import org.lwjgl.util.glu.GLU;

public class Container {

	private int vaoId = 0;
	private int vboId = 0;
	private int vboiId = 0;

	private int indicesCount = 0;

	private int vsId = 0;
	private int fsId = 0;
	private int pId = 0;

	private FloatBuffer verticesBuffer;
	private ByteBuffer indicesBuffer;

	private Vertex[] vertices;
	private byte[] indices;

	public Container(Vertex[] vertices, byte[] indices) {
		setupShaders();
		setupResources();

		this.vertices = vertices;
		this.indices = indices;
		updateResources();
	}

	public void setVertices(Vertex[] vertices) {
		this.vertices = vertices;
	}

	public void setIndices(byte[] indices) {
		this.indices = indices;
	}

	public void render() {
		GL20.glUseProgram(pId);

		GL30.glBindVertexArray(vaoId);
		GL20.glEnableVertexAttribArray(0);
		GL20.glEnableVertexAttribArray(1);

		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vboiId);

		GL11.glDrawElements(GL11.GL_TRIANGLES, indicesCount,
				GL11.GL_UNSIGNED_BYTE, 0);

		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);

		GL20.glDisableVertexAttribArray(0);
		GL20.glDisableVertexAttribArray(1);

		GL30.glBindVertexArray(0);

		GL20.glUseProgram(0);
	}

	private void setupResources() {
		verticesBuffer = BufferUtils.createFloatBuffer(1);
		verticesBuffer.flip();

		indicesBuffer = BufferUtils.createByteBuffer(1);
		indicesBuffer.flip();

		vaoId = GL30.glGenVertexArrays();
		GL30.glBindVertexArray(vaoId);

		vboId = GL15.glGenBuffers();
		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboId);
		GL15.glBufferData(GL15.GL_ARRAY_BUFFER, verticesBuffer,
				GL15.GL_STATIC_DRAW);

		GL20.glVertexAttribPointer(0, 4, GL11.GL_FLOAT, false,
				Vertex.SIZE_IN_BYTES, 0);

		GL20.glVertexAttribPointer(1, 4, GL11.GL_FLOAT, false,
				Vertex.SIZE_IN_BYTES, Vertex.ELEMENT_BYTES * 4);
		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);

		GL30.glBindVertexArray(0);

		vboiId = GL15.glGenBuffers();
		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vboiId);
		GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBuffer,
				GL15.GL_STATIC_DRAW);
		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
	}

	public void updateResources() {
		verticesBuffer = BufferUtils.createFloatBuffer(vertices.length
				* Vertex.ELEMENT_COUNT);
		for (int i = 0; i < vertices.length; i++) {
			verticesBuffer.put(vertices[i].getXYZW());
			verticesBuffer.put(vertices[i].getRGBA());
		}
		verticesBuffer.flip();

		indicesCount = indices.length;
		indicesBuffer = BufferUtils.createByteBuffer(indicesCount);
		indicesBuffer.put(indices);
		indicesBuffer.flip();

		GL30.glBindVertexArray(vaoId);

		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboId);
		GL15.glBufferData(GL15.GL_ARRAY_BUFFER, verticesBuffer,
				GL15.GL_STATIC_DRAW);
		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);

		GL30.glBindVertexArray(0);

		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vboiId);
		GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBuffer,
				GL15.GL_STATIC_DRAW);
		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
	}

	private void setupShaders() {
		int errorCheckValue = GL11.glGetError();

		vsId = loadShader("/shaders/vertex.glsl", GL20.GL_VERTEX_SHADER);
		fsId = loadShader("/shaders/fragment.glsl", GL20.GL_FRAGMENT_SHADER);

		pId = GL20.glCreateProgram();
		GL20.glAttachShader(pId, vsId);
		GL20.glAttachShader(pId, fsId);
		GL20.glLinkProgram(pId);

		GL20.glBindAttribLocation(pId, 0, "in_Position");
		GL20.glBindAttribLocation(pId, 1, "in_Color");

		GL20.glValidateProgram(pId);

		errorCheckValue = GL11.glGetError();
		if (errorCheckValue != GL11.GL_NO_ERROR) {
			System.out.println("ERROR - Could not create the shaders:"
					+ GLU.gluErrorString(errorCheckValue));
			System.exit(-1);
		}
	}

	public void destroyResources() {
		GL20.glUseProgram(0);
		GL20.glDetachShader(pId, vsId);
		GL20.glDetachShader(pId, fsId);

		GL20.glDeleteShader(vsId);
		GL20.glDeleteShader(fsId);
		GL20.glDeleteProgram(pId);

		GL30.glBindVertexArray(vaoId);

		GL20.glDisableVertexAttribArray(0);
		GL20.glDisableVertexAttribArray(1);

		GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
		GL15.glDeleteBuffers(vboId);

		GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
		GL15.glDeleteBuffers(vboiId);

		GL30.glBindVertexArray(0);
		GL30.glDeleteVertexArrays(vaoId);
	}

	private static final int loadShader(String filename, int type) {
		StringBuilder shaderSource = new StringBuilder();
		int shaderID = 0;

		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					Main.class.getResourceAsStream(filename)));
			String line;
			while ((line = reader.readLine()) != null) {
				shaderSource.append(line).append("\n");
			}
			reader.close();
		} catch (IOException e) {
			System.err.println("Could not read file.");
			e.printStackTrace();
			System.exit(-1);
		}

		shaderID = GL20.glCreateShader(type);
		GL20.glShaderSource(shaderID, shaderSource);
		GL20.glCompileShader(shaderID);

		if (GL20.glGetShader(shaderID, GL20.GL_COMPILE_STATUS) == GL11.GL_FALSE) {
			System.err.println("Could not compile shader.");
			System.exit(-1);
		}

		return shaderID;
	}
}