/**
 * Copyright (c) 2010 LAFKON/Benjamin Stephan.
 *
 * This is free software, and you may redistribute it under the GPL.
 * This Software comes with absolutely no warranty.
 * For details see the license (http://www.lafkon.net/gpl.txt)
 *
 * http://www.forkable.eu/generators/va300/
 * http://www.lafkon.net/what/is/va300
 */

// This is the batch-PDF-generating version of the va300 generator.
// It generates x variations (specified in i/posternum.i) as printable PDFs.

// Also check the live-version made for continuous live projection. See URLs above.


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;
PGraphics canvas;
String[]vektorlist, singletonList;
ArrayList traceBodies, singletonBodies, allBodies, staticParts;

FWorld world;
FPolyPlus poly, polym, obstacle, obstacle02, obstacle03, obstacle04;

boolean firstRun = true;
boolean stopDrawing = false;
boolean finalizing = false;

//============================================================
int outputMode = PDF;   //PDF or P5
int outputNum = 10;     //overwritten by file i/posternum.i
//============================================================

String starttime, outputFormat;
float rndx;
float wert = 1;
float wert2 = 0.5;
float wert3 = 0;
float wert4 = 5;


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

  if(firstRun) {
    outputNum = int(loadStrings("i/posternum.i")[0]);
    outputFormat = loadStrings("i/posterformat.i")[0];
    vektorlist = loadStrings("i/participants.list");
    singletonList = loadStrings("i/info.list"); 
    Collections.shuffle(Arrays.asList(vektorlist));
    starttime = "-> STARTED:   " + nf(month(),2) + nf(day(),2) +"-" 
                + nf(hour(),2) +":" + nf(minute(),2) +":" + nf(second(),2);
  }

//============================================== WORLD setup ====
  if(firstRun) {
    RG.init(this);
    Fisica.init(this);
    world = new FWorld();
  
    world.setGravity(0, 100);
    world.setEdges();
    world.remove(world.top);  
    world.left.setDrawable(false);
    world.right.setDrawable(false);
    world.bottom.setDrawable(false);  
    world.setEdgesRestitution(0.8);
    world.setEdgesFriction(wert2);

    traceBodies = new ArrayList(); 
    singletonBodies = new ArrayList();  
    allBodies = new ArrayList(); 
    staticParts = new ArrayList();
  }


//============================================== SINGLETONS setup ====
  if(firstRun) {
    for(int k=0; k<singletonList.length; k++) { 
      shp = loadRShape(singletonList[k]);
      polym = new FPolyPlus();
      polym.setCollisionShape(unionPath(shp));
      polym.setDrawShape(loadShape(singletonList[k])); 

      singletonBodies.add(polym);
      world.add(polym);
    }
  }
  for (int k = 0; k < singletonBodies.size(); k++) { 
    polym = (FPolyPlus) singletonBodies.get(k);
    polym.setVisible(false);//false
    polym.setRotation(0);
    polym.setPosition(random(0,width/3), -400);
    polym.setDensity(40);
    polym.setRestitution(0.94);
    polym.setFriction(wert2);    
    polym.setAngularDamping(wert);
  }

//============================================== TRACERS setup ====
  if(firstRun) {
    for(int k=0; k<vektorlist.length; k++) { 
      shp = loadRShape(vektorlist[k]);
      poly = new FPolyPlus();
      poly.setCustomStyle(true);
      poly.setCollisionShape(unionPath(shp));
      poly.setDrawShape(loadShape(vektorlist[k]));

      traceBodies.add(poly);
      world.add(poly);
    }
  }
  Collections.shuffle(traceBodies);
  rndx = random(0, (width/3)-30);
  for (int k = 0; k < traceBodies.size(); k++) { 
    poly = (FPolyPlus) traceBodies.get(k);
    poly.setVisible(true);
    poly.setDensity(100);
    poly.setRestitution(0.0);   
    poly.setFriction(wert2);
    poly.setRotation(0);    
    poly.setPosition(rndx, (40*k)-80);
  }

//============================================== OBSTACLE setup ====
  if(firstRun) {
    obstacle = new FPolyPlus();
    String svgpath = "i/non-free/v/logos/va300logo_" +outputFormat +".svg";
    shp = loadRShape(svgpath);
    obstacle.setCollisionShape(unionPath(shp));
    obstacle.setDrawShape(loadShape(svgpath));
    obstacle.setVisible(false);

    singletonBodies.add(obstacle);
    world.add(obstacle);
  }
  obstacle.setStatic(true);  
  obstacle.setRotation(random(radians(-30), radians(30)));
  obstacle.setPosition(random(40,width-130), random((height/2)+50, (height)-180));
  obstacle.setRestitution(random(0.4,1.2));
  obstacle.setFriction(wert2);

