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

Inverting Bodies
Code by Paige Mader
http://www.arch.columbia.edu/
http://proxyarch.com/kaizen

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

import traer.physics.*;

class Node {

  float x,y,z,mass;
  String name;
  Node[] connections;
  color clr;
  int reach, depth, numLinks;
  boolean checked;
  ParticleSystem physics;
  Particle p;
  Spring[] springs;
  Attraction[] attractions;
  int deep;
  int id;
  PVector pos;

  Node(String _name, float _mass, float _x, float _y, float _z, ParticleSystem _physics, Node[] _others){
    id = 0;
    reach = 0;
    deep = 200;
    depth = 0;
    numLinks = 0;
    checked = false;
    x = _x;
    y = _y;
    z = _z;
    mass = _mass;
    name = _name;
    connections = new Node[0];
    pos = new PVector(x,y,z);
    
    physics = _physics;
    connections = new Node[0];
    springs = new Spring[0];
    attractions = new Attraction[0];
    p = physics.makeParticle(mass, x, y, z);	
    for(int i=0; i<_others.length; i++){
      if( p != _others[i].p){
        Attraction a = physics.makeAttraction( p,_others[i].p, attStrength, attMinDist );
        Attraction b = physics.makeAttraction( _others[i].p, p, attStrength, attMinDist );
        attractions = (Attraction[]) append(attractions, a);
        _others[i].attractions = (Attraction[]) append(_others[i].attractions, b);
      }
    }
  }

  void calcLinks(){
    numLinks = connections.length;
  }

  int recursiveReach( int maxGenerations, int currentGeneration, float lineWidth, Node _parent){
    int childCount = 1;

    if(_parent != null){
      strokeWeight(lineWidth);
      line(x, y, z, _parent.x, _parent.y, _parent.z);
    }
    if( currentGeneration < maxGenerations){
      for(int i=0; i<connections.length; i++){
        Node theNode = connections[i];
        if(theNode != _parent){
          childCount += theNode.recursiveReach( maxGenerations, currentGeneration + 1, lineWidth/2.0, this );
        }
      }
    }
    strokeWeight(1.0);
    return childCount;
  }

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

  Node[] getConnections(){
    return connections; 
  }

  void plot3D(float sc){

    float cScale = max( .5, min(4, deep *.5));
    textMode(SCREEN);
    textAlign(LEFT);
    float sx = screenX(x, y, z);
    float sy = screenY(x, y, z);
    fill(255,0,255);

    strokeWeight(2);
    stroke(0);
    for(int j=0; j<connections.length; j++){
      line(x,y,-10,connections[j].x, connections[j].y, -10);
    }
    noStroke();
    pushMatrix();
    fill(0);
    translate(x,y,-10);
    ellipse(0,0,2,2);
    popMatrix();
    float vAmount =.5;
    
    float sca = 2;
    for(int i=0; i<connections.length; i++){
      if(id<connections[i].id){

        if(abs(connections[i].deep-deep) == 1){
          stroke(255);

          fill(min(255,(deep+connections[i].deep)/2.0*50),255,255);
          PVector v = new PVector(connections[i].x, connections[i].y, sq(connections[i].deep*vAmount));
          PVector s = new PVector(x,y, sq(deep*vAmount));
          v.sub(x,y,sq(deep*vAmount));

          int start = 0;
          char c = name.charAt(0);
          if (c == 'S'){
            start = 0;
          }

          if (c == 'C'){
            start = 0;
          }

          if (c == 'P'){
            start = 0;
          }

          float thicknessA = deep;
          float thicknessB = connections[i].deep; 
          if (c == 'S'){
            thicknessA = deep;
            thicknessB = (connections[i].deep);
          }
          if (c == 'C'){
            thicknessA = deep;
            thicknessB = (connections[i].deep);
          }
          if (c == 'P'){
            thicknessA = (connections[i].deep)*1.0;
            thicknessB = (connections[i].deep)*1.0;
          }

          if(v.mag() < 60 ){
            aligned_box(v, s, thicknessA/sca, thicknessB/sca, start);
          }

        }


        if(deep == connections[i].deep ){
          stroke(255);

          fill(min(255,deep*50),255,255);

          PVector v = new PVector(connections[i].x, connections[i].y, sq(connections[i].deep*vAmount));
          PVector s = new PVector(x,y, sq(deep*vAmount));
          v.sub(x,y,sq(deep*vAmount));

          int start = 0;
          char c = name.charAt(0);
          if (c == 'S'){
            start = 0;
          }

          float thicknessA = deep;
          float thicknessB = connections[i].deep; 
          if (c == 'S'){
            thicknessA = deep;
            thicknessB = deep;
          }

          aligned_box(v, s, thicknessA/sca, thicknessA/sca, start);

        }
      }
    }
  }

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

  void update(){

    float newX, newY, newZ;
    float spanX = 2;
    float spanY = 2;
    float spanZ = 2;

    if( (p.position().x() % spanX) < 5){
      newX = floor(p.position().x()/spanX)*spanX;
    }
    else{
      newX = ceil(p.position().x()/spanX)*spanX;
    } 

    if( (p.position().y() % spanY) < 5){
      newY = floor(p.position().y()/spanY)*spanY;
    }
    else{
      newY = ceil(p.position().y()/spanY)*spanY;
    } 

    if( (p.position().z() % spanZ) < 5){
      newZ = floor(p.position().z()/spanZ)*spanZ;
    }
    else{
      newZ = ceil(p.position().z()/spanZ)*spanZ;
    } 
    this.x =  p.position().x();
    this.y =  p.position().y() ;
    this.z =  p.position().z();
    pos.set(x,y,z);

  }

  void jiggle(float a){
    p.position().add(random(-a, a), random(-a, a), 0.0);
  }
}