package particles;

import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.List;

import org.lwjgl.BufferUtils;
import org.lwjgl.PointerBuffer;
import org.lwjgl.opencl.CL;
import org.lwjgl.opencl.CL10;
import org.lwjgl.opencl.CL10GL;
import org.lwjgl.opencl.CLCommandQueue;
import org.lwjgl.opencl.CLContext;
import org.lwjgl.opencl.CLDevice;
import org.lwjgl.opencl.CLKernel;
import org.lwjgl.opencl.CLMem;
import org.lwjgl.opencl.CLPlatform;
import org.lwjgl.opencl.CLProgram;
import org.lwjgl.opencl.Util;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.Drawable;

import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.Geometry;
import com.jme3.scene.Mesh;
import com.jme3.scene.Spatial.CullHint;
import com.jme3.scene.VertexBuffer;
import com.jme3.scene.VertexBuffer.Type;
import com.jme3.scene.control.AbstractControl;

public class JMEOpenCLTest extends SimpleApplication{
    private VertexBuffer verticesBuff;

    public static void main(String[] _a){
        new JMEOpenCLTest().start();
    }

    @Override
    public void simpleInitApp() {
        flyCam.setMoveSpeed(100f);

        Vector3f [] vertices = new Vector3f[3];
        vertices[0] = new Vector3f(0,0,0);
        vertices[1] = new Vector3f(3,0,0);
        vertices[2] = new Vector3f(0,3,0);

        int [] indexes = { 2,0,1};

        Mesh mesh=new Mesh();
        mesh.setBuffer(Type.Position,3,com.jme3.util.BufferUtils.createFloatBuffer(vertices));
        mesh.setBuffer(Type.Index,3,com.jme3.util.BufferUtils.createIntBuffer(indexes));
        mesh.updateBound();

        Geometry geom=new Geometry();
        geom.setMesh(mesh);
        geom.setCullHint(CullHint.Never);

        Material mat=new Material(assetManager,"Common/MatDefs/Misc/Unshaded.j3md");
        mat.setColor("Color",ColorRGBA.Green);
        geom.setMaterial(mat);
        geom.setCullHint(CullHint.Never);

        rootNode.attachChild(geom);
        geom.addControl(new CLCode());


        // Vertices Buffer
        verticesBuff=mesh.getBuffer(Type.Position);

    }



    private class CLCode extends AbstractControl{
        private CLKernel kernel;
        private CLCommandQueue queue;
        private PointerBuffer workers;
        private CLMem verticesBuffCL;

        @Override
        protected void controlUpdate(float tpf) {
            if(kernel==null) kernelSetup();
            else{
                CL10GL.clEnqueueAcquireGLObjects(queue,verticesBuffCL,null,null);
                        CL10.clEnqueueNDRangeKernel(queue,kernel,1,null,workers,null,null,null);
                CL10GL.clEnqueueReleaseGLObjects(queue,verticesBuffCL,null,null);
                CL10.clEnqueueReadBuffer(queue, clresult, CL10.CL_TRUE, 0, result, null, null);

                CL10.clFinish(queue);
                System.out.println();
                System.out.println();

                for(int i=0;i<result.capacity();i++){
                    System.out.println(result.get(i));
                }
            }
        }
        CLMem clresult;
        FloatBuffer result;
        private void kernelSetup(){
            try{
                if(verticesBuff.getId()==-1)return;

                System.out.println("VerticesBuffer ID: "+verticesBuff.getId());

                String source=
                        "kernel void test(global float *position,int size,global float* result) {"
                                +"unsigned int id = get_global_id(0);"
                                +"if(id<size){"
                                    +"int idv=3*id;"
                                    +"position[idv+1]+=0.0001f;"
                                    +"result[idv]=position[idv];"
                                    +"result[idv+1]=position[idv+1];"
                                    +"result[idv+2]=position[idv+2];"
                                +"}"
                        +"}";

                CL.create();
                Drawable drawable=Display.getDrawable();
                CLPlatform platform=CLPlatform.getPlatforms().get(0);
                List<CLDevice> devices=platform.getDevices(CL10.CL_DEVICE_TYPE_GPU);

                IntBuffer errorBuff=BufferUtils.createIntBuffer(1);

                CLContext context=CLContext.create(platform,devices,null,drawable,null);
                queue=CL10.clCreateCommandQueue(context,devices.get(0),CL10.CL_QUEUE_PROFILING_ENABLE,errorBuff);
                Util.checkCLError(errorBuff.get(0));

                result=BufferUtils.createFloatBuffer(3*3);
                clresult = CL10.clCreateBuffer(context, CL10.CL_MEM_WRITE_ONLY | CL10.CL_MEM_COPY_HOST_PTR, result, errorBuff);

                verticesBuffCL=CL10GL.clCreateFromGLBuffer(context,CL10.CL_MEM_READ_WRITE,
                        // Buffer ID
                        verticesBuff.getId()
                ,null);


                Util.checkCLError(errorBuff.get(0));

                for(CLDevice d:devices)System.out.println(d);

                CLProgram program=CL10.clCreateProgramWithSource(context,source,null);
                Util.checkCLError(CL10.clBuildProgram(program,devices.get(0),"",null));

                kernel=CL10.clCreateKernel(program,"test",null);
                kernel.setArg(0,verticesBuffCL);
                kernel.setArg(1,3);
                kernel.setArg(2,clresult);

                workers=BufferUtils.createPointerBuffer(1);
                workers.put(0,3);

            }catch(Exception e){
                e.printStackTrace();
            }
        }

        @Override
        protected void controlRender(RenderManager rm, ViewPort vp) {}
    }
}