ParticleSystem physics;
Particle[] siteParticles;
Graph myGraph;

// SETUP PARAMETERS
int rndSeed = floor(random(255));
float tick = 0.25;
float scaleAll = 1.0;
float fontSize = 10/scaleAll;
float titleSize = fontSize * 2;

// PLAYBACK OPTIONS
boolean blnBoxes = true;
boolean blnLines = true;
boolean blnExtraSite = true;
boolean blnText = false;
boolean blnNames = false;

boolean blnExplode = true;
boolean blnHull = false;
boolean blnCamera = true;
boolean blnRotate = true;


// HULL PARAMETERS
float squashPVect = -0.0;
float reachDist = 125.0;
int maxGenerations = 4;

// PVectors
PVector[] sitePts;
PVector[] sitePtsEnv;
PVector[] sitePtsTrain;
PVector[] railPts;
PVector siteCentre;
PVector center;

// GLOBAL PARAMETERS
float sprStr = 0.2;
float sprLength = 25.0;
float siteSprMult = 10.0;     //base spring strength divided by this factor
float siteLengthMult = 10.0;  //base spring length divided by this factor
float lobbyMult = 1.0;        //tighten lobby springs
float attrStr = -250.0;
float attrLength = 25.0;
float siteAttr = -0.0;
float siteAttrL = 15;
float progHeight = 10.0;
float avoidFactor = 1.0;

// INITIALIZING PARAMETERS
Node closeNode;
Node explodeNode;
Node drawNode;
Node otherNode;
Node[] blobNodes;
Node[] explodedNodes;
Node[] hullNodes;
Node[] buildHull;
ArrayList arrNetworks;
ArrayList hullNetworks;
int c = 0; //counter for new exploded nodes
int cExplode = 0;

// CAMERA PARAMETERS
float camLen = 140;
float trackRotH = 0;
float trackRotV = 0;
float trackZoom = 0;
float camRotX = 0.0;
float camRotY = 0.0;
float camRotStartX = 0.0;
float camRotStartY = 0.0;

// SCALING PARAMETERS
float massScale = 20.0;       //scale down sqft for representation
float noiseFactor = 1.0;      //diff in noiseValue pushes nodes apart
float noiseMin = 0.25;        //min diff between noiseValues
float trafficFactor = 1.0;    //sum of trafficFactors pulls nodes together
float sphereSize = 5.0;
float programMult = 1.0;      //mult all program sqft
float siteScale = 1.5;        //3D site NTS t/f import program sqft as is but scale site up to match

// THRESHOLD PARAMETERS
int crossThld = 8;            //sum of node crossover degrees above(incl) which to connect
float sqftThld = 4000.0;      //sqft above which to break
float chunkThld = 1000.0;     //node separation below which to chunk
float explodeThld = 10000.0;  //node separation below which to explode

