#include "Common.hpp"

#ifdef USE_GLES1
#include <GLES/gl.h>
#else
#ifdef __APPLE__
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
#endif

#include "Renderable.hpp"
#include <math.h>


typedef float floatPair[2];
typedef float floatTriple[3];
typedef float floatQuad[4];


#ifdef USE_GLES1
static void
glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
  GLfloat verts[] = {
    x1, y1,
    x1, y2,
    x2, y1,
    x2, y2
  };
  GLboolean prev;

  prev = glIsEnabled (GL_VERTEX_ARRAY);

  glEnableClientState (GL_VERTEX_ARRAY);
  glVertexPointer (2, GL_FLOAT, 0, verts);
  glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);

  if (!prev)
    glDisableClientState (GL_VERTEX_ARRAY);
}
#endif

RenderContext::RenderContext()
  : time(0),
    texsize(512),
    aspectRatio(1),
    aspectCorrect(false)
{};

RenderItem::RenderItem() : masterAlpha(1) {}

DarkenCenter::DarkenCenter() : RenderItem() {}
MotionVectors::MotionVectors() : RenderItem() {}
Border::Border() : RenderItem() {}

void
DarkenCenter::Draw(RenderContext &context)
{
  //float unit=0.05f;

  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  float colors[6][4] = {{0, 0, 0, (3.0f/32.0f) * masterAlpha},
                        {0, 0, 0, 0},
                        {0, 0, 0, 0},
                        {0, 0, 0, 0},
                        {0, 0, 0, 0},
                        {0, 0, 0, 0}};

  float points[6][2] = {{ 0.5,  0.5},
                        { 0.45, 0.5},
                        { 0.5,  0.45},
                        { 0.55, 0.5},
                        { 0.5,  0.55},
                        { 0.45, 0.5}};

  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_COLOR_ARRAY);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);

  glVertexPointer(2,GL_FLOAT,0,points);
  glColorPointer(4,GL_FLOAT,0,colors);

  glDrawArrays(GL_TRIANGLE_FAN,0,6);
}

Shape::Shape():RenderItem()
{
  std::string imageUrl = "";

  sides = 4;
  thickOutline = false;
  enabled = true;
  additive = false;
  textured = false;

  tex_zoom = 1.0;
  tex_ang = 0.0;

  x = 0.5;
  y = 0.5;
  radius = 1.0;
  ang = 0.0;

  r = 0.0; /* red color value */
  g = 0.0; /* green color value */
  b = 0.0; /* blue color value */
  a = 0.0; /* alpha color value */

  r2 = 0.0; /* red color value */
  g2 = 0.0; /* green color value */
  b2 = 0.0; /* blue color value */
  a2 = 0.0; /* alpha color value */

  border_r = 0.0; /* red color value */
  border_g = 0.0; /* green color value */
  border_b = 0.0; /* blue color value */
  border_a = 0.0; /* alpha color value */
}

void
Shape::Draw(RenderContext &context)
{
  float xval, yval;
  float t;

  // printf("drawing shape %f\n", ang);

  float temp_radius= radius*(.707*.707*.707*1.04);

  //Additive Drawing or Overwrite
  if (additive == 0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  else                glBlendFunc(GL_SRC_ALPHA, GL_ONE);

  xval= x;
  yval= -(y-1);

  if ( textured)
  {
    if (imageUrl !="")
    {
      GLuint tex= context.textureManager->getTexture(imageUrl);
      if (tex != 0)
      {
        glBindTexture(GL_TEXTURE_2D, tex);
        context.aspectRatio=1.0;
      }
    }

    glMatrixMode(GL_TEXTURE);
    glPushMatrix();
    glLoadIdentity();

    glEnable(GL_TEXTURE_2D);

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    floatQuad *colors = new float[sides+2][4];
    floatPair *tex    = new float[sides+2][2];
    floatPair *points = new float[sides+2][2];

    //Define the center point of the shape
    colors[0][0] = r;
    colors[0][1] = g;
    colors[0][2] = b;
    colors[0][3] = a * masterAlpha;
    tex[0][0] = 0.5;
    tex[0][1] = 0.5;
    points[0][0] = xval;
    points[0][1] = yval;

    for ( int i=1;i< sides+2;i++)
    {
      colors[i][0] = r2;
      colors[i][1] = g2;
      colors[i][2] = b2;
      colors[i][3] = a2 * masterAlpha;

      t = (i-1)/(float) sides;
      tex[i][0] =  0.5f + 0.5f*cosf(t*3.1415927f*2 +  tex_ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)/ tex_zoom;
      tex[i][1] =  0.5f + 0.5f*sinf(t*3.1415927f*2 +  tex_ang + 3.1415927f*0.25f)/ tex_zoom;
      points[i][0]=temp_radius*cosf(t*3.1415927f*2 +  ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
      points[i][1]=temp_radius*sinf(t*3.1415927f*2 +  ang + 3.1415927f*0.25f)+yval;
    }

    glVertexPointer(2,GL_FLOAT,0,points);
    glColorPointer(4,GL_FLOAT,0,colors);
    glTexCoordPointer(2,GL_FLOAT,0,tex);

    glDrawArrays(GL_TRIANGLE_FAN,0,sides+2);

    glDisable(GL_TEXTURE_2D);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);

    //Reset Texture state since we might have changed it
    /*
    if(this->renderTarget->useFBO)
    {
      glBindTexture( GL_TEXTURE_2D, renderTarget->textureID[1] );
    }
    else
    {
      glBindTexture( GL_TEXTURE_2D, renderTarget->textureID[0] );
    }
    */

    delete[] colors;
    delete[] tex;
    delete[] points;
  }
  else
  {
    //Untextured (use color values)

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);

    floatQuad *colors = new float[sides+2][4];
    floatPair *points = new float[sides+2][2];

    //Define the center point of the shape
    colors[0][0]=r;
    colors[0][1]=g;
    colors[0][2]=b;
    colors[0][3]=a * masterAlpha;
    points[0][0]=xval;
    points[0][1]=yval;


    for ( int i=1;i< sides+2;i++)
    {
      colors[i][0]=r2;
      colors[i][1]=g2;
      colors[i][2]=b2;
      colors[i][3]=a2 * masterAlpha;
      t = (i-1)/(float) sides;
      points[i][0]=temp_radius*cosf(t*3.1415927f*2 +  ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
      points[i][1]=temp_radius*sinf(t*3.1415927f*2 +  ang + 3.1415927f*0.25f)+yval;

    }

    glVertexPointer(2,GL_FLOAT,0,points);
    glColorPointer(4,GL_FLOAT,0,colors);


    glDrawArrays(GL_TRIANGLE_FAN,0,sides+2);
    //draw first n-1 triangular pieces

    delete[] colors;
    delete[] points;
  }
  if (thickOutline==1)  glLineWidth(context.texsize < 512 ? 1 : 2*context.texsize/512);

  glEnableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);

  floatPair *points = new float[sides+1][2];

  glColor4f( border_r, border_g, border_b, border_a * masterAlpha);

  for ( int i=0;i< sides;i++)
  {
    t = (i-1)/(float) sides;
    points[i][0] = temp_radius*cosf(t*3.1415927f*2 +  ang + 3.1415927f*0.25f)*(context.aspectCorrect ? context.aspectRatio : 1.0)+xval;
    points[i][1] = temp_radius*sinf(t*3.1415927f*2 +  ang + 3.1415927f*0.25f)+yval;
  }

  glVertexPointer(2,GL_FLOAT,0,points);
  glDrawArrays(GL_LINE_LOOP,0,sides);

  if (thickOutline==1)  glLineWidth(context.texsize < 512 ? 1 : context.texsize/512);

  delete[] points;
}

