#include "draw.h"
#include "Rectangle.h"
#include <math.h>
#include <gtk/gtk.h>
#include <gtk/gtkgl.h>
#include <GL/gl.h>


static float scale = 100.0;
static float xTranslate = 0.0, yTranslate = 0.0;


static void drawGrid(const Rectangle &rect) {
  float depth = log10f(scale)-0.75f;
  float depth2 = floorf(depth);
  float step = powf(0.1f, depth2);
  float f;
  int i;
  //gchar *string;
  float x1 = rect.getVertex1().getX(), y1 = rect.getVertex1().getY();
  float x2 = rect.getVertex2().getX(), y2 = rect.getVertex2().getY();
  
  
  glBegin(GL_LINES);
  //cairo_set_font_size(cr, 10.0/scale);
  
  for(i = 0; 0.4f*(depth-depth2+i-1) < 0.5f; i++) {
    f = fminf(0.4f*(depth-depth2+i), 0.5f);
    glColor3f(f, f, f);
    
    for(f = x1 - fmodf(x1, step) - step; f <= x2; f+=step) {
      glVertex2f(f, y1);
      glVertex2f(f, y2);
      
      /*if(step > 0.005) {
        if(step > 0.5)
          string = g_strdup_printf("%i", (int)rint(d));
        else
          string = g_strdup_printf("%.*f", -(int)floor(log10(step*1.1)), d+step/10);
        
        cairo_move_to(cr, d+1/scale, y1+11/scale);
        cairo_show_text(cr, string);
        
        g_free(string);
      }*/
    }
    
    for(f = y1 - fmodf(y1, step) - step; f <= y2; f+=step) {
      glVertex2f(x1, f);
      glVertex2f(x2, f);
      
      /*if(step > 0.005) {
        if(step > 0.5)
          string = g_strdup_printf("%i", (int)rint(d));
        else
          string = g_strdup_printf("%.*f", -(int)floor(log10(step*1.1)), d+step/10);
        
        cairo_move_to(cr, x1+3/scale, d+11/scale);
        cairo_show_text(cr, string);
        
        g_free(string);
      }*/
    }
    
    step *= 10;
  }
  
  glEnd();
}

static void fillPolygon(const Polygon &polygon) {
  std::vector<Triangle> triangles;
  
  polygon.triangulate(triangles);
  
  glBegin(GL_TRIANGLES);
  
  for(std::vector<Triangle>::iterator t = triangles.begin(); t != triangles.end(); t++) {
    glVertex2f(t->getVertexA().getX(), t->getVertexA().getY());
    glVertex2f(t->getVertexB().getX(), t->getVertexB().getY());
    glVertex2f(t->getVertexC().getX(), t->getVertexC().getY());
  }
  
  glEnd();
}

static void drawPolygon(const Polygon &polygon, bool close) {
  glBegin(GL_LINE_STRIP);
  
  for(Polygon::const_iterator vertex = polygon.begin(); vertex != polygon.end(); vertex++)
    glVertex2d(vertex->getX(), vertex->getY());
  
  if(close)
    glVertex2d(polygon.front().getX(), polygon.front().getY());
  
  glEnd();
}

