import traer.physics.*;

class Graph {
  // PROPERTIES
  Node[] nodes;
  ParticleSystem physics;
  String name;

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

  // METHODS
  Node addNode(String name, float mass, float _x, float _y, float _z, color _clr, float _crossover, int _type){
    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, _clr, _crossover, _type);
    nodes = (Node[]) append( nodes, newNode);
    return newNode;
  }

  Node addNode(String name, float mass, color _clr, float _crossover, int _type){
    name = name.trim();
    for(int i=0; i<nodes.length; i++){
      if( nodes[i].name.equalsIgnoreCase(name) ){
        return nodes[i];
      }
    }
    Node a = this.addNode( name, mass, random(-1,1), random(-1,1), random(-1,1), _clr, _crossover, _type);
    nodes = (Node[]) append( nodes, a);
    return a;
  }

  Node addLeaf(String name, Node _root,  float _mass, float _x, float _y, float _z, float _strength, float _restLength, color _clr, float _crossover, int _type){
    Node theLeaf = this.addNode(name, _mass, _x, _y, _z, _clr, _crossover, _type);
    this.connectNodes(theLeaf, _root, _strength, _restLength);
    return theLeaf;
  }

  Node addLeaf(String name, Node _root,  float _mass, float _strength, float _restLength, color _clr, float _crossover, int _type){
    Node theLeaf = this.addNode(name, _mass, _clr, _crossover, _type);
    this.connectNodes(theLeaf, _root, _strength, _restLength);
    return theLeaf;
  }

  Node addLeaf(String name, Node _root, color _clr, float _crossover, int _type){
    Node theLeaf = this.addLeaf( name, _root, 1.0, sprStr, sprLength, _clr, _crossover, _type);
    return theLeaf;
  }

  Node[] getNodes(){
    return nodes; 
  }

  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);
      }
    }
  }


  Node[] explodeNode(Node _node, float _strength, float _restLength){
    Node[] connections = _node.connections;
    Node[] connectionsExt = new Node[0];
    Node[] connectionsProg = new Node[0];
    Node[] newNodes = new Node[0];
    Node smallNode = null;
    Node bigNode = null;
    // find node with biggest diff between actual and ideal ratio
    Node otherNode = null;
    float maxDiffPhysRatio = 0;
    for(int i=0; i<connections.length; i++){
      Node checkNode = connections[i];
      if(checkNode.type <= 3){
        connectionsProg = (Node[]) append(connectionsProg, checkNode);
      }
      if( (_node.type != checkNode.type) && (checkNode.type <= 4) ){
        connectionsExt = (Node[]) append(connectionsExt, checkNode);
        float diffRatio = checkNode.getIdealRatio(_node.type) - checkNode.getPhysRatio(_node.type);
        if((diffRatio >= maxDiffPhysRatio) && (fx_Dist(_node, checkNode) <= 1000000) && (checkNode.type <= 3) ){
          otherNode = checkNode;
          maxDiffPhysRatio = diffRatio;
        }
      }
    }
    if( (otherNode == null) && (_node.getProgConnections().length > 0) ){
      otherNode = _node.getProgConnections()[floor(random(_node.getProgConnections().length))];
    }
    // if node has external connections
    if( (_node.sqft >= otherNode.sqft) && (_node.sqft >= _node.sqftMin*2) ){
      // determine properties for new nodes
      float sqftSmall = max( (otherNode.sqft / fx_TotalSqft(connectionsProg) ) * _node.sqft, _node.sqftMin);
      float sqftBig = _node.sqft - sqftSmall;
      float newCrossover = (_node.crossover + otherNode.crossover)/2;
      color newClr = color((hue(_node.clr)+hue(otherNode.clr))/2, 100, 100, 50);
      // make baby nodes
      for(int i=0; i<2; i++){
        String newName;
        if(_node.total == 1){
          newName = _node.name + "_" + c;
        } 
        else {
          newName = _node.name.substring(0,_node.strOrigL)+ "_" + c;
        }
        c++;
        if(i == 0){
          float x = (_node.x + otherNode.x)/2;
          float y = (_node.y + otherNode.y)/2;
          float z = (_node.z + otherNode.z)/2;
          smallNode = this.addNode(newName, 1.0, x,y,z, _node.clr, newCrossover, _node.type); 
          // define new properties
          smallNode.sqft = sqftSmall;
          smallNode.sqftMin = _node.sqftMin;
          smallNode.noiseAllow = (_node.noiseAllow + otherNode.noiseAllow) / 2;
          smallNode.trafficRate = (_node.trafficRate + otherNode.trafficRate) / 2;
          smallNode.transparency = _node.transparency;
          smallNode.numSplit = _node.numSplit + 1;
          smallNode.strOrigL = _node.strOrigL;
          nodes = (Node[]) append(nodes, smallNode);
          newNodes = (Node[]) append(newNodes, smallNode);
        }
        else {
          float x = (_node.x);
          float y = (_node.y);
          float z = (_node.z);
          bigNode = this.addNode(newName, 1.0, x,y,z, _node.clr, _node.crossover, _node.type); 
          // define new properties
          bigNode.sqft = sqftBig;
          bigNode.sqftMin = _node.sqftMin;
          bigNode.noiseAllow = _node.noiseAllow;
          bigNode.trafficRate = _node.trafficRate;
          bigNode.transparency = _node.transparency;
          bigNode.numSplit = _node.numSplit + 1;
          bigNode.strOrigL = _node.strOrigL;
          if( _node.p.isFixed() )  bigNode.p.makeFixed();
          nodes = (Node[]) append(nodes, bigNode);
          newNodes = (Node[]) append(newNodes, bigNode);
        }
      }
      if( (smallNode != null) && (bigNode != null) ){
        // connect smallNode and bigNode
        this.connectNodes(smallNode, bigNode, _strength, _restLength);
        // connect smallNodes to originals
        for(int i=0; i<_node.getProgConnections().length; i++){
          Node origNode = _node.getProgConnections()[i];
          if(origNode.type == newNodes[i%2].type){
            this.connectNodes(newNodes[i%2], origNode, _strength, _restLength);
          }
        }
        // connect new nodes to external connections
        this.connectNodes(smallNode, otherNode, _strength, _restLength);
        this.connectNodes(bigNode, otherNode, _strength, _restLength);
        boolean blnSiteConnect = false;
        for(int i=0; i<connectionsExt.length; i++){
          Node extNode = connectionsExt[i];
          if( (extNode.type == 4) && (blnSiteConnect == false) ){
            this.connectNodes(bigNode, extNode, sprStr*siteSprMult, sprLength/siteLengthMult);    //connect to site
            int level = min(round(random((5-smallNode.noiseAllow)*2,(5-smallNode.noiseAllow)*2+1)), 5);
            Node[] siteLevelNodes = myGraph.getSiteNodesByLevel(level);
            int index = floor(random(0,siteLevelNodes.length));
            Node rndSite = siteLevelNodes[index];
            this.connectNodes(smallNode, rndSite, sprStr*siteSprMult, sprLength/siteLengthMult);
            Node siteNodeNext = fx_ClosestNode(rndSite, myGraph.getSiteNodesByLevel(level));
            if(blnExtraSite) this.connectNodes(smallNode, siteNodeNext, sprStr*siteSprMult, sprLength/siteLengthMult);
            blnSiteConnect = true;
          }
          else{
            this.connectNodes(newNodes[i%2], extNode, _strength, _restLength);
          }
        }
        // connect new nodes to extraNode connected to otherNode
        for(int i=0; i<newNodes.length; i++){
          int bcount = 0;
          Node extraNode = otherNode.getProgConnections()[floor(random(otherNode.getProgConnections().length))];
          while( (extraNode == null) || (extraNode.crossover < 1) ){
            extraNode = otherNode.getProgConnections()[floor(random(otherNode.getProgConnections().length))];
            if( (extraNode.type == smallNode.type) ) extraNode = null;
            bcount++;
            if( bcount == 20 ){
              extraNode = this.getProgNodes()[floor(random(this.getProgNodes().length))];
              if( extraNode.type == smallNode.type )  extraNode = null;
              break;
            }
          }
          if( extraNode != null )  this.connectNodes(newNodes[i%2], extraNode, _strength, _restLength);
        }
        // remove original node
        this.removeNode(_node);
      }
    }
    newNodes = (Node[]) append(newNodes, otherNode);
    return newNodes;
  }

  void connectNodes(Node a, Node b, float _strength, float _restLength){
    float rL = (a.side + b.side)/2;
    if(! a.name.equalsIgnoreCase(b.name)){
      a.connect(b, _strength, max(a.side+b.side, rL * fx_NoiseMult(a, b) * fx_TrafficMult(a, b)), true);
      b.connect(a, _strength, max(a.side+b.side, rL * fx_NoiseMult(a, b) * fx_TrafficMult(a, b)), false);  //dont double connect
    }
  }

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

  Node[] getNodesByType(int _type){
    Node[] arrNodes = new Node[0];
    for(int i=0; i<nodes.length; i++){
      Node checkNode = nodes[i];
      if(checkNode.type == _type){
        arrNodes = (Node[]) append(arrNodes, checkNode);
      }
    }
    return arrNodes;
  }

  Node[] getSiteNodesByLevel(int _level){
    Node[] arrNodes = new Node[0];
    for(int i=0; i<nodes.length; i++){
      Node checkNode = nodes[i];
      if( (checkNode.type == 4) && (checkNode.level == _level) ){
        arrNodes = (Node[]) append(arrNodes, checkNode);
      }
    }
    return arrNodes;
  }

  Node[] getProgNodes(){
    Node[] progNodes = new Node[0];
    progNodes = (Node[]) concat(progNodes, this.getNodesByType(1));
    progNodes = (Node[]) concat(progNodes, this.getNodesByType(2));
    progNodes = (Node[]) concat(progNodes, this.getNodesByType(3));
    return progNodes;
  }

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

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

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