void
MotionVectors::Draw(RenderContext &context)
{
  glEnableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);

  float  intervalx=1.0/x_num;
  float  intervaly=1.0/y_num;

  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  glPointSize(length);
  glColor4f(r, g, b, a * masterAlpha);

  if (x_num + y_num < 600)
  {
    int size = x_num * y_num ;

    floatPair *points = new float[size][2];

    for (int x=0;x<(int)x_num;x++)
    {
      for(int y=0;y<(int)y_num;y++)
      {
        float lx, ly, lz;
        lx = x_offset+x*intervalx;
        ly = y_offset+y*intervaly;

        points[(x * (int)y_num) + y][0] = lx;
        points[(x * (int)y_num) + y][1] = ly;
      }
    }

    glVertexPointer(2,GL_FLOAT,0,points);
    glDrawArrays(GL_POINTS,0,size);

    delete[] points;
  }
}

void
Border::Draw(RenderContext &context)
{
  glEnableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  //Draw Borders
  float of=outer_size*.5;
  float iff=inner_size*.5;
  float texof=1.0-of;

  //no additive drawing for borders
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  glColor4f(outer_r, outer_g, outer_b, outer_a * masterAlpha);

  float pointsA[4][2] = {{0,0},{0,1},{of,0},{of,1}};
  glVertexPointer(2,GL_FLOAT,0,pointsA);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

  float pointsB[4][2] = {{of,0},{of,of},{texof,0},{texof,of}};
  glVertexPointer(2,GL_FLOAT,0,pointsB);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

  float pointsC[4][2] = {{texof,0},{texof,1},{1,0},{1,1}};
  glVertexPointer(2,GL_FLOAT,0,pointsC);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

  float pointsD[4][2] = {{of,1},{of,texof},{texof,1},{texof,texof}};
  glVertexPointer(2,GL_FLOAT,0,pointsD);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

  glColor4f(inner_r, inner_g, inner_b, inner_a * masterAlpha);

  glRectf(of, of, of+iff, texof);
  glRectf(of+iff, of, texof-iff, of+iff);
  glRectf(texof-iff, of, texof, texof);
  glRectf(of+iff, texof, texof-iff, texof-iff);

  float pointsE[4][2] = {{of,of},{of,texof},{of+iff,of},{of+iff,texof}};
  glVertexPointer(2,GL_FLOAT,0,pointsE);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

  float pointsF[4][2] = {{of+iff,of},{of+iff,of+iff},{texof-iff,of},{texof-iff,of+iff}};
  glVertexPointer(2,GL_FLOAT,0,pointsF);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

  float pointsG[4][2] = {{texof-iff,of},{texof-iff,texof},{texof,of},{texof,texof}};
  glVertexPointer(2,GL_FLOAT,0,pointsG);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

  float pointsH[4][2] = {{of+iff,texof},{of+iff,texof-iff},{texof-iff,texof},{texof-iff,texof-iff}};
  glVertexPointer(2,GL_FLOAT,0,pointsH);
  glDrawArrays(GL_TRIANGLE_STRIP,0,4);

}