class Graph {
  Node[] nodes;
  Spring[] springs;
  ParticleSystem physics;
  PFont myFont;

  Graph(ParticleSystem _physics){
    physics = _physics;
    nodes = new Node[0];
    springs = new Spring[0];
    myFont = createFont("Arial", 10);
  }

  Node addNode(String name, float mass, float _x, float _y, float _z){
    name = name.trim();
    for(int i=0; i<nodes.length; i++){
      if( nodes[i].name.equalsIgnoreCase(name) ){
        return nodes[i];
      }
    }
    Node newNode = new Node( name, mass, _x, _y, _z, physics);
    nodes = (Node[]) append( nodes, newNode);
    return newNode;
  }

  Node addNode(String name, float mass){
    Node a = this.addNode( name, mass, random(-1,1), random(-1,1), random(-1,1) );
    return a;
  }

  Node addLeaf(String name, Node _root,  float _mass, float _x, float _y, float _z){
    Node theLeaf = this.addNode(name, _mass, _x, _y, _z);
    Spring s = this.connectNodes(theLeaf, _root);
    springs = (Spring[]) append( springs, s);
    return theLeaf;
  }

  Node[] getNodes(){
    return nodes; 
  }
  
  Spring[] getSprings(){
   return springs; 
  }

  void removeNode(Node n){
    for(int i=0; i<n.connections.length; i++){

      // get springs + connections back to self from others and delete
      Node theLeaf = n.connections[i];
      for( int j=0; j<theLeaf.connections.length; j++){
        Node theNextLeaf = theLeaf.connections[j]; 
        if( theNextLeaf == n){      
          // remove from Traer
          physics.removeSpring( theLeaf.springs[j] );

          // remove spring reference from "springs" var
          if(j < theLeaf.springs.length-1){
            theLeaf.springs[j] = theLeaf.springs[ theLeaf.springs.length-1  ];
          }
          theLeaf.springs = (Spring[]) shorten(theLeaf.springs);

          // remove connection from connections list
          if(j < theLeaf.connections.length-1){
            theLeaf.connections[j] = theLeaf.connections[ theLeaf.connections.length-1  ];
          }
          theLeaf.connections = (Node[]) shorten(theLeaf.connections);
        }
      }
    }

    // go through all nodes, deleting attractions to node
    for(int i=0; i<nodes.length; i++){
      Node theNode = nodes[i];
      for(int j=0; j<theNode.attractions.length; j++){
        Particle a = theNode.attractions[j].getOneEnd(); 
        Particle b =  theNode.attractions[j].getTheOtherEnd();
        if(( a == n.p ) || (b ==n.p)){

          // remove attractions from connections list
          physics.removeAttraction( theNode.attractions[j] );
          if(j < theNode.attractions.length-1){
            theNode.attractions[j] = theNode.attractions[ theNode.attractions.length-1  ];
          }
          theNode.attractions = (Attraction[]) shorten(theNode.attractions);
        }  
      }
    }

    // remove traer springs from local
    for(int i=0; i<n.springs.length; i++){
      physics.removeSpring( n.springs[i] );
    }

    // remove particle
    physics.removeParticle(n.p);

    // remove node from graph var "nodes"
    for(int i=0; i<nodes.length; i++){
      if(n == nodes[i]){
        if(i<nodes.length - 1){
          nodes[i] = nodes[ nodes.length-1];
        }
        nodes = (Node[]) shorten(nodes);
      }
    }
  }

  Spring connectNodes(Node a, Node b){
    Spring s;
    if(! a.name.equalsIgnoreCase(b.name)){
      s = a.connect(b, true);
      b.connect(a, false);  //dont double connect
    }else{
     s = null; 
    }
    return s;
  }

  Node getNodeByName(String name){
    name = name.trim();
    for( int i=0; i<nodes.length; i++){
      if(nodes[i].name.equalsIgnoreCase(name)){
        return nodes[i];
      }
    }
    return null;
  }

  void update(){
    for(int i=0; i<nodes.length; i++){
      nodes[i].update();
    }
  }

  
  void plot3D(float _scale){
    for(int i=0; i<nodes.length; i++){
      nodes[i].plot3D(_scale);
    }
  }
}