PSystem ps;
Particle p[][];
Spring s[][];


int BRANCHING[] = new int[10];                                                            //desired numer of branches for each particle in next step
int CURRENT_ROW[] = new int[10];                                                          //number of members in current row
int POPULATION_TOTAL[] = new int[10];                                                     //total number of members after each row

HScrollbar myscrollbar1, myscrollbar2,myscrollbar3,myscrollbar4,myscrollbar5,myscrollbar6;


void setup() {

  create (0,0);
  branching(2,2,2,2,1,0);
  myscrollbar1 = new HScrollbar(50, height - 40, 270, 10, 3*5+1);
  myscrollbar2 = new HScrollbar(50, height - 60, 270, 10, 3*5+1);
  myscrollbar3 = new HScrollbar(50, height - 80, 270, 10, 3*5+1);
  myscrollbar4 = new HScrollbar(50, height - 100, 270, 10, 3*5+1);
  myscrollbar5 = new HScrollbar(50, height - 120, 270, 10, 3*5+1);
  myscrollbar6 = new HScrollbar(50, height - 140, 270, 10, 3*5+1);
}


void branching(int slider1, int slider2, int slider3, int slider4, int slider5, int slider6 )  {
  BRANCHING[0] = 1;
  BRANCHING[1] = slider1;
  BRANCHING[2] = slider2;
  BRANCHING[3] = slider3;
  BRANCHING[4] = slider4;
  BRANCHING[5] = slider5;
  BRANCHING[6] = slider6;
  BRANCHING[7] = 0;
  BRANCHING[8] = 0;
}


void create (int change, int horiz)  {

  size(800,600);
  
  ps = (PSystem)loadPlugin("PSystem");

  
  ps.defaultSpringRestLength = 1;
  ps.defaultSpringStrength = 0.15;

  CURRENT_ROW[0] = 1;                                                                       //number of members in each (CURRENT) row

  POPULATION_TOTAL[0] = 1;                                                                  //total number of members

  int ROWS = 0;

  for (int n = 0; n < BRANCHING.length ; n++) {                                             //checks for end of the array
    if (BRANCHING[n] == 0)  {
    break; }
    ROWS++;
  }

  Particle p[][] = new Particle[10][200];
  Spring s[][] = new Spring[10][200];

  for (int n = 0; n < ROWS ; n++) {
    if (n > 0)    {
      CURRENT_ROW[n] = CURRENT_ROW[n-1] * BRANCHING[n];
      POPULATION_TOTAL[n] = POPULATION_TOTAL[n-1] + CURRENT_ROW[n];
    }
    for (int i = 1; i <= CURRENT_ROW[n]; i++)    {                         //THE BOTTOM PARTICLE
      if (n==0 && i==1)      {
        p[n][i] = new Particle (width/2, mouseY, 0);
      }
      else if (n==ROWS-1)  {
        p[n][i] = new Particle ( i*30, 100, 0 );
      }
      else    {
        p[n][i] = new Particle ( width/2+i, 700 - (50 * n * n)  , 0 );
      }

      ps.addParticle (p[n][i]);

      if (n==0) {                                                            
        p[n][i].fix();
      }
      if (n==ROWS-1)  {
        if (change == 0)  {
          p[n][i].fix(1,50);
        }
        if (change == 1 && ROWS - 1 < 5){
          p[n][i].fix(1,50-((sqrt (i))*i-12*i));
        }
        if (change == 2 && ROWS - 1 < 5){
          p[n][i].fix(1,+(i)/4 + 100 +((sqrt (5*i))*i-6*i));
        }
        if (change == 3 && ROWS - 1 < 5)  {
          p[n][i].fix(1,+(i*i)/4 + 100+((sqrt (i))*i-12*i));
        }
        if (change == 4 && ROWS - 1 < 5)  {
          p[n][i].fix(1,100 + 10*sin(5*i));
        }
        if (change == 5 && ROWS - 1 < 5)  {
          p[n][i].fix(1,100 + 4*i + 10*sin(5*i));
        }
        
      }

      
      ps.defaultSpringDamping = .025;
      if (n > 0) {                                                          //MAIN SPRINGS
        for (int k = 1; k <= CURRENT_ROW[n]; k++)    {
          if (i<=BRANCHING[n]*k && i>BRANCHING[n]*(k-1) )  {
            s[n][i] = new Spring (p[n][i], p[n-1][k]);
            ps.addForce(s[n][i]);
          }
        }
      }

      if (i>1 && n==ROWS-1) {                                                 //HORIZONTAL SPRINGS FOR LAST ROW
        ps.defaultSpringRestLength = 50;
        ps.defaultSpringStrength = 1.5;
        ps.addSpring(p[n][i],p[n][i-1]);
        if (i>2) {                                                            //HORIZONTAL [n-2] SPRINGS FOR LAST ROW
          ps.addSpring(p[n][i],p[n][i-2]);
        }
      }

      if(horiz == 1)  {
        if (i>1 && n<ROWS-1)    {                                             //ADDITIONAL HORIzPRINGS
          ps.addSpring(p[n][i],p[n][i-1]);
          ps.defaultSpringRestLength = 50;
          ps.defaultSpringStrength = 0.5;
        }
      }

      ps.defaultSpringRestLength = 1;
      ps.defaultSpringStrength = 0.15;

    }
    println("row number is :: " + n);                                           //prints the info about number of particles in each stage
    println("current row total particle number ::  " + CURRENT_ROW[n]);
    println("total population of particles is :: " + POPULATION_TOTAL[n]);
  }
  //ps.setGravity(0, 10, 0);
}


