#ifdef WIN32
#include <windows.h>
#endif

#include <GL/gl.h>
#include <GL/glu.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>


#define MAX_NCURVES 100
#define MAX_NVERTS 500

typedef struct {
  double x,y;
} POINT2;

typedef struct {
  int len;
  POINT2 *verts;
} CURVE;

CURVE *curves = new CURVE[MAX_NCURVES];
int nCurves = 0;
enum {IDLE, ADDING};
int mode = IDLE;
int winWidth,winHeight;
int imgWidth,imgHeight;
int scaledImgWidth,scaledImgHeight;
double lineSize=0.5;
double xMin=0,xMax=1,yMin=0,yMax=1,f=2;
char *curveFile=NULL,*imgFile=NULL;
byte *origImg=NULL,*scaledImg=NULL;
double x1Chg,y1Chg,x2Chg,y2Chg;
int drawImage = 1;

//////////////////////////////////////////////////////

void handleReshape(int w, int h) {
  winWidth  = w;
  winHeight = h;

  //
  // Set the viewport
  //
  glViewport(0, 0, w, h);

  glDisable(GL_CULL_FACE);
  glEnable(GL_AUTO_NORMAL);
  glEnable(GL_NORMALIZE);
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LESS);

  GLfloat ambient[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  GLfloat diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  GLfloat specular[] = { 0.0f, 0.0f, 0.0f, 1.0f };
  GLfloat position[] = { 0.0f, 0.0f, -1.0f, 0.0f };
    
  GLfloat lmodel_ambient[] = { 0.0f, 0.0f, 0.0f, 1.0f };
  int local_view[] = { false };

       /**** set lighting parameters ****/
  glLightfv(GL_LIGHT0, GL_AMBIENT,  ambient);
  glLightfv(GL_LIGHT0, GL_DIFFUSE,  diffuse);
  glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
  glLightfv(GL_LIGHT0, GL_POSITION, position);
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
  glLightModeliv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);

//  glPixelStorei(GL_PACK_ALIGNMENT, 1);

  // resize the image to fit the screen.

  if (imgFile != NULL) {
    if (scaledImg != NULL)
      free(scaledImg);
    scaledImgWidth  = winWidth;
    scaledImgHeight = winHeight;

//    printf("win:(%d %d) orig: (%d %d) scaled:(%d %d)\n",
//            winWidth,winHeight,imgWidth,imgHeight,
//            scaledImgWidth,scaledImgHeight);

    scaledImg = new byte[scaledImgWidth*scaledImgHeight*4];
    gluScaleImage(GL_RGBA, imgWidth, imgHeight,
                  GL_UNSIGNED_BYTE, origImg,
                  scaledImgWidth, scaledImgHeight,
                  GL_UNSIGNED_BYTE, scaledImg);
  } 

  //
  // Now start setting the projection matrix stack
  //
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  double dx = (xMax-xMin)/2.0;
  double dy = (yMax-yMin)/2.0;
  glOrtho(-dx,dx, -dy,dy, 0.1*f, f*2.0);

  x1Chg = 0.0;
  y1Chg = 0.0;
  x2Chg = 1.0;
  y2Chg = 1.0;
}

//////////////////////////////////////////////////////

void readImage() {
  if (imgFile != NULL) {
    FILE *fp = fopen(imgFile,"rb");
    if (fp == NULL) {
      fprintf(stderr,"Can't read image file %s\n",imgFile);
      exit(1);
    }
    int w,h,found=false;
    int row;
    char line[80];
    fgets(line,79,fp);
    line[2] = '\0';
    if (strcmp(line,"P6") != 0) {
      fprintf(stderr,"Not a raw PPM image!  Magic=%s\n",line);
      exit(1);
    }
    while (!found) {
      fgets(line,79,fp);
      if (line[0] != '#')
        found = true;
    }
    sscanf(line,"%d %d",&w,&h);

    imgWidth = w;
    imgHeight = h;

    winWidth = w;
    winHeight = h;

    found = false;
    while (!found) {
      fgets(line,79,fp);
      if (line[0] != '#')
        found = true;
    }

    // Ok, now we've read the header.  Time to grab the bytes.
    if (origImg != NULL)
      free(origImg);
    origImg = new byte[4*h*w];
    //
    // PPM images are stored top-to-bottom, but glDrawPixels
    // draws from bottom-to-top, so we have to store rows
    // of pixels in reverse order for it to look right.
    // To make life easier, store pixels as RGBA, not RGB.
    // That simplifies alignment.
    //
    byte *oneRow = new byte[3*w];
    byte *src,*dst;
    for (row=h-1; row>=0; row--) {
      fread(oneRow,3,w,fp);
      src = oneRow;
      dst = origImg + row*w*4;
      for (int col=0; col<w; col++) {
        *dst++ = *src++;
        *dst++ = *src++;
        *dst++ = *src++;
        *dst++ = 255;
      }
    }
    fclose(fp);

//    printf("image size: (%d x %d)\n",w,h);
//    printf("first row:");
//    int col;
//    row = 0;
//    for (col=0; col<3; col++) {
//      i = (row*imgWidth+col)*4;
//      printf(" (%3d %3d %3d %3d)",origImg[i],origImg[i+1],origImg[i+2],origImg[i+3]);
//    }
//    printf("\n");
//    printf("middle row:");
//
//   row = imgHeight/2;
//    for (col=0; col<3; col++) {
//      i = (row*imgWidth+col)*4;
//      printf(" (%3d %3d %3d %3d)",origImg[i],origImg[i+1],origImg[i+2],origImg[i+3]);
//    }
//    printf("\n");
//    printf("last row:");
//    row = imgHeight-1;
//    for (col=0; col<3; col++) {
//      i = (row*imgWidth+col)*4;
//      printf(" (%3d %3d %3d %3d)",origImg[i],origImg[i+1],origImg[i+2],origImg[i+3]);
//    }
//    printf("\n");
//
  }
  else {
    winWidth = 300;
    winHeight = 300;
  }
}
        