gboolean drawTopView(GtkWidget *widget, GdkEventExpose *event, Level *level, EditManager *editor) {
  GdkGLContext *context = gtk_widget_get_gl_context(widget);
  GdkGLDrawable *drawable = gtk_widget_get_gl_drawable(widget);
  Vertex v1(0, 0), v2(widget->allocation.width, widget->allocation.height);
  Rectangle rect;
  
  
  if(level == NULL) return FALSE;
  
  viewToImage(level, &v1);
  viewToImage(level, &v2);
  
  rect.setVertex1(v1);
  rect.setVertex2(v2);
  
  if(!gdk_gl_drawable_gl_begin(drawable, context))
    return FALSE;
  
  glClear(GL_COLOR_BUFFER_BIT);
  
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  
  glLineWidth(1.0f);
  
  glTranslatef(getImageWidth(level)/2-xTranslate, getImageHeight(level)/2-yTranslate, 0);
  glScalef(scale, scale, 1);
  
  drawGrid(rect);
  
  for(Level::const_iterator room = level->begin(); room != level->end(); room++) {
    if(&*room == editor->getActiveRoom() && editor->getMode() == EditManager::ADD) continue;
    
    if(&*room == editor->getActiveRoom())
      glColor4f(0.0f, 0.7f, 1.0f, 0.2f);
    else
      glColor4f(0.0f, 0.7f, 1.0f, 0.3f);
    
    fillPolygon(*room);
    
    if(&*room == editor->getActiveRoom()) {
      glColor4f(1.0f, 1.0f, 1.0f, 0.9f);
      glLineWidth(2.0f);
    }
    else if(&*room == editor->getHoveredRoom() && editor->getMode() == EditManager::VIEW) {
      glColor4f(0.0f, 0.7f, 1.0f, 0.7f);
      glLineWidth(2.0f);
    }
    else {
      glColor4f(0.0f, 0.7f, 1.0f, 0.7f);
      glLineWidth(1.0f);
    }
    
    drawPolygon(*room, true);
  }
  
  if(editor->getMode() == EditManager::ADD) {
    if(editor->polygonOk(*editor->getActiveRoom()))
      glColor4f(0.0f, 0.7f, 1.0f, 0.2f);
    else
      glColor4f(1.0f, 0.3f, 0.3f, 0.2f);
    
    fillPolygon(*editor->getActiveRoom());
    
    glLineWidth(2.0f);
    glColor4f(0.0f, 0.7f, 1.0f, 0.7f);
    drawPolygon(*editor->getActiveRoom(), false);
    
    if(!editor->getActiveRoom()->empty() && editor->getHoveredVertex()) {
      if(!editor->vertexOk(*editor->getHoveredVertex()))
        glColor4f(1.0f, 0.3f, 0.3f, 0.7f);
      
      glBegin(GL_LINES);
      
      glVertex2d(editor->getActiveRoom()->back().getX(), editor->getActiveRoom()->back().getY());
      glVertex2d(editor->getHoveredVertex()->getX(), editor->getHoveredVertex()->getY());
      
      glEnd();
    }
  }
  
  glPopMatrix();
  
  gdk_gl_drawable_swap_buffers(drawable);
  
  gdk_gl_drawable_gl_end(drawable);
  
  return TRUE;
}


float getScale() {
  return scale;
}

void setScale(float s) {
  scale = s;
}

void imageToView(Level *level, Vertex *v) {
  v->setX(v->getX()*scale+getImageWidth(level)/2-xTranslate);
  v->setY(v->getY()*scale+getImageHeight(level)/2-yTranslate);
}

void viewToImage(Level *level, Vertex *v) {
  v->setX((v->getX()-getImageWidth(level)/2+xTranslate)/scale);
  v->setY((v->getY()-getImageHeight(level)/2+yTranslate)/scale);
}

float getImageWidth(Level *level) {
  float min = 0.0, max = 0.0;
  
  
  if(level) {
    for(Level::iterator room = level->begin(); room != level->end(); room++) {
      for(Room::iterator v = room->begin(); v != room->end(); v++) {
        min = fminf(min, v->getX());
        max = fmaxf(max, v->getX());
      }
    }
  }
  
  return (max-min+10)*scale;
}

float getImageHeight(Level *level) {
  float min = 0.0, max = 0.0;
  
  
  if(level) {
    for(Level::iterator room = level->begin(); room != level->end(); room++) {
      for(Room::iterator v = room->begin(); v != room->end(); v++) {
        min = fminf(min, v->getY());
        max = fmaxf(max, v->getY());
      }
    }
  }
  
  return (max-min+10)*scale;
}

float getXTranslate() {
  return xTranslate;
}

void setXTranslate(float x) {
  xTranslate = x;
}

float getYTranslate() {
  return yTranslate;
}

void setYTranslate(float y) {
  yTranslate = y;
}