package com.voxel.engine.core.Chunk;

import com.voxel.engine.core.Block.Block;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL15;

import java.nio.FloatBuffer;
import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 * User: Toby's PC
 * Date: 07/01/14
 * Time: 19:25
 */
public class Chunk {

    public static final int CHUNK_SIZE = 16;
    public static final int CHUNK_DEPTH = 2;
    public Block[][][] blocks;

    public static final int CUBE_LENGTH = 2;

    private int StartX, StartY, StartZ;

    private Random random;

    int xx, yy, zz;

    private int VBOColorHandle;
    private int VBOVertexHandle;

    public void render(){
        GL11.glPushMatrix();
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, VBOVertexHandle);
        GL11.glVertexPointer(3, GL11.GL_FLOAT, 0, 0L);
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, VBOColorHandle);
        GL11.glColorPointer(3, GL11.GL_FLOAT, 0, 0L);
        GL11.glDrawArrays(GL11.GL_QUADS, 0, CHUNK_SIZE * CHUNK_SIZE  * CHUNK_SIZE * 24);

        GL11.glPopMatrix();
    }

    public void update(){

    }

    public static void EnableLighting(boolean enabled){
        GL11.glEnableClientState(GL11.GL_NORMAL_ARRAY);
        GL11.glEnable(GL11.GL_COLOR_MATERIAL);
        GL11.glEnable(GL11.GL_LIGHTING);
        GL11.glEnable(GL11.GL_LIGHT0);

    }

    public Chunk(int startX, int startY, int startZ){
        random = new Random();

        int l = 10;
        int h = 30;

        for(int i = 0;i < 10;i++){
            xx = random.nextInt(h-l)+l;
        }
//       xx = random.nextInt(h-l)+l;
        zz = random.nextInt(h-l)+l;

        blocks = new Block[CHUNK_SIZE][CHUNK_SIZE][CHUNK_SIZE];
        for (int x = 0; x < CHUNK_SIZE; x++) {
            for (int y = 0; y < CHUNK_DEPTH; y++) {
                for (int z = 0; z < CHUNK_SIZE; z++) {
                    if(random.nextFloat()>0.7f){
                        blocks[x][y][z] = new Block(Block.BlockType.BLOCK_TYPE_GRASS);
                    }else if(random.nextFloat() > 0.4f){
                        blocks[x][y][z] = new Block(Block.BlockType.BLOCK_TYPE_DIRT);
                    }else if(random.nextFloat()>0.2f){
                        blocks[x][y][z] = new Block(Block.BlockType.BLOCK_TYPE_WATER);
                    }else{
                        blocks[x][y][z] = new Block(Block.BlockType.BLOCK_TYPE_DEFAULT);
                    }
                }
            }
        }
        VBOColorHandle = GL15.glGenBuffers();
        VBOVertexHandle = GL15.glGenBuffers();
//        StartX = startX;
 //       StartY = startY;
  //      StartZ = startZ;
        rebuildMesh(startX, startY, startZ);
    }

    public void rebuildMesh(float startX, float startY, float startZ){
        VBOColorHandle = GL15.glGenBuffers();
        VBOVertexHandle = GL15.glGenBuffers();

        FloatBuffer VertexPositionData = BufferUtils.createFloatBuffer((CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE) * 6 * 12);
        FloatBuffer VertexColorData = BufferUtils.createFloatBuffer((CHUNK_SIZE* CHUNK_SIZE * CHUNK_SIZE) * 6 * 12);
        //Note that for above CHUNK_SIZE^3 was not working for me.

        for (float x = 0; x < CHUNK_SIZE; x += 1) {
            for (float y = 0; y < CHUNK_DEPTH; y += 1) {
                for (float z = 0; z < CHUNK_SIZE; z += 1) {
                    VertexPositionData.put(CreateCube((float) startX + x * CUBE_LENGTH, (float) startY + y * CUBE_LENGTH,(float) startZ + z * CUBE_LENGTH));
                    VertexColorData.put(CreateCubeVertexCol(GetCubeColor(blocks[(int)x][(int) y][(int) z])));



                    VertexPositionData.put(CreateCube((float) startX, (float)xx,(float) zz));
                    VertexColorData.put(CreateCubeVertexCol(GetCubeColor(blocks[(int)x][(int) y][(int) z])));
                }
            }

        }

        VertexColorData.flip();
        VertexPositionData.flip();
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, VBOVertexHandle);
        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, VertexPositionData,GL15.GL_STATIC_DRAW);
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, VBOColorHandle);
        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, VertexColorData,GL15.GL_STATIC_DRAW);
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
    }

    public static float[] CreateCube(float x, float y, float z) {
        int offset = CUBE_LENGTH / 2;
        return new float[] {

                x + offset, y + offset,z,
                x - offset,y + offset,z,
                x - offset,y + offset,z - CUBE_LENGTH,
                x + offset,y + offset,z - CUBE_LENGTH,

                x + offset, y - offset, z - CUBE_LENGTH,
                x - offset,y - offset,z - CUBE_LENGTH,
                x - offset,y - offset,z,
                x + offset,y - offset,z,

                x + offset, y + offset, z - CUBE_LENGTH,
                x - offset,y + offset, z - CUBE_LENGTH,
                x - offset,y - offset,z - CUBE_LENGTH,
                x + offset,y - offset,z - CUBE_LENGTH,

                x + offset, y - offset, z,
                x - offset, y - offset, z,
                x - offset, y + offset, z,
                x + offset,y + offset, z,

                x - offset, y + offset, z - CUBE_LENGTH,
                x - offset,y + offset, z,
                x - offset, y - offset, z,
                x - offset,y - offset,z - CUBE_LENGTH,

                x + offset, y + offset, z,
                x + offset, y + offset,z - CUBE_LENGTH,
                x + offset, y - offset, z - CUBE_LENGTH,
                x + offset, y - offset, z };

    }

    private float[] GetCubeColor(Block block) {
        switch (block.getID()) {
            case 1:
                return new float[] { 0, 1, 0 };
            case 2:
                return new float[] { 1, 0.5f, 0 };
            case 3:
                return new float[] { 0, 0f, 1f };
        }
        return new float[] { 1, 1, 1 };
    }

    private float[] CreateCubeVertexCol(float[] CubeColorArray) {
        float[] cubeColors = new float[CubeColorArray.length * 4 * 6];
        for (int i = 0; i < cubeColors.length; i++) {
            cubeColors[i] = CubeColorArray[i % CubeColorArray.length];
        }
        return cubeColors;
    }
}