import traer.physics.*;

class Node {
  // PROPERTIES
  String name;
  float x, y, z, mass, sqft, sqftMin, crossover;
  float stories = 1.0;
  float side, transparency;
  PVector pv;
  PVector[] bBox;
  float physIdealI, physIdealO, physIdealP;
  float physRatioI, physRatioO, physRatioP;
  int type;  // 1 = I, 2 = O, 3 = P, 4 = site, 5 = rail, 6 = kink
  int level; // for site nodes
  int reach, strOrigL, numSplit, total;  
  int noiseAllow, trafficRate;
  color clr, clrPhys;
  Node[] connections;
  int numConnI, numConnO, numConnP, numConnTotal;
  boolean textOn = false;
  boolean titleOn = true;
  boolean blnExplodable = true;
  boolean activeHull = false;
  // particle system stuff
  ParticleSystem physics;
  Particle p;
  Spring[] springs;
  Attraction[] attractions;

  // CONSTRUCTOR
  Node(String _name, float _mass, float _x, float _y, float _z, ParticleSystem _physics, Node[] _others, color _clr, float _crossover, int _type){
    name = _name;
    mass = _mass;
    x = _x;
    y = _y;
    z = _z;
    pv = new PVector(x,y,z);
    clr = _clr;
    reach = 0;
    crossover = _crossover;
    type = _type;
    numSplit = 0;
    total = 1;
    bBox = new PVector[8];

    physics = _physics;
    connections = new Node[0];
    springs = new Spring[0];
    attractions = new Attraction[0];
    p = physics.makeParticle(mass, x, y, z);	//makeParticle(float mass, float x, float y, float z)
    for(int i=0; i<_others.length; i++){
      if( p != _others[i].p){
        Attraction a = physics.makeAttraction( p,_others[i].p, attrStr, attrLength);
        Attraction b = physics.makeAttraction( _others[i].p, p, attrStr, attrLength);
        attractions = (Attraction[]) append(attractions, a);
        _others[i].attractions = (Attraction[]) append(_others[i].attractions, b);
      }
    }
  }

  // METHODS
  void fix(){
    p.makeFixed();
  }

  void connect(Node a, float _strength, float _restLength, boolean _on){
    connections = (Node[]) append(connections, a);
    Spring theSpring = physics.makeSpring(this.p, a.p, _strength, _strength, _restLength);
    springs = (Spring[]) append(springs, theSpring);
    if(!_on){
      theSpring.turnOff(); 
    }
  }

  Node[] getProgConnections(){
    Node[] progConnections = new Node[0];
    for(int i=0; i<connections.length; i++){
      Node otherNode = connections[i];
      if( otherNode.type <= 3 ){
        progConnections = (Node[]) append(progConnections, otherNode);
      }
    }
    return progConnections;
  }

  float getIdealRatio(int indicator){
    float idealRatio = 0;
    if(indicator == 1){
      idealRatio = this.physIdealI;
    } 
    else if(indicator == 2){
      idealRatio = this.physIdealO;
    } 
    else if(indicator == 3){
      idealRatio = this.physIdealP;
    }
    return idealRatio;
  }

  float getPhysRatio(int indicator){
    float physSqft = 0;
    Node[] progConnections = new Node[0];
    for(int i=0; i<connections.length; i++){
      Node a = connections[i];
      if( a.type == indicator ){
        physSqft += a.sqft;
      }
      if( a.type <= 3 ){
        progConnections = (Node[]) append(progConnections, a);
      }
    }
    float physRatio = physSqft/fx_TotalSqft(progConnections);
    return physRatio;
  }

  color getFillClr(){
    float hueValue = this.getPhysRatio(1)*hue(getColour("orange")) + this.getPhysRatio(2)*hue(getColour("cyan")) + this.getPhysRatio(3)*hue(getColour("magenta"));
    color fillClr = color(hueValue, 50, 100, 100);
    return fillClr;
  }

