import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferInt;
import java.awt.image.DirectColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;

import javax.swing.SwingUtilities;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.opengl.GLCanvas;
import org.eclipse.swt.opengl.GLData;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GLContext;
import org.lwjgl.util.glu.GLU;

class ImageCanvas extends GLCanvas {
	public ImageCanvas(Composite parent, int style, GLData data) {
		super(parent, style, data);
		// TODO Auto-generated constructor stub
	}

	private final Point imagePosition = new Point(0, 0);
	private ImageData bufferedImage = null;
	private IntBuffer buffer = null;

	public void setBufferedImage(ImageData bi) {
		bufferedImage = bi;// ImageHelper.toBufferedImage(bufferedImage);//.getScaledInstance(50, 50, java.awt.Image.SCALE_DEFAULT));

		int w = bufferedImage.width;
		int h = bufferedImage.height;
		buffer = ByteBuffer.allocateDirect(w * h * 4).order(ByteOrder.nativeOrder()).asIntBuffer();
		updateImageBuffer();
	}

	private void updateImageBuffer() {
		// ImageData fullImageData = makeTransparent(bufferedImage, 0);
		BufferedImage bi = Snippet.convertToAWT(bufferedImage);
		BufferedImage result = new BufferedImage(bi.getWidth(), bi.getHeight(), BufferedImage.TYPE_INT_ARGB);
		Graphics2D g = result.createGraphics();
		g.scale(1, -1);
		g.drawImage(bi, 0, -bi.getHeight(), null);
		g.dispose();
		WritableRaster wr = result.getData().createCompatibleWritableRaster();
		for (int x = 0; x < result.getWidth(); x++) {
			for (int y = 0; y < result.getHeight(); y++) {
				int arx[] = new int[4];
				int zero[] = new int[4];
				zero = result.getData().getPixel(x, y, arx);
				arx[0] = zero[2];
				arx[1] = zero[1];
				arx[2] = zero[0];
				// arx[3]=255;
				wr.setPixel(x, y, arx);
			}
		}
		result = new BufferedImage(result.getColorModel(), wr, result.isAlphaPremultiplied(), null);
		Raster r = result.getData();
		DataBuffer db = r.getDataBuffer();
		DataBufferInt dataBufferInt = (DataBufferInt) db;
		buffer.put(dataBufferInt.getData());
		buffer.rewind();
	}

	public void setImagePosition(int x, int y) {
		imagePosition.x = x;
		imagePosition.y = y;
	}

	public void render() {
		setCurrent();
		try {
			GLContext.useContext(this);
		} catch (LWJGLException e) {
			e.printStackTrace();
		}


		GL11.glMatrixMode(GL11.GL_PROJECTION);
		GL11.glLoadIdentity();
		GL11.glOrtho(0, getBounds().width, 0, getBounds().width, -2, 2);
		GL11.glMatrixMode(GL11.GL_MODELVIEW);
		GL11.glLoadIdentity();

		GL11.glClearColor(255, 255, 255, 255);
		GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);

		int w = this.bufferedImage.width;
		int h = this.bufferedImage.height;
		int format = GL11.GL_RGBA;
		int type = GL11.GL_UNSIGNED_BYTE;
		GL11.glEnable(GL11.GL_BLEND);
		GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

		GL11.glRasterPos4i(imagePosition.x, imagePosition.y, 0, 1);
		GL11.glDrawPixels(w, h, format, type, buffer);
		swapBuffers();

		GC g = new GC(this);
		g.drawText("XXXXXXXXXXXXXX", 10, 10);
		g.dispose();

	}
}

public class Snippet {
	public static void main(String[] arguments) {
		SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {
				try {
					new Snippet();
				} catch (LWJGLException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		});

	}