//////////////////////////////////////////////////////

void saveCurves() {
  FILE *fp;

  if ((fp=fopen(curveFile,"w")) == NULL) {
    fprintf(stderr,"Can't write to file %s\n",curveFile);
    exit(1);
  }

  int i,j,len;

  fprintf(fp,"%d\n",nCurves);
  for (i=0; i<nCurves; i++) {
    len = curves[i].len;
    fprintf(fp,"%d\n",len);
    for (j=0; j<len; j++) {
      fprintf(fp,"%6.3lf %6.3lf\n",
              curves[i].verts[j].x,
              curves[i].verts[j].y);
    }
  }
  fclose(fp);
}

//////////////////////////////////////////////////////

void rc2xy (int row, int col, double *x, double *y) {
  *x = xMin + (double)col/winWidth              * (xMax-xMin);
  *y = yMin + (double)(winHeight-row)/winHeight * (yMax-yMin);
}

//////////////////////////////////////////////////////

void newCurve() {
  if (nCurves > MAX_NCURVES) {
    fprintf(stderr,"Can't allocate more than %d curves, sorry.\n",
            MAX_NCURVES);
  }
  else {
    int i = nCurves++;
    curves[i].len = 0;
    curves[i].verts = new POINT2[MAX_NVERTS];
  }
}

//////////////////////////////////////////////////////

void addVertex(double x, double y) {

//  printf("addVertex: (x y)=(%6.3lf %6.3lf)\n",x,y);

  int i = nCurves-1;
  if (curves[i].len > MAX_NVERTS) {
    fprintf(stderr,"Curve too long.  Max is %d vertices\n",
            MAX_NVERTS);
  }
  else {
    int j = curves[i].len++;
    curves[i].verts[j].x = x;
    curves[i].verts[j].y = y;
  }
}

//////////////////////////////////////////////////////

void delVertex() {
  int i = nCurves-1;
  if (curves[i].len > 0) {
    curves[i].len--;
  }
}

//////////////////////////////////////////////////////

void readCurves() {
  FILE *fp;

  if ((fp=fopen(curveFile,"r")) == NULL) {
    fprintf(stderr,"Can't read file %s\n",curveFile);
    return;
  }

  int i,j,n,len;
  double x,y;

  fscanf(fp,"%d",&n);
  for (i=0; i<n; i++) {
    fscanf(fp,"%d\n",&len);
    newCurve();
    for (j=0; j<len; j++) {
      fscanf(fp,"%lf %lf",&x,&y);
      addVertex(x,y);
    }
  }
  fclose(fp);
}

//////////////////////////////////////////////////////

void handleMouse (int button, int state, int col, int row) {
  
//  printf("handleMouse: but=%d state=%d (col row)=(%d %d)\n",
//        button,state,col,row);
  int i=(winHeight-row)*winWidth*4 + col*4;
  int r = scaledImg[i++];
  int g = scaledImg[i++];
  int b = scaledImg[i++];
//  printf("image at (%d %d)=(%d %d %d)\n",row,col,r,g,b);

  if (button == GLUT_LEFT_BUTTON &&
      state == GLUT_UP) {
    if (mode == ADDING) {
      double x,y;
      rc2xy (row,col, &x,&y);

//      printf("(x y)=(%6.3lf %6.3lf)\n",x,y);

      addVertex(x,y);
    }
  }

  glutPostRedisplay();
}

//////////////////////////////////////////////////////