  ArrayList recursiveReach(int currentGeneration, Node _root, Node _parent, Network _currPath, ArrayList allPaths){
    ArrayList rtrnPaths;
    if( currentGeneration < maxGenerations ){
      for(int i=0; i<floor(this.getProgConnections().length/8); i++){
        //for(int i=0; i<this.getProgConnections().length; i++){
        Node theNode = this.getProgConnections()[floor(random(this.getProgConnections().length))];
        //Node theNode = this.getProgConnections()[i];
        if( theNode != _parent ){
          if( (theNode.type <= 3) ){//&& (theNode.type != _parent.type) )
            if( (fx_Dist(_parent,theNode) <= reachDist) && (theNode == _root) ){ //path has looped
              _currPath.blnLoop = true;
            }
            else if( (fx_Dist(_parent,theNode) <= reachDist) && (theNode != _root) ){ //continue reaching
              Network newPath = new Network(_currPath.arrNodes);
              newPath.addNode(theNode);
              allPaths.add(newPath);
              if( (i == this.connections.length - 1) ){
                int index = allPaths.indexOf(_currPath);
                if( index >= 0 ) allPaths.remove(index);
              }
              rtrnPaths = theNode.recursiveReach( currentGeneration + 1, _root, this, newPath, allPaths );
            }
          }
        }
      }
    }
    return allPaths;
  }

  void plot3D_Connections(float sc){
    for(int i=0; i<connections.length; i++){
      otherNode = connections[i];
      line(x,y,z, connections[i].x, connections[i].y, connections[i].z);
    }
  }

  void plot3D_Nodes(float sc){
    // draw boxes
    if(blnBoxes == true){
      noStroke();
      fill(this.getFillClr());
      pushMatrix();
      translate(x, y, z+progHeight*stories/2);
      box(side/2, side/2, progHeight*stories/2);
      popMatrix();
    }
    if( (this.activeHull == true) ){
      stroke(100);
      strokeCap(ROUND);
      strokeWeight(6);
      fill(100);
      pushMatrix();
      translate(x, y, z+progHeight*stories/2);
      box(side, side, progHeight*stories);
      popMatrix();
    }
    // plot text
    float sx = screenX(x, y, z);
    float sy = screenY(x, y, z);
    if( (blnNames == true) && (this.type < 4) ){
    }
  }

  void updateBBox(){
    this.pv = new PVector(this.x, this.y, this.z);

    float rndAmnt = 0.001;
    PVector pvAdd = new PVector(side/2, side/2);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[0] = PVector.add(pvAdd, this.pv);
    pvAdd = new PVector(-side/2, side/2);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[1] = PVector.add(pvAdd, this.pv);
    pvAdd = new PVector(-side/2, -side/2);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[2] = PVector.add(pvAdd, this.pv);
    pvAdd = new PVector(side/2, -side/2);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[3] = PVector.add(pvAdd, this.pv);

    pvAdd = new PVector(side/2, side/2, progHeight*stories);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[4] = PVector.add(pvAdd, this.pv);
    pvAdd = new PVector(-side/2, side/2, progHeight*stories);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[5] = PVector.add(pvAdd, this.pv);
    pvAdd = new PVector(-side/2, -side/2, progHeight*stories);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[6] = PVector.add(pvAdd, this.pv);
    pvAdd = new PVector(side/2, -side/2, progHeight*stories);
    pvAdd.mult(random(1-rndAmnt, 1+rndAmnt));
    bBox[7] = PVector.add(pvAdd, this.pv);
  }

  void avoid(){
    for(int i=0; i<myGraph.nodes.length; i++){
      Node checkNode = myGraph.nodes[i];
      if( (checkNode != this) && (checkNode.type <= 3) ){
        PVector pvBetween = PVector.sub(this.pv, checkNode.pv);
        if(abs(pvBetween.x) < (this.side/2 + checkNode.side/2)){
          if(abs(pvBetween.y) < (this.side/2 + checkNode.side/2)){
            if(abs(pvBetween.z) < (progHeight*this.stories/2 + progHeight*checkNode.stories/2)){
              pvBetween.normalize();
              pvBetween.mult(1);
              this.p.position().add(pvBetween.x, pvBetween.y, pvBetween.z);
            }
          }
        }
      }
    }
    this.pv.x = p.position().x();
    this.pv.y = p.position().y();
    this.pv.z = p.position().z();
  }