//============================================== OBSTACLE02 setup ====
  if(firstRun) {
    obstacle02 = new FPolyPlus();
    String svgpath = "i/non-free/v/logos/sponsoren_" +outputFormat +".svg";
    shp = loadRShape(svgpath);
    obstacle02.setCollisionShape(unionPath(shp));
    obstacle02.setDrawShape(loadShape(svgpath));
    obstacle02.setVisible(false);

    singletonBodies.add(obstacle02);
    world.add(obstacle02);
  }
  obstacle02.setStatic(true);  
  obstacle02.setPosition(0,0);
  obstacle02.setRestitution(random(0.4,1.2));
  obstacle02.setFriction(wert2);


//============================================== OBSTACLE03 setup ====
  if(firstRun) {
    obstacle03 = new FPolyPlus();
    String svgpath = "i/non-free/v/logos/lafkon_" +outputFormat +".svg";
    shp = loadRShape(svgpath);
    obstacle03.setCollisionShape(unionPath(shp));
    obstacle03.setDrawShape(loadShape(svgpath));
    obstacle03.setVisible(false);

    singletonBodies.add(obstacle03);
    world.add(obstacle03);
  }
  obstacle03.setStatic(true);  
  obstacle03.setPosition(0,0);
  obstacle03.setRestitution(random(0.4,1.2));
  obstacle03.setFriction(wert2);


//============================================================
  if(firstRun) {
    allBodies.addAll(traceBodies);
    allBodies.addAll(singletonBodies);
    firstRun = false ;
  }

//============================================== CANVAS setup ====
  if(outputMode == PDF) {
    canvas = createGraphics(width, height, processing.core.PConstants.PDF, 
            "o/non-free/" +outputFormat +"/va300_" +outputFormat +"_" 
            + 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 end



void draw() {
  if(!finalizing) {
    boolean rest = true;
    int i = 0;
    
    // check whether *all* bodies are resting
    while(rest && i<allBodies.size()) {
      FPolyPlus bdy = (FPolyPlus) allBodies.get(i);
      rest = bdy.isResting();
      i++;
    } 
    // if all bodies are resting (or 1500 frames passed), start finishing this poster.
    if(i == allBodies.size() || frameCount > 1500) {
      println("======== GENERATED NR.: " +nf(outputNum, 4) +" in " +frameCount +" f"); 
      finish();
    }
  }

  if(!stopDrawing) {
    world.step();                           // advance simulation
    if(frameCount%2 == 0 || finalizing) {
      world.draw(canvas);                   // draw world 
    }
  }
}//draw end



void finish() {
  finalizing = true;
  //set singletons (non-tracing-bodies) to visible
  for (int i = singletonBodies.size()-1; i >= 0; i--) { 
    FPolyPlus bdy = (FPolyPlus) singletonBodies.get(i);
    bdy.toggleVisible();
  }
  //draw them once
  draw();    
  stopDrawing = true;
  //close PDF
  if(outputMode == PDF) {
    canvas.dispose();
    canvas.endDraw();
  }
  // reset values and generate next poster (or exit)
  outputNum--;
  if(outputNum > 0) {
    reset();
  } 
  else {
    println(starttime);
    println("-> FINISHED : " + nf(month(),2) + nf(day(),2) +"-" 
            + nf(hour(),2) +":" + nf(minute(),2) +":" + nf(second(),2));
    exit();
  }
}//finish( end


void reset() {
  canvas = null;
  finalizing = false;
  stopDrawing = false;  
  frameCount = 0;
  setup();
}


//=================================================== LISTENERS ===========

void keyPressed() {
  // finish current poster and start next
  if (key == 's') {
    finish();
  } 
  // set singletons (non-tracing-bodies) visible during the simulation 
  else if(key == 'v') {
    for (int i = singletonBodies.size()-1; i >= 0; i--) { 
      FPolyPlus bdy = (FPolyPlus) singletonBodies.get(i);
      bdy.toggleVisible();
    }
  }
}


//=================================================== UTILS ===========

//attempt to join/union multiple pathes to one single, closed path
//EXPERIMENTAL!!!
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();
}

// load SVG from URL as RShape (geomerative)
RShape loadRShape(String svgpath) {
  RShape svgload;
  RG.ignoreStyles(true);
  //RG.setPolygonizer(RG.UNIFORMSTEP);  
  svgload = RG.loadShape(svgpath); 

  return svgload;
}