void graphics () {                                                      //INTERFACE (I KNOW IT CAN BE SHORTER!!)
stroke (255,255,255);
  line (40, height - 45, 40, height - 35);
  
  line (40, height - 65, 40, height - 55);
  line (35, height - 65, 35, height - 55);
  
  line (40, height - 85, 40, height - 75);
  line (35, height - 85, 35, height - 75);
  line (30, height - 85, 30, height - 75);
  
  line (40, height - 105, 40, height - 95);
  line (35, height - 105, 35, height - 95);
  line (30, height - 105, 30, height - 95);
  line (25, height - 105, 25, height - 95);
  
  line (40, height - 125, 40, height - 115);
  line (35, height - 125, 35, height - 115);
  line (30, height - 125, 30, height - 115);
  line (25, height - 125, 25, height - 115);
  line (20, height - 125, 20, height - 115);
  
  stroke (100, 100, 100);
  line (40, height - 145, 40, height - 135);
  line (35, height - 145, 35, height - 135);
  line (30, height - 145, 30, height - 135);
  line (25, height - 145, 25, height - 135);
  line (20, height - 145, 20, height - 135);
  line (15, height - 145, 15, height - 135);
  
  stroke(150, 0,0);
  line (60, height - 145, 60, height - 35);
  fill(0);
 ellipse(55, height - 25, 10, 10);
  
  stroke(100, 100,100);
  line (110, height - 145, 110, height - 35);
  line (160, height - 145, 160, height - 35);
  line (210, height - 145, 210, height - 35);
  line (260, height - 145, 260, height - 35);
  line (310, height - 145, 310, height - 35);
  
  stroke (255,255,255);
  
  line (110, height - 25, 110, height - 15);
  
  line (155, height - 25, 160, height - 15);
  line (165, height - 25, 160, height - 15);
  
  line (203, height - 25, 210,height - 15);
  line (217, height - 25, 210, height - 15);
  line (210, height - 25, 210, height - 15);
  
  line (257, height - 25, 260, height - 15);
  line (263, height - 25, 260, height - 15);
  line (250, height - 25, 260, height - 15);
  line (270, height - 25, 260, height - 15);
  
  line (303, height - 25, 310, height - 15);
  line (317, height - 25, 310, height - 15);
  line (310, height - 25, 310, height - 15);
  line (297, height - 25, 310, height - 15);
  line (323, height - 25, 310, height - 15);
  
    stroke (0,0,0);
}


