// ----------------------------------
// for sorting paths
class Path {
  int num;
  boolean flipped;

  Path(int _num, boolean _flipped) {
    num=_num;
    _flipped=flipped;
  }
}

// SVG and Path Planning Code

void readSVGFile(String filename) {
  if(printToConsole)println("initializing geomerative library...");

  RG.init(this);
  RG.ignoreStyles(true);
  
  //RG.setPolygonizer(RG.ADAPTATIVE);
  RG.setPolygonizer(RG.UNIFORMLENGTH);
  RCommand.setSegmentLength(SVGSEGMENTLENGTH*PPI);
  grp = RG.loadShape(filename);

  //grp = RG.loadShape("treemesh.svg");
  //grp = RG.loadShape("exploded_pocket_knife_simplified.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/exploded_pocket_knife.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/eye nerves outline.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/sign of the snake.svg");
  //grp = RG.loadShape("cal39.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/blood_storage_container_and_methods_fig3.svg");
  //grp = RG.loadShape("slit lamp diagram.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/rocking_horse.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/schechner_the_fan.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/bedroom_laurel_hatched_simplified.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/svgs/threshold_20_blur_hatch.svg");
  //grp = RG.loadShape("/Users/rtwomey/Documents/ankle_brace.svg");
  //grp = RG.loadShape("box.svg");

  grp.centerIn(g, 0, 0, 0);
  grpW = grp.getWidth();
  grpH = grp.getHeight();
  grpX = grp.getX();
  grpY = grp.getY();

  if(printToConsole) {
    print("width X height: "+grpW+" "+grpH);
    println(" (inches "+(grpW/PPI)+" "+(grpH/PPI)+")");
    println("on screen scale: "+onScreenScale);
    println("grpX,Y "+grpX+" "+grpY);
  }
  
  pointPaths = grp.getPointsInPaths();
  
  if(printToConsole) println("image has "+pointPaths.length+" paths");
  paths = new Path[pointPaths.length];
  
  for (int i=0;i<pointPaths.length; i++)
    paths[i]=new Path(i, false);

  // nearest neighbor sort
  sortPointPaths();

  drawSortedPointPaths();

  if(printToConsole) println("done reading SVG data.");
}

// ---------------------------------------------------- //
// sorting pointpaths by nearest neighbor
//

void sortPointPaths() {
  if(printToConsole) {
    print("sorting pointpaths by nearest begin-end points, starting in upper left. ");
    println("("+pointPaths.length+" paths)");
  }
  
  boolean [] pathUsed = new boolean[pointPaths.length];
  for (i=0; i<pointPaths.length; i++)
    pathUsed[i]=false;

  boolean done=false;
  boolean flipped=false;
  int i=0;
  int count=0;
  while (!done) {
    paths[count].num=i;
    paths[count].flipped=flipped;
    //  paths[count].num = new Path(i, flipped);
    //if(flipped) println("FLIPPED!");
    RPoint finish;
    //    RPoint start;

    int pathlen=pointPaths[i].length;
    if (flipped) {
      finish=pointPaths[i][0];
      //start=pointPaths[i][pathlen-1];
    } 
    else {
      ///start=pointPaths[i][0];
      finish=pointPaths[i][pathlen-1];
    }

    //    print(i+": start "+start.x+", "+start.y);
    //    println("  finish "+finish.x+", "+finish.y+" "+pathlen+" points.");

    pathUsed[i]=true;

    float testdist = 999999;
    boolean testflipped=false;   
    int testindex=-1;

    for (j=0; j<pointPaths.length; j++) {
      if (!pathUsed[j] && pointPaths[j]!=null) {
        RPoint testStart, testFinish;
        testStart = pointPaths[j][0];
        testFinish = pointPaths[j][pointPaths[j].length-1];      
        float distFS=dist(finish.x, finish.y, testStart.x, testStart.y);
        float distFF=dist(finish.x, finish.y, testFinish.x, testFinish.y);

        if (distFS < testdist) {
          testdist=distFS;
          testflipped=false;
          testindex=j;
        }

        if (distFF < testdist) {
          testdist=distFF;
          testflipped=true;
          testindex=j;
        }
      }
    }

    if (testindex > 0) {
      pathUsed[testindex]=true;

      i=testindex;
      flipped=testflipped;

      count++;
      if (count>=pointPaths.length)
        done=true;
    } 
    else {
      done=true;
    }
  }
  if(printToConsole) println("done sorting.");
}


// display the sorted plotting path on screen

void drawSortedPointPaths() {
  float xstart, ystart, xend, yend;
  float lastx=0, lasty=0;
  
  for (int i=0; i<paths.length-1; i++) {
    int pathlen = pointPaths[paths[i].num].length;
    RPoint first, last;
    first=pointPaths[paths[i].num][0];
    last=pointPaths[paths[i].num][pathlen-1];

    if (paths[i].flipped) {
      xstart=last.x;
      ystart=last.y;
      xend=first.x;
      yend=first.y;
      //      println("FLIPPED!");
    } 
    else {
      xstart=first.x;
      ystart=first.y;
      xend=last.x;
      yend=last.y;
    }
    noStroke();
    //fill(255, 0, 0, 128);
    //ellipse(xstart*onScreenScale, ystart*onScreenScale, 5, 5);
    //text(i, xstart*onScreenScale+5, ystart*onScreenScale+5);

    //fill(128, 0, 0, 128);
    //ellipse(xend*onScreenScale, yend*onScreenScale, 5, 5);

    strokeWeight(2);
    stroke(128, 128, 128, 64);
    line(xstart*onScreenScale, ystart*onScreenScale, xend*onScreenScale, yend*onScreenScale);

    stroke(0, 64, 0, 64);
    line(xstart*onScreenScale, ystart*onScreenScale, lastx, lasty);
    lastx=xend*onScreenScale;
    lasty=yend*onScreenScale;

    for (int j=0; j<pathlen-1; j++) {
      stroke(0, 0, 64, 64);
      line(pointPaths[paths[i].num][j].x*onScreenScale, pointPaths[paths[i].num][j].y*onScreenScale, 
      pointPaths[paths[i].num][j+1].x*onScreenScale, pointPaths[paths[i].num][j+1].y*onScreenScale);
    }
  }
}

void drawScaledSegment(float x1, float y1, float x2, float y2) {
  stroke(0);
  line(x1*onScreenScale, y1*onScreenScale, x2*onScreenScale, y2*onScreenScale);
};

void drawCrossHairs(float x, float y) {
  float px, py;
  px=x*onScreenScale;
  py=y*onScreenScale;
//  stroke(128, 0, 0, 128);
//  line(px-3, py, px+3, py);
//  line(px, py-3, px, py+3);

  stroke(192, 0, 0, 128);
  line(px-1, py, px+1, py);
  line(px, py-1, px, py+1);
  
  
};

int findClosestPath(float testx, float testy) {
  int closest=-1;
  float mindist=999999;
  for (int i=0; i<pointPaths.length; i++) {
    float testdist=dist(testx, testy, pointPaths[i][0].x, pointPaths[i][0].y);

    if (testdist<mindist) {
      mindist=testdist;
      closest=i;
    }
  }
  return closest;
}