/* ----------------------------------------------
Computing Kaizen Studio
Advanced Studio VI Spring 2010
Columbia University GSAPP

Subdividing Bodies
Code by Nikolas Stutzin
http://www.arch.columbia.edu/
http://proxyarch.com/kaizen

This work is licensed under a Creative Commons 
Attribution-Noncommercial-Share Alike 3.0 License
-----------------------------------------------*/

class Graph {

  //PROPERTIES
  Node[] nodes;
  ParticleSystem physics;

  //CONSTRUCTOR
  Graph(ParticleSystem _physics){
    physics = _physics;
    nodes = new Node[0];
  }

  //METHOD 1
  Node addNode(String name, float mass, float _x, float _y, float _z, float _sm, int _tree, float _offsetZ){
    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, _sm, _tree, _offsetZ);
    nodes = (Node[]) append( nodes, newNode);
    return newNode;
  }

  //METHOD 2
  Node addNode(String name, float mass, float _sm, int _tree, float _offsetZ){
    Node a = this.addNode( name, mass, random(width), random(height), random(height) , _sm, _tree, random(0,0.1));
    return a;
  }

  //METHOD 3
  Node addLeaf(String name, Node _root,  float _mass, float _strength, float _restLength, float _sm, int _tree, float _offsetZ){
    Node theLeaf = this.addNode(name, _mass, _sm, _tree, _offsetZ);
    this.connectNodes(theLeaf, _root, _strength, _restLength);
    return theLeaf;
  }

  //METHOD 4
  Node addLeaf(String name, Node _root, float _sm, int _tree, float _offsetZ){
    Node theLeaf = this.addLeaf( name, _root, 1.0, .1, 100, _sm, _tree, _offsetZ);
    return theLeaf;
  }

  Node[] getNodes(){
    return nodes; 
  }

  //METHOD 5
  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);
    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);
      }
    }
  }
  
  //METHOD 6
  void connectNodes(Node a, Node b, float _strength, float _restLength){
    if(! a.name.equalsIgnoreCase(b.name)){
      a.connect(b, _strength, _restLength, true);
      b.connect(a, _strength, _restLength, false);  //don't double connect
    }
  }

  //METHOD 7
  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;
  }

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

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