/* 
 
 Structure 3 
 
 A surface filled with one hundred medium to small sized circles. 
 Each circle has a different size and direction, but moves at the same slow rate. 
 Display: 
 A. The instantaneous intersections of the circles 
 B. The aggregate intersections of the circles 
 
 Implemented by Casey Reas <http://groupc.net> 
 8 March 2004 
 Processing v.68 <http://processing.org> 
 
 */

//parametrizzare i raggi delle bolle x decidere a che distanza devono unirsi 


int numCircle = 2; 
Circle[] circles = new Circle[numCircle]; 

void setup() 
{ 
  size(800, 600); 
  frameRate(30); 


  //Creazione delle bolle
  //Le bolle andrebbero create in modo tale da non essere sovrapposte 
  //Il movimento dovrebbe essere verso il centro dello schermo

  circles[0] = new Circle(100, 100,20,  0.25,0, 0); 
  circles[1] = new Circle(200, 100,20, -0.25, 0, 1); 

  /*for(int i=0; i<numCircle; i++) { 
   circles[i] = new Circle(random(width), 
   	      (float)height/(float)numCircle * i, 
   	      int(random(2, 6))*10, random(-0.25, 0.25), 
   	      random(-0.25, 0.25), i); 
   }*/


  ellipseMode(CENTER_RADIUS); 
  background(255); 
} 


void draw() 
{ 
  //Pulizia dello schermo
  background(255); 

  stroke(0, 10); 

  for(int i=0; i<numCircle; i++) { 
    circles[i].update(); //Calcolo intersezione
  } 

  //Aggiunto disegno delle bolle
  for(int i=0; i<numCircle; i++) { 
    circles[i].draw(); 
  }    


  //Movimento delle bolle
  for(int i=0; i<numCircle; i++) { 
    circles[i].move(); 
  } 
} 


class Circle 
{ 
  float x, y, r, r2, sp, ysp; 
  float ax, ay, bx, by; //Coordinate punti intersezione A B
  int p;
  int id; 

  Circle( float px, float py, float pr, float psp, float pysp, int pid ) { 
    x = px; 
    y = py; 
    r = pr; 
    r2 = r*r; 
    id = pid; 
    sp = psp; 
    ysp = pysp; 

    ax = 0;
    ay = 0;

    bx = 0;
    by = 0;

    p = 1;
  } 

  void update() { 

    for(int i=0; i<numCircle; i++) { 
      if(i != id) { 
        intersect( this, circles[i] ); 
      } 
    } 

  } 

  void draw(){ 

    float g = 0, a;

    stroke(100,100,100);

    //finchè le coordinate della corda non sono valorizzate disegno il cerchio completo
    //altrimenti si calcola per ciascun punto della corda l'angolo formato sul cerchio 
    //in modo tale da determinare il grado di inizio e di fine dell'arco di cerchio

    //if (p!= 0){
    if (sp == 0) {

      //print("x:" + x + " y:" + y );
      //print("ax:" + ax + " ay:" + ay );

      //quando calcolo l'angolo che si forma unendo il centro e il punto di intersezione 
      //dei due cerchi, normalizzo le coordinate del cerchio riportandole a zero, cioè faccio la
      //differenza tra le coordinate del punto a e quelle del centro del cerchio

      g = atan2(abs(ay-y),abs(ax-x));

      println("ax-x " + (ax-x) + " ay-y " + (ay-y) );
      //println("g:" + g + " gradi:" + g*180/PI);

      a = g*180/PI;

      //println("a: " + a + " -a: " + (360-a));

      //Per il cerchio di sinistra, l'arco deve andare da g a 2*PI-g
     //Per il cerchio di destra invece l'arco deve andare da PI+g a PI-g
     //Ma come faccio a dirgli che ne deve disegnare uno in un modo e l'altro nell'altro modo??    
     
      arc(x, y, r, r, PI+g,PI-g);


      p = 0;
    }
    else {
      arc(x, y, r, r, 0, 2*PI);
    }

  }

  void move() { 
    x += sp; 
    y += ysp; 
    if(sp > 0) { 
      if(x > width+r) { 
        x = -r; 
      }   
    } 
    else { 
      if(x < -r) { 
        x = width+r; 
      } 
    } 
    if(ysp > 0) { 
      if(y > height+r) { 
        y = -r; 
      } 
    } 
    else { 
      if(y < -r) { 
        y = height+r; 
      } 
    } 
  } 
} 


void intersect( Circle cA, Circle cB ) 
{ 
  float dx = cA.x - cB.x; 
  float dy = cA.y - cB.y; 
  float d2 = dx*dx + dy*dy; 
  float d = sqrt( d2 ); 

  if ( d>cA.r+cB.r || d<abs(cA.r-cB.r) ) { 
    return; // no solution 
  } 

  float a = (cA.r2 - cB.r2 + d2) / (2*d); 
  float h = sqrt( cA.r2 - a*a ); 
  float x2 = cA.x + a*(cB.x - cA.x)/d; 
  float y2 = cA.y + a*(cB.y - cA.y)/d; 

  float paX = x2 + h*(cB.y - cA.y)/d; 
  float paY = y2 - h*(cB.x - cA.x)/d; 
  float pbX = x2 - h*(cB.y - cA.y)/d; 
  float pbY = y2 + h*(cB.x - cA.x)/d; 

  //stroke(dist(paX, paY, pbX, pbY)*4, 12); 

  stroke(100,100,100);
  line(paX, paY, pbX, pbY); 

  //Le bolle che sono intersecate si fermano
  //In realtà si dovrebbero fermare quando il valore d è > di xx% rispetto ai raggi delle bolle
  if (d < 20) {  

    cA.ax = paX;
    cA.ay = paY;

    cB.ax = pbX;
    cB.ay = pbY;

    cA.sp = 0;
    cA.ysp = 0;

    cB.sp = 0;
    cB.ysp = 0;

    stroke(100,100,100);
    line(paX, paY, pbX, pbY); 

    //cA.draw();
    //cB.draw();

  }
}