#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#include <gl/gl.h>
#include <stdio.h>
#include <stdlib.h>
#include "prof.h"
#include "prof_internal.h"

#pragma warning(disable:4305; disable:4244)

// use factor to compute a glow amount
static int get_colors(float factor,
                       float text_color_ret[3],
                       float glow_color_ret[3],
                       float *glow_alpha_ret)
{
   const float GLOW_RANGE = 0.5f;
   const float GLOW_ALPHA_MAX = 0.5f;
   float glow_alpha;
   int i;
   float hot[3] = {1, 1.0, 0.9};
   float cold[3] = {0.15, 0.9, 0.15};

   float glow_cold[3] = {0.5f, 0.5f, 0};
   float glow_hot[3] = {1.0f, 1.0f, 0};

   if (factor < 0) factor = 0;
   if (factor > 1) factor = 1;

   for (i=0; i < 3; ++i)
      text_color_ret[i] = cold[i] + (hot[i] - cold[i]) * factor;

   // Figure out whether to start up the glow as well.
   glow_alpha = (factor - GLOW_RANGE) / (1 - GLOW_RANGE);
   if (glow_alpha < 0) {
      *glow_alpha_ret = 0;
      return 0;
   }

   for (i=0; i < 3; ++i)
      glow_color_ret[i] = glow_cold[i] + (glow_hot[i] - glow_cold[i]) * factor;

   *glow_alpha_ret = glow_alpha * GLOW_ALPHA_MAX;
   return 1;
}

static void draw_rectangle(float x0, float y0, float x1, float y1)
{
   // FACE_CULL is disabled so winding doesn't matter
   glVertex2f(x0, y0);
   glVertex2f(x1, y0);
   glVertex2f(x1, y1);
   glVertex2f(x0, y1);
}

typedef struct
{
   float x0,y0;
   float sx,sy;
} GraphLocation;

static void graph_func(int id, int x0, int x1, float *values, void *data)
{
   GraphLocation *loc = (GraphLocation *) data;
   int i, r,g,b;

   // trim out values that are under 0.2 ms to accelerate rendering
   while (x0 < x1 && (*values < 0.0002f)) { ++x0; ++values; }
   while (x1 > x0 && (values[x1-1-x0] < 0.0002f)) --x1;

   if (id == 0)
      glColor4f(1,1,1,0.5);
   else {
      if (x0 == x1) return;

      id = (id >> 8) + id;
      r = id * 37;
      g = id * 59;
      b = id * 45;
#pragma warning(disable:4761)
      glColor3ub((r & 127) + 80, (g & 127) + 80, (b & 127) + 80);
   }

   glBegin(GL_LINE_STRIP);
   if (x0 == x1) {
      float x,y;
      x = loc->x0 + x0 * loc->sx;
      y = loc->y0 + values[0] * loc->sy;
      glVertex2f(x,loc->y0);
      glVertex2f(x, y);
   }
   for (i=0; i < x1-x0; ++i) {
      float x,y;
      x = loc->x0 + (i+x0) * loc->sx;
      y = loc->y0 + values[i] * loc->sy;
      glVertex2f(x,y);
   }
   glEnd();
}

Prof_extern_C void Prof_draw_graph_gl(float sx, float sy, float x_spacing, float y_spacing)
{
#ifdef Prof_ENABLED
   Prof_Begin(iprof_draw_graph)
   GraphLocation loc = { sx, sy, x_spacing, y_spacing * 1000 };
   Prof_graph(128, graph_func, &loc);
   Prof_End
#endif
}


// float to string conversion with sprintf() was
// taking up 10-20% of the Prof_draw time, so I
// wrote a faster float-to-string converter

static char int_to_string[100][4];
static char int_to_string_decimal[100][4];
static char int_to_string_mid_decimal[100][4];
static void int_to_string_init(void)
{
   int i;
   for (i=0; i < 100; ++i) {
      sprintf(int_to_string[i], "%d", i);
      sprintf(int_to_string_decimal[i], ".%02d", i);
      sprintf(int_to_string_mid_decimal[i], "%d.%d", i/10, i % 10);
   }
}

static char *formats[5] =
{
   "%.0f",
   "%.1f",
   "%.2f",
   "%.3f",
   "%.4f",
};

static void float_to_string(char *buf, float num, int precision)
{
   int x,y;
   switch(precision) {
      case 2:
         if (num < 0 || num >= 100)
            break;
         x = num;
         y = (num - x) * 100;
         strcpy(buf, int_to_string[x]);
         strcat(buf, int_to_string_decimal[y]);
         return;
      case 3:
         if (num < 0 || num >= 10)
            break;
         num *= 10;
         x = num;
         y = (num - x) * 100;
         strcpy(buf, int_to_string_mid_decimal[x]);
         strcat(buf, int_to_string_decimal[y]+1);
         return;
      case 4:
         if (num < 0 || num >= 1)
            break;
         num *= 100;
         x = num;
         y = (num - x) * 100;
         buf[0] = '0';
         strcpy(buf+1, int_to_string_decimal[x]);
         strcat(buf, int_to_string_decimal[y]+1);
         return;
   }
   sprintf(buf, formats[precision], num);
}

