import processing.pdf.*;

import fisica.*;
import geomerative.*;

static int PDF = 0;
static int P5 = 1;

float x,y,x1,x2,y1,y2;

RShape shp;
RPoint[] points;
RPoint[][] pointPaths;
String[] traceList,gridList,dropList,logoList;
PGraphics canvas;

boolean stopDrawing = false;
boolean finalizing = false;

ArrayList traceBodies, gridBodies,dropBodies,logoBodies,allBodies;

FWorld world;
FPolyPlus poly;
FPolyMinus polym,polymi,logo;

int stopFrame;
String tmpdir,outputdir;

//=======================================
int outputMode = PDF;     //PDF or P5
//=======================================

float wert = 1;
float friction = 0.1;
float wert3 = 0;
float wert4 = 5;

void setup() {
  size(641,841);
  smooth();
  frameRate(100);

  tmpdir = loadStrings("i/tmp/tmpdir.i")[0];
  outputdir = loadStrings("i/tmp/outputdir.i")[0];


  stopFrame = int(random(40,100));
  //stopFrame = int(100);

  //Collections.shuffle(Arrays.asList(traceList));

  Fisica.init(this);
  //Fisica.setScale(50);

  world = new FWorld();

  //world.setGravity(random(-100,100),random(-200,80));
  world.setGravity(0,150);
  world.setEdges();
  world.remove(world.top);  

  world.left.setDrawable(false);
  world.right.setDrawable(false);
  world.left.setPosition(10,height/2);
  world.right.setPosition(width-60,height/2);

  world.bottom.setDrawable(false);  
  world.setEdgesRestitution(0.8);
  world.setEdgesFriction(friction);

  traceBodies = new ArrayList(); 
  gridBodies  = new ArrayList();
  dropBodies  = new ArrayList();
  logoBodies  = new ArrayList();

  allBodies = new ArrayList();



  //-----------------------------------------------------//

  gridList  = loadStrings(tmpdir + "obstacle.list");
  if (gridList.length > 0){

    for(int k=0; k<gridList.length; k++) { 
      shp = loadRShape(gridList[k]);

      polym = new FPolyMinus();
      polym.setCollisionShape(unionPath(shp));
      polym.setDrawShape(loadShape(gridList[k]));
      polym.setVisible(false);

      polym.setStatic(true);
      polym.setGrabbable(false);

      polym.setDensity(100);
      polym.setRestitution(0.94);
      polym.setFriction(10);    
      polym.setAngularDamping(wert);


      gridBodies.add(polym);

      /*if (k > 0){
       world.add(polym);
       }*/
      if (!(gridList[k].equals(tmpdir + "LFKNCH_obstacles_100928--5-00_0002.svg"))){
        world.add(polym);
      }

    }
    allBodies.addAll(gridBodies);

  }
  //-----------------------------------------------------//

  dropList  = loadStrings(tmpdir + "drop.list");  
  if (dropList.length > 0){

    for(int k=0; k<dropList.length; k++) {
      shp = loadRShape(dropList[k]);

      polymi = new FPolyMinus();
      polymi.setCollisionShape(unionPath(shp));
      polymi.setDrawShape(loadShape(dropList[k]));
      polymi.setVisible(false);

      //polymi.setDensity(1.0);

      polymi.setDensity(10);
      polymi.setRestitution(0.6);   
      polymi.setFriction(friction);

      //polymi.setPosition(0,-500);

      dropBodies.add(polymi);
      world.add(polymi);
    }
    allBodies.addAll(dropBodies);

  }
  //-----------------------------------------------------//

  traceList = loadStrings(tmpdir + "trace.list");
  if (traceList.length > 0){

    for(int k=0; k<traceList.length; k++) {
      shp = loadRShape(traceList[k]);

      poly = new FPolyPlus();
      poly.setCollisionShape(unionPath(shp));
      poly.setDrawShape(loadShape(traceList[k]));
      //poly.setPosition(random(-100,0),random(0,-200));
      poly.setVisible(true);

      poly.setDensity(100);
      poly.setRestitution(0.1);   
      poly.setFriction(friction);

      //poly.setStatic(true);

      traceBodies.add(poly);
      world.add(poly);

    }  
    allBodies.addAll(traceBodies);

  }
  //-----------------------------------------------------//

  FBox schraeg = new FBox(width*2,10);
  schraeg.setStatic(true);
  schraeg.setPosition(0,595);
  schraeg.setRotation(0.135);
  schraeg.setDrawable(false);
  world.add(schraeg);






  if(outputMode == PDF) {
    canvas = createGraphics(width, height, processing.core.PConstants.PDF, 
    outputdir + nf(month(),2) + nf(day(),2) +"-" 
      + nf(hour(),2) + nf(minute(),2) 
      + nf(second(),2) + ".pdf"); 
    canvas.beginDraw();
  }
  else if (outputMode == P5) {
    canvas = this.g;
    background(255);
  }
}//setup