void loop() {



 
  stroke(0, 0, 0);
  background(0, 0, 0);
   graphics();
  
 
  
  //p[0][1].fix(mouseX,mouseY);

  int slider1 = myscrollbar1.getPos()/60 ;
  int slider2 = myscrollbar2.getPos()/60 ;
  int slider3 = myscrollbar3.getPos()/60 ;
  int slider4 = myscrollbar4.getPos()/60 ;
  int slider5 = myscrollbar5.getPos()/60 ;
  int slider6 = myscrollbar6.getPos()/2000;

  if (mousePressed == true)    {
    println ("slider1 is" + slider1);
    println ("slider2 is" + slider2);
    println ("slider3 is" + slider3);
    println ("slider4 is" + slider4);
    println ("slider5 is" + slider5);
    println ("slider6 is" + slider6);
  }
  
  branching(slider1, slider2, slider3, slider4, slider5, slider6);

  myscrollbar1.update();
  myscrollbar1.draw();
  myscrollbar2.update();
  myscrollbar2.draw();
  myscrollbar3.update();
  myscrollbar3.draw();
  myscrollbar4.update();
  myscrollbar4.draw();
  myscrollbar5.update();
  myscrollbar5.draw();
  myscrollbar6.update();
  myscrollbar6.draw();
  ps.draw();

  if(keyPressed) {                                                      //INPUT FOR DIFFERENT LOAD CONDITIONS
    int h;
    if (mousePressed)  {
      h = 1;
    }
    else {
      h = 0;
    }

    if(key == 'q')  {
      create(0,h);
    }
    if(key == 'w')    {
      create(1,h);
    }
    if(key == 'e')  {
      create(2,h);
    }
    if(key == 'r')    {
      create(3,h);
    }
    if(key == 't')    {
      create(4,h);
    }
    //if(key == 'y')    {
    //  create(5,h);
    //}
  }

  float maxForce=0;                                                          //COLOR CODING
  float forceCol[] = new float[ps.nForces];
  int numSprings=0;

  // extract spring forces and max force
  for (int i = 0; i < ps.nForces; i++) {
    if (ps.forces[i] instanceof Spring) {
      float Fx = ((Spring)ps.forces[i]).Fx;
      float Fy = ((Spring)ps.forces[i]).Fy;
      float Fz = ((Spring)ps.forces[i]).Fz;
      forceCol[i] = sqrt((Fx*Fx)+(Fy*Fy)+(Fz*Fz));
      if (maxForce<forceCol[i])  maxForce=forceCol[i];
    }
    numSprings++;
  }

  // scaling down the color range
  for (int i=0;i<numSprings;i++) {
    forceCol[i]= (forceCol[i]/maxForce)*255.0;
  }

  //re-drawing the springs with the colors
  for (int i = 0; i < ps.nForces; i++) {
    if (ps.forces[i] instanceof Spring) {
      float axpos = ((Spring)ps.forces[i]).a.pos[0];
      float aypos = ((Spring)ps.forces[i]).a.pos[1];
      float azpos = ((Spring)ps.forces[i]).a.pos[2];
      float bxpos = ((Spring)ps.forces[i]).b.pos[0];
      float bypos = ((Spring)ps.forces[i]).b.pos[1];
      float bzpos = ((Spring)ps.forces[i]).b.pos[2];

      stroke(forceCol[i], 125,125);
      strokeWeight(forceCol[i]/200 );

      line(axpos,aypos,azpos,bxpos,bypos,bzpos);

      stroke(0,0,0);
      strokeWeight(1);

    }//
  }

}

class HScrollbar                                                          //SCROLLBAR CLASS
{
  int swidth, sheight;    // width and height of bar
  int xpos, ypos;         // x and y position of bar
  int spos, newspos;      // x position of slider
  int sposMin, sposMax;   // max and min values of slider
  int loose;              // how loose/heavy
  boolean over;           // is the mouse over the slider?
  boolean locked;
  int ratio;

  HScrollbar (int xp, int yp, int sw, int sh, int l) {
    swidth = sw;
    sheight = sh;
    int widthtoheight = sw - sh;
    ratio = (int)sw / (int)widthtoheight;
    xpos = xp;
    ypos = yp-sheight/2;
    spos = xpos + swidth/2 - sheight/2 - 25;
    newspos = spos;
    sposMin = xpos;
    sposMax = xpos + swidth - sheight;
    loose = 4;
  }

  void update() {
    if(over()) {
      over = true;
    } else {
      over = false;
    }
    if(mousePressed && over) {
      locked = true;
    }
    if(!mousePressed) {
      locked = false;
    }
    if(locked) {
      newspos = constrain(mouseX-sheight/2, sposMin, sposMax);
    }
    if(abs(newspos - spos) > 1) {
      spos = spos + (newspos-spos)/loose;
    }
  }

  int constrain(int val, int minv, int maxv) {
    return min(max(val, minv), maxv);
  }

  boolean over() {
    if(mouseX > xpos && mouseX < xpos+swidth &&
    mouseY > ypos && mouseY < ypos+sheight) {
      return true;
    } else {
      return false;
    }
  }

  void draw() {
    fill(200);
    rect(xpos, ypos, swidth, sheight);
    if(over || locked) {
      fill(125, 125, 125);    // color while active
    } else {
      fill(255, 255, 255);  // color while inactive
    }
    rect(spos, ypos, sheight, sheight);
  }

  int getPos() {
    // convert spos to be values between
    // 0 and the total width of the scrollbar
    return spos * ratio;
  }
}