	public Snippet() throws LWJGLException, IOException {
		final Display display = new Display();
		final Shell shell = new Shell(display);
		shell.setLayout(new FillLayout());
		shell.setText("OpenGl Test");

		GLData data = new GLData();
		data.doubleBuffer = true;

		final ImageCanvas canvas = new ImageCanvas(shell, SWT.NONE, data);
		final ImageData bufferedImage = loadImage("icons/sample.gif");
		final Canvas c1 = new Canvas(shell, SWT.NONE);
		c1.addListener(SWT.Paint, new Listener() {

			@Override
			public void handleEvent(Event event) {
				GC g = new GC(c1);

				GC gc = new GC(canvas);
				Image image = new Image(canvas.getDisplay(), canvas.getBounds().width, canvas.getBounds().height);
				gc.copyArea(image, 0, 0);
				gc.dispose();

				ImageData idata = image.getImageData();

				image.dispose();
				if (idata != null) {
					System.out.println("super" + idata.width);
//					g.drawImage(new Image(display, canvas.getGLData().shareContext.getBackgroundImage().getImageData()), 0, 0);
					g.drawImage(new Image(display, idata), 0, 0);
				}
				g.dispose();
			}
		});
		canvas.setBufferedImage(bufferedImage);
		canvas.addListener(SWT.Resize, new Listener() {
			@Override
			public void handleEvent(Event event) {
				org.eclipse.swt.graphics.Rectangle bounds = canvas.getBounds();
				float fAspect = (float) bounds.width / (float) bounds.height;
				canvas.setCurrent();
				try {
					GLContext.useContext(canvas);
				} catch (LWJGLException e) {
					e.printStackTrace();
				}
				GL11.glViewport(0, 0, bounds.width, bounds.height);
				GL11.glMatrixMode(GL11.GL_PROJECTION);
				GL11.glLoadIdentity();
				GLU.gluPerspective(45.0f, fAspect, 0.5f, 400.0f);
				GL11.glMatrixMode(GL11.GL_MODELVIEW);
				GL11.glLoadIdentity();
			}
		});
		display.asyncExec(new Runnable() {
			double a = 0;

			@Override
			public void run() {
				if (!canvas.isDisposed()) {
					int cx = canvas.getBounds().width / 2 - bufferedImage.width / 2;
					int cy = canvas.getBounds().height / 2 - bufferedImage.height / 2;
					int d = 50;
					double x = cx + d * Math.cos(a);
					double y = cy + d * Math.sin(a);
					canvas.setImagePosition((int) x, (int) y);
					a += 0.1;
					// System.out.println("Foo?=");
					canvas.render();
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						Thread.currentThread().interrupt();
					}
					display.asyncExec(this);
				}
			}
		});

		shell.pack();
		shell.layout();
		shell.open();
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		display.dispose();
	}

	public static ImageData loadImage(String fileName){
		final ImageData[] imageDatas = new ImageLoader().load(fileName);
		return imageDatas[0];
	}
	public static BufferedImage convertToAWT(ImageData data) {
	      ColorModel colorModel = null;
	      PaletteData palette = data.palette;
	      if (palette.isDirect) {
	         colorModel = new DirectColorModel(data.depth, palette.redMask, palette.greenMask, palette.blueMask);
	         BufferedImage bufferedImage = new BufferedImage(colorModel,
	               colorModel.createCompatibleWritableRaster(data.width, data.height), false, null);
	         WritableRaster raster = bufferedImage.getRaster();
	         int[] pixelArray = new int[3];
	         for (int y = 0; y < data.height; y++) {
	            for (int x = 0; x < data.width; x++) {
	               int pixel = data.getPixel(x, y);
	               RGB rgb = palette.getRGB(pixel);
	               pixelArray[0] = rgb.red;
	               pixelArray[1] = rgb.green;
	               pixelArray[2] = rgb.blue;
	               raster.setPixels(x, y, 1, 1, pixelArray);
	            }
	         }
	         return bufferedImage;
	      } else {
	         RGB[] rgbs = palette.getRGBs();
	         byte[] red = new byte[rgbs.length];
	         byte[] green = new byte[rgbs.length];
	         byte[] blue = new byte[rgbs.length];
	         for (int i = 0; i < rgbs.length; i++) {
	            RGB rgb = rgbs[i];
	            red[i] = (byte) rgb.red;
	            green[i] = (byte) rgb.green;
	            blue[i] = (byte) rgb.blue;
	         }
	         if (data.transparentPixel != -1) {
	            colorModel = new IndexColorModel(data.depth, rgbs.length, red, green, blue, data.transparentPixel);
	         } else {
	            colorModel = new IndexColorModel(data.depth, rgbs.length, red, green, blue);
	         }
	         BufferedImage bufferedImage = new BufferedImage(colorModel,
	               colorModel.createCompatibleWritableRaster(data.width, data.height), false, null);
	         WritableRaster raster = bufferedImage.getRaster();
	         int[] pixelArray = new int[1];
	         for (int y = 0; y < data.height; y++) {
	            for (int x = 0; x < data.width; x++) {
	               int pixel = data.getPixel(x, y);
	               pixelArray[0] = pixel;
	               raster.setPixel(x, y, pixelArray);
	            }
	         }
	         return bufferedImage;
	      }
	   }

}