/* 
 
 bubbleBubble 
 
 Due bolle si scontrano e si intersecano 
 
 September 2007 
 Processing v.0124 <http://processing.org> 
 
 */

int idxCircle =-1; 
Circle[] circles= new Circle[10]; 

void AddCircle(int x, int y, int r, float dx, float dy){ 
  
  idxCircle ++;

  circles[idxCircle] = new Circle(x, y,r, dx, dy, idxCircle);
}   
  
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

  
  //Due bolle 
  //circles[0] = new Circle(100, 100,20,  0.25,0, 0); 
  //circles[1] = new Circle(200, 100,5, -0.25, 0, 1); 
  
                          //x   y  r  dx     dy id   
  //circles[0] = new Circle(100, 200,40, 0.25, 0, 0); 
  //circles[1] = new Circle(200, 200,40, -0.25, 0, 1); 

  /*circles[0] = new Circle(100, 300,20, 0.01, 0, 0); 
  circles[1] = new Circle(150, 350,20, -0.25, -0.25, 1); 

  circles[6] = new Circle(180, 150,10, -0.25, -0.25, 6); 
  */
  
  //circles[0] = new Circle(400, 400,40, 0.25, 0, 0); 
  //circles[1] = new Circle(500, 400,30, -0.25, 0, 1);
  
  AddCircle(400, 400,70, 0.25, 0);
  AddCircle(500, 400,40, -0.25, 0);
  
  AddCircle(200, 200,40, 0.25, 0);
  AddCircle(300, 200,40, -0.25, 0);
  
  //circles[2] = new Circle(450, 450,20, 0.1, -0.25, 2);
  
  
  /*circles[2] = new Circle(150, 500,25, 0.001, -0.4, 2);
  circles[0] = new Circle(100, 100,20,  0.01,0, 0); 
  circles[1] = new Circle(200, 200,20, -0.25, -0.25, 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<circles.length; i++) { 
    if(circles[i] != null){
      circles[i].update(); //Calcolo intersezione
    }
  } 

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


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


class Circle 
{ 
  float x, y, r, r2, sp, ysp; 
  float ax, ay;
  float 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<circles.length; i++) { 
      if(i != id && circles[i] != null) { 
        intersect( this, circles[i] ); 
      } 
    } 

  } 

  void draw(){ 

    float g1 = 0, a1;
    float g2 = 0, a2;

    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) {

      //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

      //println("");
      //println("id:" + id);

      g1 = (atan2((y-ay),(x-ax)));      
      //println("x-ax " + (x-ax) + " y-ay " + (y-ay) );
      a1 = g1*180/PI;
      //println("g1:" + g1 + " gradi:" + a1);

      g2 = (atan2((y-by),(x-bx)));      
      //println("x-bx " + (x-bx) + " y-by " + (y-by) );
      a2 = g2*180/PI;
      //println("g2:" + g2 + " gradi:" + a2);

      
      arc(x, y, r, r, PI+g2,PI+g1);
      
      //stroke(255,0,0);

      //line(ax, ay, bx, by); 

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

  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; 
      } 
    } 
  } 
} 
   //questo mi serve per avere l'equazione della retta che passa per il
   //centro del cerchio e il punto di intersezione, cioè quella
   //su cui sta il raggio
   float r(float m, float p, float x) {
    return (x*m) + p;
  }
  
  
float equ_rect_m(float x1,float y1, float x2, float y2){

    return (y2 - y1) / (x2 - x1); 
 }   

float equ_rect_p(float x1,float y1, float x2, float y2){
return ((x2 * y1) - (x1 * y2) ) / (x2 - x1);
 }   


  
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
  //Le bolle si fermano e fanno l'intersezione quando l'angolo fra i due archi è di 120°.
  //qui calcolo il valore di d quando l'angolo è 120° sapendo i raggi e che si forma un 
  //triangolo con angoli di 60° tra i centri e il punto di intersezione. Uso il coseno dell'angolo di 60°
  
  float rapporto = (cA.r*cA.r+cB.r*cB.r) - 2*cA.r*cB.r*cos(PI/3);
  float rapporto2 = sqrt (rapporto);
  if (d < rapporto2) {  

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

    cA.bx = pbX;
    cA.by = pbY;

    //***************
    
    //anche se sembra sbagliato è giusto 
   //Specchio dei punti di intersezione  
    cB.ax = pbX;
    cB.ay = pbY;

    cB.bx = paX;
    cB.by = paY;

    //***********

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

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

    stroke(255,0,0);
    line(paX, paY, pbX, pbY); 
    //cA.draw();
    //cB.draw();
    
    
    
    //***********************
    
    //PEZZO NUOVO PER FARE L'ARCO DI CERCHIO!!!!
    //qui calcolo quanto vale l'angolo nel centro di uno dei due cerchi, poi trovo BD
    //cioè la distanza dall'altro centro al centro del cerchio che è l'intersezione delle due bolle
    //quindi una volta trovate le coordinate di D mi manca solo di disegnarlo
    
    float coseno;
    float angolo_alpha;
    float BD;
    float cD_x, cD_y;
    
    println ("rapporto2:" +rapporto2);
    coseno = (cA.r*cA.r + rapporto - cB.r*cB.r)/ (2 * cA.r * rapporto2);
    angolo_alpha = acos (coseno);
    println ("angolo_alpha in gradi :" + angolo_alpha * 180 /PI);
    
    BD = (rapporto2 * sin(angolo_alpha)) / sin(PI/3 - angolo_alpha);
    println ("BD:" +BD);
    //una volta trovata la distanza BD, come faccio a trovare le coordinate di D?
    //so solo che sta sulla stessa retta che contiene i due centri e la sua distanza da B
    
    //Retta passante per i due centri dei cerchi
    float m2,p2;
      
    m2 = equ_rect_m(cA.x,cA.y,cB.x,cB.y);
    p2 = equ_rect_p(cA.x,cA.y,cB.x,cB.y);
    println ("m2:" +m2);
    println ("p2:" +p2);
    stroke(0,255,0);
    line(cA.x,r(m2,p2,cA.x),600,r(m2,p2,600));
    line(cA.x, cA.y, cA.ax, cA.ay);
    line(cA.x, cA.y, cA.bx, cA.by);
    line(cB.x, cB.y, cB.ax, cB.ay);
    line(cB.x, cB.y, cB.bx, cB.by);
    
    float delta_x;
    
    float C_x, C_y, C_r;
    
    if (cA.r < cB.r) {
      C_x = cA.x;
      C_y = cA.y;
      C_r = cA.r;
    } 
    else{
      C_x = cB.x;
      C_y = cB.y;
      C_r = cB.r;
    }
    
    println ("C_x:" + C_x);
    println ("C_y:" + C_y);    
    println ("C_r:" + C_r);
    
    delta_x = cos (atan (m2)) * BD;
    println ("delta_x:" + delta_x);
    //le coordinate del punto B sono cB.x e cB.y
    //calcolo le coordinate di D
    //cD_x = sqrt (BD*BD - p2*p2 + cB.x*cB.x + cB.y*cB.y) / 2*m2*m2;
    //cD_x = sqrt (+ p2*p2 - BD*BD + cB.x*cB.x + cB.y*cB.y) / -2*m2*m2;
    
    
    //cD_x = (  (cB.x-m2*p2+cB.y*m2) - sqrt(  (cB.x-m2+p2+cB.y*m2)*(cB.x-m2+p2+cB.y*m2) - (1+m2*m2)*(cB.x*cB.x+cB.y*cB.y+p2*p2-2*cB.y*p2-BD*BD)  )   )/ 1+m2*m2 ;
    
    cD_x = C_x - delta_x;
    cD_y = r(m2, p2,cD_x);
    
    stroke (255,0,0);
    point (cD_x, cD_y);
    println ("cD_x:" + cD_x);
    println ("cD_y:" + cD_y);
    
    //con questo dovrei poter calcolare la distanza da D al punto d'intersez dei due cerchi,
    //cioè il raggio del mio arco di cerchio che fa l'intersezione
    float raggio_x = cA.ax - cD_x; 
    float raggio_y = cA.ay - cD_y; 
    float raggio2 = raggio_x*raggio_x + raggio_y*raggio_y; 
    float raggio = sqrt( raggio2 );
    println ("raggio:" +raggio);
    
    //qui dovrei usare i valori g1 e g2 ma non posso perchè sono definiti da un'altra parte; 
    //probabilmente dovrei scrivere tutto in modo diverso
    arc (cD_x, cD_y, raggio, raggio, PI+10,PI+80);
    
    //***********************
    
    
    
    
    float m,p;

    //Retta passante per centro e punto intersezione A    
    stroke(0,255,0);

    m = equ_rect_m(cA.x,cA.y,paX,paY);
    p = equ_rect_p(cA.x,cA.y,paX,paY);

    //line(0,r(m,p,0),600,r(m,p,600));
    
    //println (atan2(paY,paX));
    //println (m*tan(PI/6));
    
    //questa sotto sarebbe la formula ma non mi dà nessun risultato perchè lui
    //si trova zero al denominatore perchè m*tan(PI/6)= -1
    
    //m = (m - tan(PI/6)) / (1 + (m) *tan(PI/6));
    m = -tan(atan(m)+30);
    //m =(m + tan(PI/6))/(1 - m*tan(PI/6));
    //m = -1/m;
    stroke(0,0,255);
    //line(paX,r(m,p,paX),600,r(m,p,600));
  }
  

}