void setMaterial(double r, double g, double b) {
  float ambient = 1.f;
  float diffuse = 1.f;
  float specular = 1.f;
  GLfloat mat[4];

//  printf("setMaterial: colour=(%3d %3d %3d)\n",c.r,c.g,c.b);

      /**** set ambient lighting parameters ****/
  mat[0] = ambient*r;
  mat[1] = ambient*g;
  mat[2] = ambient*b;
  mat[3] = 1.0;
  glMaterialfv (GL_FRONT, GL_AMBIENT, mat);

      /**** set diffuse lighting parameters ******/
  mat[0] = diffuse*r;
  mat[1] = diffuse*g;
  mat[2] = diffuse*b;
  mat[3] = 1.0;
  glMaterialfv (GL_FRONT, GL_DIFFUSE, mat);

      /**** set specular lighting parameters *****/
  mat[0] = specular*r;
  mat[1] = specular*g;
  mat[2] = specular*b;
  mat[3] = 1.0;
  glMaterialfv (GL_FRONT, GL_SPECULAR, mat);
  glMaterialf (GL_FRONT, GL_SHININESS, 0.3F);
}

//////////////////////////////////////////////////////

void display () {
  glClearColor(.1f,.1f,.1f, 1.f);   /* set the background colour */
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  gluLookAt((xMin+xMax)/2.0, (yMin+yMax)/2.0, f,
            (xMin+xMax)/2.0, (yMin+yMax)/2.0, 0.0,
            0.0, 1.0, 0.0);

  //
  // To speed things up, only modify frame buffer
  // in a rectangle where changes happened.
  //

//  glEnable(GL_SCISSOR_TEST);
//  glScissor

  int i,j,len;
  double curveWidth = lineSize * f / winWidth * 1.0;
  double x1,y1,x2,y2,dx,dy,ll;

//  printf("curveWidth=%6.3f\n",curveWidth);

  glRasterPos3d(xMin,yMin,0.0);

//  double rasPos[4];
//  glGetDoublev(GL_CURRENT_RASTER_POSITION,rasPos);
//  printf("current ras pos: (%6.3lf %6.3lf %6.3lf %6.3lf)\n",
//         rasPos[0],rasPos[1],rasPos[2],rasPos[3]);

  if (drawImage)
    glDrawPixels(scaledImgWidth,scaledImgHeight,
               GL_RGBA,GL_UNSIGNED_BYTE,scaledImg);

  setMaterial(0.1,0.1,0.1);
  for (i=0; i<nCurves; i++) {
    len = curves[i].len;
    for (j=0; j<len-1; j++) {
      glBegin(GL_POLYGON);
      x1 = curves[i].verts[j].x;
      y1 = curves[i].verts[j].y;
      x2 = curves[i].verts[j+1].x;
      y2 = curves[i].verts[j+1].y;
      dx = x2 - x1;
      dy = y2 - y1;
      ll = sqrt (dx*dx + dy*dy);
      dx *= curveWidth / ll;
      dy *= curveWidth / ll;
      glVertex3d(x1-dy,y1+dx,0.02*f);
      glVertex3d(x2-dy,y2+dx,0.02*f);
      glVertex3d(x2+dy,y2-dx,0.02*f);
      glVertex3d(x1+dy,y1-dx,0.02*f);
      glEnd();
    }
  }

  glFlush();
  glutSwapBuffers();
}

//////////////////////////////////////////////////////

void handleKey(byte key, int x, int y) {
  int index;

  switch (key) {
  case 'q': exit(0);

  case 's':
    saveCurves();
    break;

  case 'a':
    mode = ADDING;
    newCurve();
    break;

  case 'u':
    delVertex();
    break;

  case 'c':
    index=nCurves-1;
    addVertex(curves[index].verts[0].x, curves[index].verts[0].y);
    mode = IDLE;
    break;

  case 'i':
	drawImage ^= 1;
	break;
  }

  glutPostRedisplay();
}

//////////////////////////////////////////////////////

void parseArgs(int argc, char** argv) {
  int i,l;

  imgFile = curveFile = NULL;
  for (i=1; i<argc; i++) {
    if (argv[i][0] == '-') {
      if (strcmp(argv[i]+1,"i") == 0) {
        l = strlen(argv[++i]);
        imgFile = new char[l];
        strcpy(imgFile,argv[i]);
      }
      else if (strcmp(argv[i]+1,"c") == 0) {
        l = strlen(argv[++i]);
        curveFile = new char[l];
        strcpy(curveFile,argv[i]);
      }
    }
  }
}

//////////////////////////////////////////////////////

main(int argc, char *argv[]) {
  parseArgs(argc,argv);
  readImage();
  readCurves();

  glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
  glutInitWindowPosition (0, 0);
  glutInitWindowSize(winWidth,winHeight);
  int mainWindowID = glutCreateWindow(argv[0]);


  glutReshapeFunc (handleReshape);
  glutKeyboardFunc(handleKey);
  glutMouseFunc   (handleMouse);
  glutDisplayFunc(display);
	
  printf("Curves.\n");
  printf("Press 's' to save curves.\n");
  printf("Press 'a' to add a curve.\n");
  printf("    Click to add a vertex.\n");
  printf("Press 'u' to remove a vertex.\n");
  printf("Press 'c' to close curve.\n");
  printf("Press 'i' to toggle bg image.\n");
  printf("Press 'q' to quit\n");

  glutMainLoop();

  return 0;         // never reached
}