void setup(){

  size(600, 450, P3D);
  colorMode(HSB, 100);
  randomSeed( rndSeed );
  println("random seed = " + rndSeed); 


  //MOUSE WHEEL STUFF
  addMouseWheelListener(new java.awt.event.MouseWheelListener() { 
    public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) { 
      mouseWheel(evt.getWheelRotation());
    }
  }
  );

  physics = new ParticleSystem(0.0, 0.0, 0.98, 0.2);  //Gx, Gy, Gz, drag
  physics.setGravity(0, 0, 0);
  physics.setDrag( 0.5 );
  myGraph = new Graph(physics);

  arrNetworks = new ArrayList();

  // LOAD SITE NODES
  String[] dataPoints = loadStrings("site_pts_boundary.txt");
  sitePts = new PVector[dataPoints.length];
  String[] dataPointsEnv = loadStrings("site_pts_env.txt");
  sitePtsEnv = new PVector[dataPointsEnv.length];
  String[] dataPointsTrain = loadStrings("site_pts_train.txt");
  sitePtsTrain = new PVector[dataPointsTrain.length];
  String[] dataPointsRail = loadStrings("site_pts_railway.txt");
  railPts = new PVector[dataPointsRail.length];

  siteCentre = new PVector();

  // GET BOUNDARY POINT DATA
  for(int i=0; i<dataPoints.length; i++){
    float[] onePointData = float(split(dataPoints[i], ","));
    sitePts[i] = new PVector(onePointData[0]*siteScale, onePointData[1]*siteScale, onePointData[2]*siteScale);
    PVector axisPt = new PVector(0,0,0);
    sitePts[i] = fx_MirrorPt(axisPt, sitePts[i]);
    siteCentre.add(sitePts[i]);
  }
  siteCentre.div(sitePts.length);

  // GET ENV POINT DATA
  for(int i=0; i<dataPointsEnv.length; i++){
    float[] onePointData = float(split(dataPointsEnv[i], ","));
    sitePtsEnv[i] = new PVector(onePointData[0]*siteScale, onePointData[1]*siteScale, onePointData[2]*-siteScale*2);
    PVector axisPt = new PVector(0,0,0);
    sitePtsEnv[i] = fx_MirrorPt(axisPt, sitePtsEnv[i]);
    // make site node
    color clr_S = color(0, 0, 0, 50);
    int crossover = 3;
    Node siteNode = myGraph.addNode("SiteNodeEnv"+i, 1.0, sitePtsEnv[i].x, sitePtsEnv[i].y, sitePtsEnv[i].z, clr_S, crossover, 4);
    siteNode.level = floor((onePointData[2]*-siteScale)/-15);
    siteNode.p.makeFixed();
    siteNode.sqft = 500.0;
    siteNode.sqftMin = 500.0;
    siteNode.noiseAllow = siteNode.level;
    siteNode.trafficRate = 5;
  }

  // GET TRAIN POINT DATA
  for(int i=0; i<dataPointsTrain.length; i++){
    float[] onePointData = float(split(dataPointsTrain[i], ","));
    sitePtsTrain[i] = new PVector(onePointData[0]*siteScale, onePointData[1]*siteScale, onePointData[2]*siteScale*(-1));
    PVector axisPt = new PVector(0,0,0);
    sitePtsTrain[i] = fx_MirrorPt(axisPt, sitePtsTrain[i]);
  }

  // GET RAILWAY POINT DATA
  for(int i=0; i<dataPointsRail.length; i++){
    float[] onePointData = float(split(dataPointsRail[i], ","));
    railPts[i] = new PVector(onePointData[0]*siteScale, onePointData[1]*siteScale, onePointData[2]*siteScale*(-1));
    PVector axisPt = new PVector(0,0,0);
    railPts[i] = fx_MirrorPt(axisPt, railPts[i]);
  }

  // LOAD INCUBATOR
  String[] records_I = loadStrings("program_incubator.csv"); // each string of records[] is a new line
  for(int i=2; i<records_I.length-1; i++){
    String[] items = split( records_I[i], ",");
    float mass = float(items[1])/massScale;
    float crossover = float(items[4]);
    color clr_I = getColour("orange");
    int noiseAllow = int(items[9]);
    int trafficRate = int(items[10]);
    Node theNode = myGraph.addNode(items[0], 1.0, random(-10,10), random(-10,10), random(-10,10), clr_I, crossover, 1);
    theNode.strOrigL = theNode.name.length();
    theNode.sqft = float(items[1]) * programMult;
    theNode.sqftMin = float(items[2]) * programMult;
    theNode.stories = float(items[14]);
    theNode.noiseAllow = noiseAllow;
    theNode.trafficRate = trafficRate;
    theNode.transparency = float(items[15]);
    theNode.physIdealI = float(items[5])/float(items[8]);
    theNode.physIdealO = float(items[6])/float(items[8]);
    theNode.physIdealP = float(items[7])/float(items[8]);
    if( (noiseAllow >= 3) ){    //connect to site
      if(i == 2){
        Node siteNode = myGraph.getSiteNodesByLevel(0)[13];
       // myGraph.connectNodes(theNode, siteNode, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
       // theNode.p.position().set(siteNode.x, siteNode.y, siteNode.z);
       // Node siteNodeNext = fx_ClosestNode(siteNode, myGraph.getSiteNodesByLevel(0));
       // myGraph.connectNodes(theNode, siteNodeNext, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
       // Node siteNodeNextNext = fx_NextClosestNode(siteNode, myGraph.getSiteNodesByLevel(0));
       // myGraph.connectNodes(theNode, siteNodeNextNext, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
        //theNode.p.makeFixed();
      }
      else{
        if( int(items[7]) >= 3 ){  //measure of publicness
          int level = round(random((5-theNode.noiseAllow)*2,(5-theNode.noiseAllow)*2+1));
          Node[] siteLevelNodes = myGraph.getSiteNodesByLevel(level);
          int index = floor(random(0,siteLevelNodes.length));
          //Node siteNode = siteLevelNodes[index];
          //myGraph.connectNodes(theNode, siteNode, sprStr*siteSprMult, sprLength/siteLengthMult);
          //Node siteNodeNext = fx_ClosestNode(siteNode, myGraph.getSiteNodesByLevel(level));
          //if(blnExtraSite) myGraph.connectNodes(theNode, siteNodeNext, sprStr*siteSprMult, sprLength/siteLengthMult);
        }
      }
    }
  }

  // BUILD INCUBATOR CONNECTIONS
  for(int i=2; i<records_I.length-1; i++){
    String[] items = split( records_I[i], ",");
    Node rootNode = myGraph.getNodeByName(items[0]);
    if(items[3].length() > 0){
      String[] links = split( items[3], "|");
      for(int j=0; j<links.length; j++){
        Node connectNode = myGraph.getNodeByName(links[j]);
        myGraph.connectNodes(connectNode, rootNode, sprStr, sprLength);
      } 
    }
  }

  // LOAD OFFICE
  String[] records_O = loadStrings("program_office.csv");
  for(int i=2; i<records_O.length-1; i++){
    String[] items = split( records_O[i], ",");
    float mass = float(items[1])/massScale;
    float crossover = float(items[4]);
    color clr_O = getColour("cyan");
    int noiseAllow = int(items[9]);
    int trafficRate = int(items[10]);
    Node theNode = myGraph.addNode(items[0], 1.0, random(width), random(height), random(height), clr_O, crossover, 2);
    theNode.strOrigL = theNode.name.length();
    theNode.sqft = float(items[1]) * programMult;
    theNode.sqftMin = float(items[2]) * programMult;
    theNode.stories = float(items[14]);
    theNode.noiseAllow = noiseAllow;
    theNode.trafficRate = trafficRate;
    theNode.transparency = float(items[15]);
    theNode.physIdealI = float(items[5])/float(items[8]);
    theNode.physIdealO = float(items[6])/float(items[8]);
    theNode.physIdealP = float(items[7])/float(items[8]);
    if( (noiseAllow >= 3) ){
      if(i == 2){
        Node siteNode = myGraph.getSiteNodesByLevel(0)[2];
        //myGraph.connectNodes(theNode, siteNode, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
        //theNode.p.position().set(siteNode.x, siteNode.y, siteNode.z);
        //Node siteNodeNext = fx_ClosestNode(siteNode, myGraph.getSiteNodesByLevel(0));
        //myGraph.connectNodes(theNode, siteNodeNext, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
        //Node siteNodeNextNext = fx_NextClosestNode(siteNode, myGraph.getSiteNodesByLevel(0));
        //myGraph.connectNodes(theNode, siteNodeNextNext, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
      }
      else{
        if( int(items[7]) >= 3 ){  //measure of publicness
          int level = round(random((5-theNode.noiseAllow)*2,(5-theNode.noiseAllow)*2+1));
          Node[] siteLevelNodes = myGraph.getSiteNodesByLevel(level);
          int index = floor(random(0,siteLevelNodes.length));
          Node siteNode = siteLevelNodes[index];
          //myGraph.connectNodes(theNode, siteNode, sprStr*siteSprMult, sprLength/siteLengthMult);
          //Node siteNodeNext = fx_ClosestNode(siteNode, myGraph.getSiteNodesByLevel(level));
          //if(blnExtraSite) myGraph.connectNodes(theNode, siteNodeNext, sprStr*siteSprMult, sprLength/siteLengthMult);
        }
      }
    }
  }
  // BUILD OFFICE CONNECTIONS
  for(int i=2; i<records_O.length-1; i++){
    String[] items = split( records_O[i], ",");
    Node rootNode = myGraph.getNodeByName(items[0]);
    if(items[3].length() > 0){
      String[] links = split( items[3], "|");
      for(int j=0; j<links.length; j++){
        Node connectNode = myGraph.getNodeByName(links[j]);
        myGraph.connectNodes(connectNode, rootNode, sprStr, sprLength);
      } 
    }
  }

  // LOAD PUBLIC
  String[] records_P = loadStrings("program_public.csv");
  for(int i=2; i<records_P.length-1; i++){
    String[] items = split( records_P[i], ",");
    float mass = float(items[1])/massScale;
    float crossover = float(items[4]);
    color clr_P = getColour("magenta");
    int noiseAllow = int(items[9]);
    int trafficRate = int(items[10]);
    Node theNode = myGraph.addNode(items[0], 1.0, random(width), random(height), random(height), clr_P, crossover, 3);
    theNode.strOrigL = theNode.name.length();
    theNode.sqft = float(items[1]) * programMult;
    theNode.sqftMin = float(items[2]) * programMult;
    theNode.stories = float(items[14]);
    theNode.noiseAllow = noiseAllow;
    theNode.trafficRate = trafficRate;
    theNode.transparency = float(items[15]);
    theNode.physIdealI = float(items[5])/float(items[8]);
    theNode.physIdealO = float(items[6])/float(items[8]);
    theNode.physIdealP = float(items[7])/float(items[8]);
    if( (noiseAllow >= 3) ){
      if(i == 2){
        Node siteNode = myGraph.getSiteNodesByLevel(0)[1];
        //myGraph.connectNodes(theNode, siteNode, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
        //theNode.p.position().set(siteNode.x, siteNode.y, siteNode.z);
        //Node siteNodeNext = fx_ClosestNode(siteNode, myGraph.getSiteNodesByLevel(0));
        //myGraph.connectNodes(theNode, siteNodeNext, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
        //Node siteNodeNextNext = fx_NextClosestNode(siteNode, myGraph.getSiteNodesByLevel(0));
        //myGraph.connectNodes(theNode, siteNodeNextNext, sprStr*siteSprMult*lobbyMult, sprLength/siteLengthMult/lobbyMult);
      }
      else{
        if( int(items[7]) >= 3 ){  //measure of publicness
          int level = round(random((5-theNode.noiseAllow)*2,(5-theNode.noiseAllow)*2+1));
          //Node[] siteLevelNodes = myGraph.getSiteNodesByLevel(level);
          //int index = floor(random(0,siteLevelNodes.length));
          //Node siteNode = siteLevelNodes[index];
          //myGraph.connectNodes(theNode, siteNode, sprStr*siteSprMult, sprLength/siteLengthMult);
          //Node siteNodeNext = fx_ClosestNode(siteNode, myGraph.getSiteNodesByLevel(level));
          //if(blnExtraSite) myGraph.connectNodes(theNode, siteNodeNext, sprStr*siteSprMult, sprLength/siteLengthMult);
        }
      }
    }
  }

  // BUILD PUBLIC CONNECTIONS
  for(int i=2; i<records_P.length-1; i++){
    String[] items = split( records_P[i], ",");
    Node rootNode = myGraph.getNodeByName(items[0]);
    if(items[3].length() > 0){
      String[] links = split( items[3], "|");
      for(int j=0; j<links.length; j++){
        Node connectNode = myGraph.getNodeByName(links[j]);
        myGraph.connectNodes(connectNode, rootNode, sprStr, sprLength);
      } 
    }
  }


  // CONSTRUCT SPRINGS BETWEEN PROGRAM TYPES
  for(int i=0; i<myGraph.nodes.length; i++){
    Node theNode = myGraph.nodes[i];
    if(theNode.type <= 3){
      for(int j=0; j<myGraph.nodes.length; j++){
        if(j != i){
          Node checkNode = myGraph.nodes[j];
          if( (theNode.type != checkNode.type) && (checkNode.type <= 3) ){
            if(theNode.crossover + checkNode.crossover >= crossThld){
              myGraph.connectNodes(theNode, checkNode, sprStr, sprLength);
            }
          }
        }
      }
    }

    // FORWARD THROUGH INITIAL SEQUENCE
    for(int t=0; t<2; t++){
      physics.tick(tick);
    }
  }

  blobNodes = new Node[0];
  buildHull = new Node[0];
  hullNetworks = new ArrayList();

}