  void constrainToSite(){
    PVector pvCentre = new PVector();
    for(int i=0; i<sitePts.length; i++){
      pvCentre.add(sitePts[i]);
    }
    pvCentre.div(sitePts.length);
    PVector pvCentreToThis = PVector.sub(this.pv, pvCentre);
    PVector pvBrepClosest = fx_ClosestPtToLine(pvCentreToThis, sitePts);
    PVector pvCentreToBrep = PVector.sub(pvBrepClosest, pvCentre);
    if(pvCentreToThis.mag() > pvCentreToBrep.mag()){
      PVector pvMove = PVector.sub(pvCentreToBrep, pvCentreToThis);
      pvMove.normalize();
      pvMove.mult(4);
      this.p.position().add(pvMove.x, pvMove.y, 0);
    }
  }

  void avoidTrain(){
    PVector pvCentre = new PVector();
    for(int i=0; i<sitePtsTrain.length; i++){
      pvCentre.add(sitePtsTrain[i]);
    }
    pvCentre.div(sitePtsTrain.length);
    PVector pvCentreToThis = PVector.sub(this.pv, pvCentre);
    PVector pvBrepClosest = fx_ClosestPtToLine(pvCentreToThis, sitePtsTrain);
    PVector pvCentreToBrep = PVector.sub(pvBrepClosest, pvCentre);
    if( (pvCentreToThis.mag() < pvCentreToBrep.mag()) && (this.z < 3*progHeight) ){
      this.p.position().set(this.p.position().x(), this.p.position().y(), 3*progHeight);
    }
  }

  void update(){
    side = pow(sqft, 0.5);
    // SNAP TO GRID
    if( (this.type <= 3) || (this.type == 6) ){
      if( this.p.position().z() > 75 ){               //PUSH DOWN
        this.p.position().add(0, 0, -2);
      }
      if( this.p.position().z() > 0 ){                 //SQUISH ALL
        this.p.position().add(0, 0, squashPVect);
      }
      if( this.p.position().z() < siteCentre.z ){      //PUSH ABOVE GROUND
        this.p.position().set(this.p.position().x(), this.p.position().y(), siteCentre.z);
      }
      // CONSTRAINTS
      if( (frameCount>60) && (this.p.isFree()) ){
        //this.constrainToSite();
        //this.avoidTrain();
        this.avoid();
      }
      if( this.name.equals("Lobby(I)") || this.name.equals("Lobby(O)") || this.name.equals("Lobby(P)") ){
        this.p.position().set(this.p.position().x(), this.p.position().y(), siteCentre.z);
      }
      // UPDATE PVECT
      this.pv.x = p.position().x();
      this.pv.y = p.position().y();
      this.pv.z = p.position().z();
      x = this.p.position().x();
      y = this.p.position().y();
      z = this.p.position().z();
      // MAKE BBOX AND STRUCTURE
      this.updateBBox();
    }
    // update physRatios
    for(int i=0; i<this.connections.length; i++){
      Node a = connections[i];
      if(a.type == 1){
        this.physRatioI += a.sqft;
      } 
      else if(a.type == 2){
        this.physRatioO += a.sqft;
      }
      else if(a.type == 3){
        this.physRatioP += a.sqft;
      }
    }
    // update total
    this.total = 1;
    for(int i=0; i<connections.length; i++){
      Node otherNode = connections[i];
      if( otherNode.name.substring(0,otherNode.strOrigL).equalsIgnoreCase(this.name.substring(0,this.strOrigL)) ){
        this.total++;
      }
    }
  }

}