Prof_extern_C void Prof_draw_gl(float sx, float sy,
                                float full_width, float height,
                                float line_spacing, int precision,
    void (*printText)(float x, float y, char *str), float (*textWidth)(char *str))
{
#ifdef Prof_ENABLED
   Prof_Begin(iprof_draw)

   int i,j,n,o;
   GLuint cull, texture;
   float backup_sy;

   float field_width = textWidth("5555.55");
   float name_width  = full_width - field_width * 3;
   float plus_width  = textWidth("+");

   int max_records;

   Prof_Report *pob;

   if (!int_to_string[0][0]) int_to_string_init();

   if (precision < 1) precision = 1;
   if (precision > 4) precision = 4;

   // disable face culling to avoid having to get winding correct
   texture = glIsEnabled(GL_TEXTURE_2D);
   cull = glIsEnabled(GL_CULL_FACE);
   if (cull == GL_TRUE) {
      glDisable(GL_CULL_FACE);
   }

   pob = Prof_create_report();

   for (i=0; i < NUM_TITLE; ++i) {
      if (pob->title[i]) {
         float header_x0 = sx;
         float header_x1 = header_x0 + full_width;

         if (i == 0)
            glColor4f(0.1f, 0.3f, 0, 0.85);
         else
            glColor4f(0.2f, 0.1f, 0.1f, 0.85);

         glBegin(GL_QUADS);
         draw_rectangle(header_x0, sy-2, header_x1, sy-line_spacing+2);
         glEnd();

         if (i == 0) 
            glColor4f(0.6, 0.4, 0, 0);
         else
            glColor4f(0.8f, 0.1f, 0.1f, 0);

         printText(sx+2, sy, pob->title[i]);

         sy += 1.5*line_spacing;
         height -= abs(line_spacing)*1.5;
      }
   }

   max_records = height / abs(line_spacing);

   o = 0;
   n = pob->num_record;
   if (n > max_records) n = max_records;
   if (pob->hilight >= o + n) {
      o = pob->hilight - n + 1;
   }

   backup_sy = sy;

   // Draw the background colors for the zone data.
   glDisable(GL_TEXTURE_2D);
   glBegin(GL_QUADS);

   glColor4f(0,0,0,0.85);
   draw_rectangle(sx, sy, sx + full_width, sy - line_spacing);
   sy += line_spacing;

   for (i = 0; i < n; i++) {
      float y0, y1;

      if (i & 1) {
         glColor4f(0.1, 0.1f, 0.2, 0.85);
      } else {
         glColor4f(0.1f, 0.1f, 0.3, 0.85);
      }
      if (i+o == pob->hilight)
         glColor4f(0.3f, 0.3f, 0.1f, 0.85);

      y0 = sy;
      y1 = sy - line_spacing;

      draw_rectangle(sx, y0, sx + full_width, y1);
      sy += line_spacing;
   }
   glEnd();

   sy = backup_sy;
   glColor4f(0.7,0.7,0.7,0);

   if (pob->header[0])
      printText(sx+8, sy, pob->header[0]);

   for (j=1; j < NUM_HEADER; ++j)
      if (pob->header[j])
         printText(sx + name_width + field_width * (j-1) + 
            field_width/2 - textWidth(pob->header[j])/2, sy, pob->header[j]);

   sy += line_spacing;

   for (i = 0; i < n; i++) {
      char buf[256], *b = buf;
      Prof_Report_Record *r = &pob->record[i+o];
      float text_color[3], glow_color[3];
      float glow_alpha;
      float x = sx + textWidth(" ") * r->indent + plus_width/2;
      if (r->prefix) {
         buf[0] = r->prefix;
         ++b;
      } else {
         x += plus_width;
      }
      if (r->number)
         sprintf(b, "%s (%d)", r->name, r->number);
      else
         sprintf(b, "%s", r->name);
      if (get_colors(r->heat, text_color, glow_color, &glow_alpha)) {
         glColor4f(glow_color[0], glow_color[1], glow_color[2], glow_alpha);
         //printText(x+2, sy-1, buf);
		 printText(x+1, sy, buf);
      }
      glColor3fv(text_color);
      printText(x + 1, sy, buf);

      for (j=0; j < NUM_VALUES; ++j) {
         if (r->value_flag & (1 << j)) {
            int pad;
            float_to_string(buf, r->values[j], j == 2 ? 2 : precision);
            pad = field_width- plus_width - textWidth(buf);
            if (r->indent) pad += plus_width;
            printText(sx + pad + name_width + field_width * j, sy, buf);
         }
      }
              

      sy += line_spacing;
   }

   Prof_free_report(pob);

   if (cull == GL_TRUE)
      glEnable(GL_CULL_FACE);
   if (texture == GL_TRUE)
      glEnable(GL_TEXTURE_2D);

   Prof_End
#endif
}