package dam.test;

import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Random;

import javax.imageio.ImageIO;

import net.mokyu.threading.GameExecutor;
import net.mokyu.threading.MultithreadedExecutor;
import net.mokyu.threading.SplitTask;
import net.mokyu.threading.TaskTree;
import net.mokyu.threading.TaskTreeBuilder;

import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.util.Timer;

import dam.gl.shader.Shader;
import dam.gl.shader.ShaderProgram;
import dam.gl.tex.Sampler;
import dam.gl.tex.Texture2D;
import dam.gl.tex.TextureUtils;
import dam.test.ParticleTest10.Particle;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL12.*;
import static org.lwjgl.opengl.GL15.*;
import static org.lwjgl.opengl.GL20.*;
import static org.lwjgl.opengl.GL31.*;
import static org.lwjgl.opengl.GL33.*;

public class OGL3ParticleTest {
   
   private static final int WIDTH = 1600, HEIGHT = 900;
   
   private static final int MAX_PARTICLES = 50;
   
   private static final int THREADS = 8;

   private static final int PARTICLE_SIZE = 24;
   private static final int POSITION_OFFSET = 0;
   private static final int ROTATION_OFFSET = 8;
   private static final int SIZE_OFFSET = 12;
   private static final int COLOR_OFFSET = 20;
   
   private ShaderProgram geometryShader;

   private int positionLocation;
   private int rotationLocation;
   private int sizeLocation;
   private int colorLocation;
   
   
   

   private Texture2D texture;
   private Sampler sampler;

   
   private ByteBuffer data;
   private int dataVBO;
   private ByteBuffer mappedVBO;
   
   private GameExecutor executor;
   private TaskTree taskTree;

   
   private ArrayList<Particle> particles;
   private Random r;
   
   public OGL3ParticleTest(){
      initLWJGL();
      initShaders();
      initBuffers();
      initParticles();
      initTexture();
      initThreading();
   }

   private void initLWJGL() {
        //System.setProperty("org.lwjgl.librarypath", new File("").getAbsolutePath() + "\\natives");
      try{
         Display.setDisplayMode(new DisplayMode(WIDTH, HEIGHT));
         //Display.setDisplayModeAndFullscreen(Display.getDesktopDisplayMode());
         Display.create();
      }catch(LWJGLException ex){
         ex.printStackTrace();
      }
   }

   private void initShaders() {
      geometryShader = new ShaderProgram();
      geometryShader.attachShader(new Shader(Shader.VERTEX_SHADER, new File("shaders/particles/geometry shader.vert")));
      geometryShader.attachShader(new Shader(Shader.GEOMETRY_SHADER, new File("shaders/particles/geometry shader.geom")));
      geometryShader.attachShader(new Shader(Shader.FRAGMENT_SHADER, new File("shaders/particles/geometry shader.frag")));
      geometryShader.link();

      positionLocation = geometryShader.getAttribLocation("position");
      rotationLocation = geometryShader.getAttribLocation("rotation");
      sizeLocation = geometryShader.getAttribLocation("size");
      colorLocation = geometryShader.getAttribLocation("color");
      
      geometryShader.bind();
      glUniform2f(geometryShader.getUniformLocation("screenSize"), Display.getWidth(), Display.getHeight());
   }

   private void initBuffers() {
      data = BufferUtils.createByteBuffer(PARTICLE_SIZE * MAX_PARTICLES);
      
      dataVBO = glGenBuffers();
      glBindBuffer(GL_ARRAY_BUFFER, dataVBO);
      glBufferData(GL_ARRAY_BUFFER, PARTICLE_SIZE * MAX_PARTICLES, GL_STREAM_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
   }

   private void initParticles() {
      particles = new ArrayList<>();
      r = new Random();
   }
   
   private void initTexture(){
      texture = new Texture2D(GL_TEXTURE_2D, GL_RGBA8, GL_UNSIGNED_BYTE, GL_RGBA);
      texture.bind();
      try{
         texture.load(0, 16, 16, TextureUtils.loadImage(ImageIO.read(new File("files/particle/particle.png")), TextureUtils.PIXEL_HANDLER_RGBA_PREMULTIPLIED));
      }catch(IOException ex){
         ex.printStackTrace();
      }
      texture.generateMipmaps();
      
      sampler = new Sampler();
      sampler.setWrapModes(GL_CLAMP_TO_EDGE);
      sampler.setMinMagFilter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
      sampler.setAnisotropy(16f);
   }

   private void initThreading() {
      executor = new MultithreadedExecutor(THREADS);
      TaskTreeBuilder builder = new TaskTreeBuilder();
      builder.addTask(new MyTask(THREADS));
      taskTree = builder.build();
   }

   private void gameloop() {
      while(!Display.isCloseRequested()){
         
         handleInput();
         
         updateParticles();
         
         glClear(GL_COLOR_BUFFER_BIT);
         
         glEnable(GL_BLEND);
         glBlendFunc(GL_ONE, GL_ONE);
         
         texture.bind();
         sampler.bind(0);
         
         renderGeometry();
         
         Display.update();
      }
   }
   
   private void handleInput(){
      if(Keyboard.isKeyDown(Keyboard.KEY_G)){
         for(int i = 0; i < 1000 && particles.size() != MAX_PARTICLES; i++){
            particles.add(new Particle());
         }
         Display.setTitle("Particles: " + particles.size());
      }
   }

   private boolean pull;
   private int x, y;
   private void updateParticles() {
      
      
      pull = Mouse.isButtonDown(0);
      x = Mouse.getX();
      y = HEIGHT - 1 - Mouse.getY();
      
      executor.run(taskTree);
      
      data.limit(particles.size() * PARTICLE_SIZE);
      
      glBindBuffer(GL_ARRAY_BUFFER, dataVBO);
      mappedVBO = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY, particles.size() * PARTICLE_SIZE, mappedVBO);
      
      mappedVBO.put(data);
      
      glUnmapBuffer(GL_ARRAY_BUFFER);
      
      data.clear();
      mappedVBO.clear();
   }
   
