package mior;
  
  /*
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.nio.ByteBuffer;
  import java.util.Arrays;
  import java.util.Random;
  import java.util.concurrent.ExecutionException;
  
  import javax.swing.JFrame;
  
  import mior.model.IMiorModel;
  
  import org.jocl.Pointer;
  import org.jocl.Sizeof;
  import org.jocl.struct.Buffers;
  import org.jocl.struct.SizeofStruct;
  
  import ocl.OCL;
  import ocl.OCLCommandQueue;
  import ocl.OCLContext;
  import ocl.OCLEvent;
  import ocl.OCLKernel;
  import ocl.OCLMem;
  import ocl.OCLProgram;
  
  public class MiorModel implements IMiorModel {
  	
  	private MiorMM  [] mmList;
  	private OCLMem     mmMem;
  	
  	private MiorOM  [] omList;
  	private OCLMem     omMem;
  	
  	private int     [] associations;
  	private OCLMem     associationsMem;
  	
  	private MiorWorld  world;
  	private OCLMem     worldMem;
  	
  	private OCLContext context;
  	private OCLProgram program;
  	private OCLCommandQueue queue;
  	
  	public MiorModel() {
  		initializeOpenCL();
  		
  		this.world = new MiorWorld();
  		
  		this.worldMem = context.createBuffer(1, MiorWorld.class, OCL.MEM_RW, world);
  		
  		this.worldSize = SizeofStruct.sizeof(MiorWorld.class);
  		
  		this.associations = new int[world.nbMM * world.nbOM];
  		this.associationsSize = associations.length * Sizeof.cl_int;
  		this.associationsMem = context.createBuffer(associations.length, OCL.INT, OCL.MEM_RW);
  		
  		initializeMM();
  		initializeOM();
  		
  		computeTopography();
  		computeLive();
  		
  		releaseOpenCL();
  	}
  	
  	public void computeTopography() {
  		OCLKernel topographyKernel = program.createKernel("topography");
  		
  		topographyKernel.setArguments(mmMem, omMem, associationsMem, worldMem);
  		
  		OCLEvent event = queue.enqueueKernel(
  				topographyKernel, 2,
  				new long[] { 0, 0 },
  				new long[] { mmList.length, omList.length },
  				new long[] { 1, 1 }
  		);
  		
  		try {
  			event.get();
  		} catch (InterruptedException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		} catch (ExecutionException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		}
  		
  		try {
  			Thread.sleep(1000);
  		} catch (InterruptedException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		}
  		queue.blockingReadBuffer(associationsMem, Pointer.to(associations), 0, associationsSize);
  		System.out.println(Arrays.toString(associations));
  		System.out.println(associations.length);
  	}
  	
  	public void computeLive() {
  		OCLKernel liveKernel = program.createKernel("topography");
  		
  		liveKernel.setArguments(mmMem, omMem, associationsMem, worldMem);
  		
  		OCLEvent event = queue.enqueue1DKernel(liveKernel, mmList.length, 1);
  		
  		try {
  			event.get();
  		} catch (InterruptedException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		} catch (ExecutionException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		}
  		
  		try {
  			Thread.sleep(1000);
  		} catch (InterruptedException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		}
  		
  		queue.blockingReadBuffer(associationsMem, Pointer.to(associations), 0, associationsSize);
  		System.out.println(Arrays.toString(associations));
  		System.out.println(associations.length);
  	}
  	
  	private void initializeMM() {
  		Random rand = new Random();
  		
  		this.mmList = new MiorMM[world.nbMM];
  		
  		for (int i = 0; i < world.nbMM; i++) {
  			mmList[i] = new MiorMM(
  					rand.nextInt(world.width),
  					rand.nextInt(world.width)
  			);
  		}
  		
  		this.mmBuffer = Buffers.allocateBuffer(mmList);
  		Buffers.writeToBuffer(mmBuffer, mmList);
  		
  		this.mmSize = mmList.length * SizeofStruct.sizeof(MiorMM.class);
  		this.mmMem = context.createBuffer(mmSize, OCL.MEM_RW, Pointer.to(mmBuffer));
  	}
  	private void initializeOM() {
  		Random rand = new Random();
  		
  		this.omList = new MiorOM[world.nbOM];
  		
  		for (int i = 0; i < world.nbOM; i++) {
  			omList[i] = new MiorOM(
  					rand.nextInt(world.width),
  					rand.nextInt(world.width)
  			);
  		}
  		
  		this.omBuffer = Buffers.allocateBuffer(omList);
  		Buffers.writeToBuffer(omBuffer, omList);
  		
  		this.omSize = omList.length * SizeofStruct.sizeof(MiorOM.class);
  		this.omMem = context.createBuffer(omSize, OCL.MEM_RW, Pointer.to(omBuffer));
  	}
  	
  	private void initializeOpenCL() {
  		this.context = new OCLContext();
  		this.queue = context.createCommandQueue();
  		
  		try {
  			this.program = context.createProgram(readFileAsString("/home/glaville/mior.cl"));
  		} catch (IOException e) {
  			e.printStackTrace();
  		}
  	}
  	
  	private void releaseOpenCL() {
  		associationsMem.release();
  		worldMem.release();
  		mmMem.release();
  		omMem.release();
  		queue.release();
  		context.release();
  	}
  	
  	@Override
  	public MiorOM[] getOMList() {
  		return omList;
  	}
  	
  	@Override
  	public MiorMM[] getMMList() {
  		return mmList;
  	}
  	
  	@Override
  	public MiorWorld getWorld() {
  		return world;
  	}
  	
  	@Override
  	public int[] getAssociations() {
  		return associations;
  	}
  	
  	private static String readFileAsString(String filePath) throws java.io.IOException{
  	    byte[] buffer = new byte[(int) new File(filePath).length()];
  	    FileInputStream f = new FileInputStream(filePath);
  	    f.read(buffer);
  	    return new String(buffer);
  	}
  
  }*/