void draw() {

  /*
  if (frameCount == 150 && outputMode == PDF) {
   canvas = createGraphics(width, height, processing.core.PConstants.PDF, 
   "o/" + nf(month(),2) + nf(day(),2) +"-" 
   + nf(hour(),2) + nf(minute(),2) 
   + nf(second(),2) + ".pdf"); 
   canvas.beginDraw();
   }
   */


  /*
  if (frameCount == (stopFrame - random(0,stopFrame/3))) {   
   for (int i = traceBodies.size()-1; i >= 0; i--) { 
   FPolyPlus bdy = (FPolyPlus) traceBodies.get(i);
   bdy.setStatic(false);
   }  
   }
   */




  if(!finalizing) {
    boolean rest = true;
    int i = 0;
    int j = 0;

    while(rest && i<allBodies.size() && frameCount > 50) {
      FPolyMinus bdy = (FPolyMinus) allBodies.get(i);
      rest = bdy.isResting();
      i++;
    }
    
    if(i == allBodies.size() || frameCount ==  stopFrame) {
      println("==================== FETISCHHHHHHHHHHH ================="); 
      finish();
    } 

  }


  /*
  if(!stopDrawing) {
   world.step();
   if(frameCount%5 == 0 || finalizing) {
   world.draw(canvas);
   }
   }
   */


  if(!stopDrawing) {
    world.step();
    if(frameCount%8 == 0 || finalizing || frameCount == 1) {
      world.draw(canvas);
    }
  }



}//draw













void finish() {

  finalizing = true;

  for (int i = gridBodies.size()-1; i >= 0; i--) { 
    FPolyMinus bdy = (FPolyMinus) gridBodies.get(i);
    //    if(i == 0) {
    //      world.add(bdy);
    //    }
    bdy.toggleVisible();
  }


  
  for (int i = dropBodies.size()-1; i >= 0; i--) { 
   FPolyMinus bdy = (FPolyMinus) dropBodies.get(i);
   bdy.toggleVisible();
   }
  



  /*
  for (int i = traceBodies.size()-1; i >= 0; i--) { 
   FPolyPlus bdy = (FPolyPlus) traceBodies.get(i);
   //bdy.toggleVisible();
   bdy.setFillColor(0,0,0);
   }
   */

  /* ////////////////////////////////////////////////////////////
   // NOCHMAL ZEICHNEN BESSER LÖSEN!!!
   //-----------------------------------------------------//
   traceList = loadStrings("i/tmp/trace.list");
   if (traceList.length > 0){
   
   for(int k=0; k<traceList.length; k++) {
   shp = loadRShape(traceList[k]);
   
   poly = new FPolyPlus();
   poly.setCollisionShape(unionPath(shp));
   poly.setDrawShape(loadShape(traceList[k]));
   poly.setVisible(true);
   //poly.setFillColor(0,0,0);
   
   traceBodies.add(poly);
   world.add(poly);
   
   }  
   allBodies.addAll(traceBodies);
   }
   //-----------------------------------------------------//
   //world.draw(canvas);
   */  ////////////////////////////////////////////////////////////



  ////////////////////////////////////////////////////////////
  // NOCHMAL ZEICHNEN BESSER LÖSEN!!!
  //-----------------------------------------------------//
  //traceList = loadStrings("i/tmp/trace.list");
  if (traceList.length > 0){

    for(int k=0; k<traceList.length; k++) {
      shp = loadRShape(traceList[k]);

      logo = new FPolyMinus();
      logo.setCollisionShape(unionPath(shp));
      logo.setDrawShape(loadShape(traceList[k]));
      logo.setVisible(true);
      //poly.setFillColor(0,0,0);

      logoBodies.add(logo);
      world.add(logo);

    }  
    allBodies.addAll(logoBodies);
  }
  //-----------------------------------------------------//
  //world.draw(canvas);
  ////////////////////////////////////////////////////////////








  //  for (int i = allBodies.size()-1; i >= 0; i--) { 
  //    FPolyMinus bdy = (FPolyMinus) allBodies.get(i);
  //    //bdy.setFillColor(255,255,255);
  //  }


  /*
  if(outputMode == PDF) {
   canvas = createGraphics(width, height, processing.core.PConstants.PDF, 
   "o/" + nf(month(),2) + nf(day(),2) +"-" 
   + nf(hour(),2) + nf(minute(),2) 
   + nf(second(),2) + ".pdf"); 
   canvas.beginDraw();
   }
   */

  draw();    
  stopDrawing = true;

  /* attempt to save an image with every PDF for preview-purposes
   PImage img = createImage(width, height, RGB);
   //img.loadPixels();
   //img.pixels = canvas.pixels;
   img = canvas;
   img.loadPixels(); 
   //img.updatePixels();
   img.save("test.tga");
   */

  if(outputMode == PDF) {
    canvas.dispose();
    canvas.endDraw();
    exit();
  }
}







RPoint[] unionPath(RShape shp) {

  RPoint[][] shapo = shp.getPointsInPaths();
  ArrayList polys = new ArrayList();
  RPolygon unionPoly = new RPolygon();

  for(int i = 0; i < shapo.length; i++) {
    RPolygon rpoly = new RPolygon(shapo[i]);
    polys.add(rpoly);
  }
  for(int i = 0; i < polys.size(); i++) {
    RPolygon p = (RPolygon) polys.get(i);
    unionPoly = unionPoly.union(p);
  }

  return unionPoly.getPoints();
}


RShape loadRShape(String svgpath) {

  RShape svgload;

  // VERY IMPORTANT: Allways initialize the library in the setup
  RG.init(this);
  RG.ignoreStyles(true);
  //RG.setPolygonizer(RG.UNIFORMSTEP);  

  svgload = RG.loadShape(svgpath); 

  return svgload;
}