   private void renderGeometry() {
      
      geometryShader.bind();
      
      glBindBuffer(GL_ARRAY_BUFFER, dataVBO);

      glVertexAttribPointer(positionLocation, 2, GL_FLOAT, false, PARTICLE_SIZE, POSITION_OFFSET);
      glVertexAttribPointer(rotationLocation, 1, GL_FLOAT, false, PARTICLE_SIZE, ROTATION_OFFSET);
      glVertexAttribPointer(sizeLocation, 2, GL_FLOAT, false, PARTICLE_SIZE, SIZE_OFFSET);
      glVertexAttribPointer(colorLocation, 4, GL_UNSIGNED_BYTE, true, PARTICLE_SIZE, COLOR_OFFSET);

      glEnableVertexAttribArray(positionLocation);
      glEnableVertexAttribArray(rotationLocation);
      glEnableVertexAttribArray(sizeLocation);
      glEnableVertexAttribArray(colorLocation);
      
      
      glDrawArrays(GL_POINTS, 0, particles.size());

      
      glDisableVertexAttribArray(positionLocation);
      glDisableVertexAttribArray(rotationLocation);
      glDisableVertexAttribArray(sizeLocation);
      glDisableVertexAttribArray(colorLocation);
   }
   
   private class Particle{
      
      private float x, y;
      private float vx, vy;

      private float width, height;
      private float rotation;
      private int color;
      
      public Particle(){
         x = r.nextFloat() * WIDTH;
         y = r.nextFloat() * HEIGHT;
         
         rotation = r.nextFloat() * 360;
         
         width = 10;
         height = 10;
         
         color = 0x0640FF40;
      }
      
      public void pull(int mouseX, int mouseY){
         
         float dx = mouseX - x, dy = mouseY - y;
         float distSqrd = dx*dx + dy*dy;
         
         //float force = 0.01f / (float)Math.sqrt(distSqrd);
         float force = 2f / distSqrd;
         vx += dx * force;
         vy += dy * force;
      }

      public void update() {

         vx *= 0.999;
         vy *= 0.999;
         
         x += vx;
         y += vy;
         
         if((x < 0 && vx < 0) || (x > WIDTH && vx > 0)){
            vx = -vx;
         }
         
         if((y < 0 && vy < 0) || (y > HEIGHT && vy > 0)){
            vy = -vy;
         }
      }

      public void put(ByteBuffer data) {
         data.
         putFloat(x).putFloat(y).
         putFloat(rotation).
         putFloat(width).putFloat(height).
         putInt(color);
      }
   }
   
   private class MyTask extends SplitTask{
      
      private int totalSubtasks;

      public MyTask(int subtasks) {
         super(0, 0, subtasks);
         totalSubtasks = subtasks;
      }

      @Override
      protected void runSubtask(int subtask) {
         int start = subtask * particles.size() / totalSubtasks;
         int end = (subtask + 1) * particles.size() / totalSubtasks;

           ByteBuffer view = data.slice();
           view.order(ByteOrder.nativeOrder());
         view.position(start * PARTICLE_SIZE);
         view.limit(end * PARTICLE_SIZE);
         
         
         for(int i = start; i < end; i++){
            
            Particle p = particles.get(i);
            
            if(pull){
               p.pull(x, y);
            }
            
            p.update();
            p.put(view);
         }
         
         
      }

      @Override
      public void finish() {
      }
      
   }

   public static void main(String[] args){
      new OGL3ParticleTest().gameloop();
   }
}