package pointer.media;

import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.ARBVertexBufferObject;
import org.lwjgl.util.vector.Vector2f;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;

import static org.lwjgl.BufferUtils.createByteBuffer;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL12.GL_CLAMP_TO_EDGE;
import static org.lwjgl.opengl.GL15.glGenBuffers;

public class Sprite
{
  public static final int
    NORMAL = 0,
    FLIP_VERTICAL = 1,
    FLIP_HORIZONTAL = 2;

  private int texID = 0;
  private FloatBuffer quadVertices = null;
  private FloatBuffer quadTexVertices = null;
  private int vboQuadHandle = 0;
  private int vboQuadTexHandle = 0;
  private Vector2f size;
  private Vector2f position = new Vector2f( 0, 0 );
  private float angle = 0;

  public Sprite( InputStream is )
  {
    try
    {
      BufferedImage bufImg = ImageIO.read( is );
      size = new Vector2f( bufImg.getWidth(), bufImg.getHeight() );
      int[] pixels = new int[ bufImg.getWidth() * bufImg.getHeight() ];
      bufImg.getRGB( 0, 0, bufImg.getWidth(), bufImg.getHeight(), pixels, 0, bufImg.getWidth() );
      ByteBuffer buffer = createByteBuffer( bufImg.getWidth() * bufImg.getHeight() * 4 );

      for (int y = 0; y < bufImg.getHeight(); ++y)
      {
        for (int x = 0; x < bufImg.getWidth(); ++x)
        {
          int pixel = pixels[ y * bufImg.getWidth() + x ];
          buffer.put( (byte)((pixel >> 16) & 0xFF) );
          buffer.put( (byte)((pixel >> 8) & 0xFF) );
          buffer.put( (byte)(pixel & 0xFF) );
          buffer.put( (byte)((pixel >> 24) & 0xFF) );
        }
      }

      buffer.flip();

      texID = glGenTextures();
      glBindTexture( GL_TEXTURE_2D, texID );
      glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
      glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, bufImg.getWidth(), bufImg.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer );

      float[] vert = {
        -bufImg.getWidth() / 2.0f, -bufImg.getHeight() / 2.0f,
        bufImg.getWidth() / 2.0f, -bufImg.getHeight() / 2.0f,
        bufImg.getWidth() / 2.0f, bufImg.getHeight() / 2.0f,
        -bufImg.getWidth() / 2.0f, bufImg.getHeight() / 2.0f
      };

      float[] texVertices = {
        0.0f, 0.0f,
        1.0f, 0.0f,
        1.0f, 1.0f,
        0.0f, 1.0f
      };

      vboQuadHandle = glGenBuffers();
      vboQuadTexHandle = glGenBuffers();

      quadVertices = BufferUtils.createFloatBuffer( 4 * 2 );
      quadVertices.put( vert );
      quadVertices.flip();

      quadTexVertices = BufferUtils.createFloatBuffer( 4 * 2 );
      quadTexVertices.put( texVertices );
      quadTexVertices.flip();

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadHandle );
      ARBVertexBufferObject.glBufferDataARB(
        ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
        quadVertices,
        ARBVertexBufferObject.GL_STREAM_DRAW_ARB
      );

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadTexHandle );
      ARBVertexBufferObject.glBufferDataARB(
        ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
        quadTexVertices,
        ARBVertexBufferObject.GL_STREAM_DRAW_ARB
      );

      ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0 );
    }
    catch (Exception e)
    {
      System.err.println( "Sprite: " + e.getLocalizedMessage() );
    }
  }

  public int getID()
  {
    return texID;
  }

  public void setPosition( Vector2f pos )
  {
    position = pos;
  }

  /**
   * Set pivot to sprite in pixels
   * @param p: new pivot
   */
  public void setPivot( Vector2f p )
  {
    float tlX = p.getX() == 0 ? 0 : p.getX() - size.getX();
    float tlY = p.getY() == 0 ? 0 : p.getY() - size.getY();
    float trX = p.getX() == 0 ? size.getX() : size.getX() - p.getX();
    float trY = p.getY() == 0 ? 0 : p.getY() - size.getY();
    float brX = p.getX() == 0 ? size.getX() : size.getX() - p.getX();
    float brY = p.getY() == 0 ? size.getY() : size.getY() - p.getY();
    float blX = p.getX() == 0 ? 0 : p.getX() - size.getX();
    float blY = p.getY() == 0 ? size.getY() : size.getY() - p.getY();

    float[] vert = {
      tlX, tlY,
      trX, trY,
      brX, brY,
      blX, blY
    };

    quadVertices.clear();
    quadVertices.put( vert );
    quadVertices.flip();
  }

  public void setAngle( float a )
  {
    angle = a;
  }

  public void setDrawMode( int dm )
  {
    // Normal render
    float[] texVertices = new float[] {
      0.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      0.0f, 1.0f
    };

    // Flip vertical
    if (dm == FLIP_VERTICAL)
    {
      texVertices = new float[] {
        0.0f, 1.0f,
        1.0f, 1.0f,
        1.0f, 0.0f,
        0.0f, 0.0f
      };
    }
    // Flip horizontal
    else if (dm == FLIP_HORIZONTAL)
    {
      texVertices = new float[] {
        1.0f, 0.0f,
        0.0f, 0.0f,
        0.0f, 1.0f,
        1.0f, 1.0f
      };
    }

    quadTexVertices.clear();
    quadTexVertices.put( texVertices );
    quadTexVertices.flip();
  }

  public void draw()
  {
    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadVertices );
    glVertexPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vboQuadTexHandle );
    ARBVertexBufferObject.glBufferSubDataARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0L, quadTexVertices );
    glTexCoordPointer( 2, GL_FLOAT, 0, 0L );

    ARBVertexBufferObject.glBindBufferARB( ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, 0 );

    glLoadIdentity();

    glTranslatef( position.getX(), position.getY(), 0.0f );
    glRotatef( angle, 0.0f, 0.0f, 1.0f );

    glEnable( GL_TEXTURE_2D );
    glBindTexture( GL_TEXTURE_2D, texID );

    glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );

    glEnableClientState( GL_VERTEX_ARRAY );
    glEnableClientState( GL_TEXTURE_COORD_ARRAY );

    glDrawArrays( GL_QUADS, 0, 4 );

    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
    glDisableClientState( GL_VERTEX_ARRAY );

    glBindTexture( GL_TEXTURE_2D, 0 );
    glDisable( GL_TEXTURE_2D );
  }

  public void destroy()
  {
    glDeleteTextures( texID );
    ARBVertexBufferObject.glDeleteBuffersARB( vboQuadHandle );
    ARBVertexBufferObject.glDeleteBuffersARB( vboQuadTexHandle );
  }
}