void draw(){ 

  // UPDATE
  lights();
  background(90);
  physics.tick(tick);
  myGraph.update();

  if( frameCount == 1 ){
    myGraph.getNodeByName("Lobby(I)").p.makeFixed();
    myGraph.getNodeByName("Lobby(O)").p.makeFixed();
    myGraph.getNodeByName("Lobby(P)").p.makeFixed();
  }

  // CAMERA STUFF
  float eyeX = 0.0;
  float eyeY = 0.0;
  float eyeZ = 0.0;
  Node center = myGraph.getNodeByName("Lobby(O)");
    
  if( blnCamera == true ){
    if( blnRotate == true ) {
      trackRotH += 0.30;
    }
    trackRotH -= camRotX*10;
    trackRotV += camRotY;
    eyeX =  sin(radians(trackRotH+camRotX))*camLen;
    eyeY =  cos(radians(trackRotH+camRotX))*camLen;
    eyeZ =  camLen*0.65 + trackRotV;
    camera(eyeX+center.x, eyeY+center.y, eyeZ+center.z, center.x, center.y, center.z, 0,0,-1);
  }
  PVector camPos = new PVector(eyeX, eyeY, eyeZ);
  
  pushMatrix();
translate(center.x, center.y,0);
grid();
popMatrix();

  // EXPLODE NODES
  if( (blnExplode == true) ){
    // get biggest node that has enough sqft to explode
    Node[] selectNodes = myGraph.getProgNodes();
    explodeNode = fx_BiggestNode(selectNodes);
    if(explodeNode != null){
      explodeNode.blnExplodable = false;
      explodedNodes = myGraph.explodeNode(explodeNode, sprStr, sprLength);
      if( explodedNodes != null ){
        //println("[x" + cExplode + "] " + explodeNode.name + " chosen @ f" + frameCount + " r" + round(frameRate));
        cExplode++;
      }
    }
  }


  // LET EXPLODE FOR A BIT FIRST THEN PLAY ANIMATION
  if( frameCount == 15 ){
    blnExplode = false;
  }


  // BUILD HULLS
  float touchThresh = 25; 
  PVector blobCenter = new PVector(mouseX, mouseY);

  if( blnHull == true ){
    // FIND CLOSEST NODE TO CAM WITHIN CLICK THRESHOLD
    Node[] collectNodes = new Node[0];
    for(int j=0; j<myGraph.nodes.length; j++){
      Node checkNode = myGraph.nodes[j];
      if( checkNode.type <= 3 ){
        PVector checkPV = checkNode.pv;
        float sx = screenX(checkPV.x, checkPV.y, checkPV.z);
        float sy = screenY(checkPV.x, checkPV.y, checkPV.z);
        PVector screenPoint = new PVector(sx,sy);
        if( screenPoint.dist(blobCenter) < touchThresh ){
          collectNodes = (Node[]) append(collectNodes, checkNode);
        }
      }
    }
    Node closeNode = fx_ClosestNodeToPV(camPos, collectNodes);
    // HULL NODES
    if( closeNode != null ){
      closeNode.activeHull =! closeNode.activeHull;
      if( closeNode.activeHull == true ){  //add node to network building hull
        buildHull = (Node[]) append(buildHull, closeNode);
        if( buildHull.length == 4 ){
          Network addNetwork = new Network(buildHull);
          hullNetworks.add(addNetwork);
          buildHull = new Node[0];
        }
      }
      else {  //remove node from network building hull or destroy hull
        int index = -1;
        for(int k=0; k<buildHull.length; k++){
          if( buildHull[k] == closeNode )  index = k;
        }
        if( index > -1 ){
          if(index < buildHull.length - 1){
            buildHull[index] = buildHull[ buildHull.length-1 ];
          }
          buildHull = (Node[]) shorten(buildHull);
        }
        if( hullNetworks.size() > 0 ){
          index = -1;
          for(int k=0; k<hullNetworks.size(); k++){
            Network theNetwork = (Network) hullNetworks.get(k);
            for(int m=0; m<theNetwork.arrNodes.length; m++){
              if( theNetwork.arrNodes[m] == closeNode ){
                index = k;
              }
            }
          }
          if( index > -1 ){
            Network deactivateNetwork = (Network) hullNetworks.get(index);
            for(int m=0; m<deactivateNetwork.arrNodes.length; m++){
              deactivateNetwork.arrNodes[m].activeHull = false;
            }
            hullNetworks.remove(index);
          }
        }
      }
    }
    blnHull = false;
  }


  // MAKE HULLS
  if( hullNetworks != null ){
    for(int i=0; i<hullNetworks.size(); i++){
      Network theNetwork = (Network) hullNetworks.get(i);
      int T = round(theNetwork.avgTransparency);
      PVector[] arrPVects = fx_GetBBoxPVects(theNetwork.arrNodes);
      ConvexHull3D newHull = new ConvexHull3D(arrPVects);
      noStroke();
      fill(theNetwork.clr);
      newHull.plot();
    }
  }

  // PLOT3D CONNECTIONS
  stroke(30, 50);
  strokeWeight(1);
  if(blnLines == true){
    myGraph.plot3D_Connections(1);
  }

  //PLOT3D NODES
  noStroke();
  for(int i=0; i<myGraph.getProgNodes().length; i++){
    Node plotNode = myGraph.getProgNodes()[i];
    plotNode.plot3D_Nodes(1);
  }


  // DRAW SITE LINES
  fill(0,50);
  stroke(0,50);
  strokeWeight(1);
  for(int i=0; i<sitePts.length-1; i++){
    //if(i==52) i++;
    PVector p1 = sitePts[i];
    PVector p2 = sitePts[i+1];
    //line(p1.x, p1.y, siteCentre.z, p2.x, p2.y, siteCentre.z);
  }
  PVector p1 = sitePts[sitePts.length-1];
  PVector p2 = sitePts[0];
  line(p1.x, p1.y, siteCentre.z, p2.x, p2.y, siteCentre.z);

  // DRAW RAIL LINES
  fill(0,50);
  stroke(0,50);
  strokeWeight(1);
  for(int i=5; i<railPts.length-6; i++){
    if( i == 40 ) i = 57;
    if( i == 47 ) i++;
    PVector p3 = railPts[i];
    PVector p4 = railPts[i+1];
    //line(p3.x, p3.y, p3.z, p4.x, p4.y, p4.z);
  }

  // DRAW SITE PTS
  fill(0,25);
  noStroke();
  for(int i=0; i<sitePtsEnv.length; i++){
    PVector pv = sitePtsEnv[i];
    pushMatrix();
    translate(pv.x, pv.y, pv.z);
   // box(2);
    popMatrix();
  }

  camera();
  fill(100,90);
  noStroke();
  ellipse(blobCenter.x, blobCenter.y, 50, 50);

}



void grid(){
    // GRID
  stroke(160);
  for(int i=-200; i<=200; i+=25){
    for(int j=-200; j<=200; j+=25){
      line(-200, j, 200, j);
      line(i, -200, i, 200);
    } 
  }
  stroke(120);
  for(int i=-200; i<=200; i+=50){
    for(int j=-200; j<=200; j+=50){
      line(-200, j, 200, j);
      line(i, -200, i, 200);
    } 
  }

  stroke(80);
  strokeWeight(2);
  noFill();
  rect(-200,-200,400,400);
  line(-200,0,200,0);
  line(0,-200,0,200);
  strokeWeight(1);

}