//------------------------------------------------------------ 
// Metaball Class 
//------------------------------------------------------------ 

class MetaSystem
{ 

  int W = 640; 
  int H = 480; 

  int METABALLS_N = 1; // Total numbers of Metaballs 

  float ISOVALUE = 12.0f;  // seems to affect size of metaball, lower value increases blobiness

  float Viscosity = 18.0;
  float Viscosity_min = 1.0;
  float Viscosity_max = 20.0; // Try 100 ;-)
  float dViscosity = (Viscosity_max - Viscosity_min)/250.0;

  int SQUARES_NX = 64;  // seems to affect decay rate
  int SQUARES_NY = 64; 

  int RES = 640/SQUARES_NX ; // RES_X & RES_Y  , dimensions where grid is calculated

  int GRIDSIZE_X = SQUARES_NX+1; 
  int GRIDSIZE_Y = SQUARES_NY+1; 

  float[][] MetaGrid = new float[GRIDSIZE_X][GRIDSIZE_Y]; 
  float MetaGridTrgt = 0; 
  float Meta_Nb = METABALLS_N; 
  //Metaball[] MetaB = new Metaball[METABALLS_N];
  
  boolean switch1 = true;
  
  Metaball MetaB; 
  
  ArrayList ballZ;

  color METACOLOR, METACENTERCOLOR, GRIDCOLOR;

  int[][] squareEdge = { 
    {
      0,1                } 
    , {
      1,2                }
    , {
      2,3                }
    , {
      3,0                } 
  };
  int[][] offset = { 
    {
      0,0                }
    , {
      1,0                }
    , {
      1,1                }
    , {
      0,1                } 
  };
  int[][] Line = { 
    {
      -1, -1, -1, -1, -1                }
    , 
    { 
      0,  3, -1, -1, -1                }
    , 
    { 
      0,  1, -1, -1, -1                }
    , 
    { 
      3,  1, -1, -1, -1                }
    , 
    { 
      1,  2, -1, -1, -1                }
    , 
    { 
      1,  2,  0,  3, -1                }
    , 
    { 
      0,  2, -1, -1, -1                }
    , 
    { 
      3,  2, -1, -1, -1                }
    , 
    { 
      3,  2, -1, -1, -1                }
    , 
    { 
      0,  2, -1, -1, -1                }
    , 
    { 
      3,  2,  0,  2, -1                }
    , 
    { 
      1,  2, -1, -1, -1                }
    , 
    { 
      3,  1, -1, -1, -1                }
    , 
    { 
      0,  1, -1, -1, -1                }
    , 
    { 
      0,  3, -1, -1, -1                }
    , 
    {
      -1, -1, -1, -1, -1                } 
  }; 

  int[][] squareFlag = new int[GRIDSIZE_X][GRIDSIZE_Y]; 

  int square_idx; 
  float isoP1_x, isoP1_y, isoP2_x, isoP2_y; 
  int P1_idx, P2_idx; 
  float Val1, Val2, temp; 

  float temp_, isoP1_x_, isoP1_y_, isoP2_x_, isoP2_y_;
  int P1_idx_, P2_idx_, i_, j_, square_idx_;
  float dVal, dIso;

  float prevX = 0.0f;
  float prevY = 0.0f;

  float xoff = 0.0f;
  float xoff2 = 0.0f;

/*  
  Vector3D a;
  Vector3D v;
  Vector3D l;
*/

  Vector3D a = new Vector3D(0.0,0.0);
  Vector3D v = new Vector3D(0.0,0.0);
  Vector3D l = new Vector3D(0.0,0.0);
  
  int num;

  //METACOLOR = color(175,175,175); 

  MetaSystem() // num corresponds to the # of Metaballs
  {

    METACOLOR = color(200,0,0);
    METACENTERCOLOR = color(200,0,0);
    GRIDCOLOR = color(220,220,220);
    
    ballZ = new ArrayList(); // array List for balls, each ball will have it's own a, v, & l
    ballZ.ensureCapacity(5);
    //METABALLS_N = _num;
    //Meta_Nb = METABALLS_N;
    int num = 4;
    
    //a = _a.copy();
    //v = _v.copy();
    //l = _l.copy();
    
    for (int i=0; i<num; i++) {  // add num amount of metaballs to the list.
      //Vector3D a = new Vector3D(0.0,0.0);
      //Vector3D v = new Vector3D(0.0,0.0);
      //Vector3D l = new Vector3D(0.0,2);
      
      //diff.mult(factor);
      ballZ.add(new Metaball(a, v, l));
    }
    
  }

  void run() {
    makeBalls();
    //creation();

  }
  
  void addBall() {
    //Vector3D a = new Vector3D(0.0,random(0,0.125));
    //Vector3D v = new Vector3D(random(0,0.2),0.0);
    //Vector3D l = new Vector3D(random(0,width),2);
    //ballZ.add(new Metaball(a, v, l));
  }
  
  void addBall(Metaball mb){
    ballZ.add(mb);
  }
  
  void removeBall(Metaball mb){
    ballZ.remove(mb);
  }
  
  /*
  void removeBall(Metaball mb){
    ballZ.remove(mb);
  } 
  
  if (mb.size() > 300) {
    mb.remove(0);
  }
  
 */ 


  void makeBalls() {
    
    for (int il = ballZ.size()-1; il >= 0; il--) {
      
      Metaball mb = (Metaball) ballZ.get(il);
      
    for (int y=0; y<GRIDSIZE_Y; y++)
    {
      for (int x=0; x<GRIDSIZE_X; x++)
      {
        squareFlag[x][y] = 0; 
        MetaGridTrgt = 0; 
        //for (int n=0; n<Meta_Nb; n++) 
        //{ 
        MetaGridTrgt += mb.getFieldAt(RES*x, RES*y); 
        //} 
        MetaGrid[x][y] += (MetaGridTrgt - MetaGrid[x][y])/Viscosity; 
      }

    }


    // *------------------------- 
    int scan_iMin,scan_iMax,scan_jMin,scan_jMax; 
    for (int k=0; k<Meta_Nb; k++) 
    {

      { 
        scan_iMin = 0; 
        scan_iMax = SQUARES_NX; 
        scan_jMin = 0; 
        scan_jMax = SQUARES_NY; 
      } 

      for (int j=scan_jMin; j<scan_jMax ; j++) 
      { 
        for (int i=scan_iMin; i<scan_iMax ; i++) 
        { 
          if (squareFlag[i][j] != 1) 
          { 
            square_idx = 0; 
            if (MetaGrid[i][j]    < ISOVALUE) square_idx |= 1; 
            if (MetaGrid[i+1][j]  < ISOVALUE) square_idx |= 2; 
            if (MetaGrid[i+1][j+1]< ISOVALUE) square_idx |= 4; 
            if (MetaGrid[i][j+1]  < ISOVALUE) square_idx |= 8; 

            if (square_idx != 0 || square_idx != 15) 
            { 
              int n=0; 

              while (Line[square_idx][n] != -1) 
              { 
                int Edge1_idx = Line[square_idx][n++]; 
                int Edge2_idx = Line[square_idx][n++]; 

                // * --------- Edge1 -------- * 
                //  
                P1_idx = squareEdge[Edge1_idx][0];
                P2_idx = squareEdge[Edge1_idx][1];

                Val1 = MetaGrid[i + offset[P1_idx][0]][j + offset[P1_idx][1]];
                Val2 = MetaGrid[i + offset[P2_idx][0]][j + offset[P2_idx][1]];
                if ((Val2-Val1) != 0 ) 
                { 
                  temp = (ISOVALUE - Val1)/(Val2-Val1); 
                } 
                else 
                { 
                  temp = 0.5f; 
                } 

                isoP1_x = RES*((i + offset[P1_idx][0]) + temp*((i + offset[P2_idx][0]) - (i + offset[P1_idx][0]))); 
                isoP1_x = Math_Clip(isoP1_x, 0.0f, 640.0f); 
                isoP1_y = RES*((j + offset[P1_idx][1]) + temp*((j + offset[P2_idx][1]) - (j + offset[P1_idx][1]))); 
                isoP1_y = Math_Clip(isoP1_y, 0.0f, 480.0f); 

                // * --------- Edge2 -------- * 
                // 
                P1_idx = squareEdge[Edge2_idx][0]; 
                P2_idx = squareEdge[Edge2_idx][1]; 


                Val1 = MetaGrid[i + offset[P1_idx][0]][j + offset[P1_idx][1]]; 
                Val2 = MetaGrid[i + offset[P2_idx][0]][j + offset[P2_idx][1]]; 
                if ((Val2-Val1) != 0 ) 
                { 
                  temp = (ISOVALUE - Val1)/(Val2-Val1); 
                } 
                else 
                { 
                  temp = 0.5f; 
                } 

                isoP2_x = RES*((i + offset[P1_idx][0]) + temp*((i + offset[P2_idx][0]) - (i + offset[P1_idx][0])));
                isoP2_x = Math_Clip(isoP2_x, 0.0f, 640.0f);
                isoP2_y = RES*((j + offset[P1_idx][1]) + temp*((j + offset[P2_idx][1]) - (j + offset[P1_idx][1])));
                isoP2_y = Math_Clip(isoP2_y, 0.0f, 480.0f);

                // * --------- draw Line(s) -------- * 
                // 
                strokeWeight(3);
                stroke(red(METACOLOR) , green(METACOLOR), blue(METACOLOR)); 
                line( (int)( isoP1_x ), (int)( isoP1_y ), (int)( isoP2_x ), (int)( isoP2_y ) ); 
                squareFlag[i][j] = 1; 
                //if (DRAWMETACONTAINER) drawX(i,j); 
              }   // end while 
            }   // end if     
          }  // end if 
        }  // end i 
      }  // end j 
    }  // end k 
 // 
      //Vector3D a = new Vector3D(0.0,0.125);
      //Vector3D v = new Vector3D(0.0,0.0);
      //Vector3D l = new Vector3D(width/2,2);
    
   // for (int i = ballZ.size(); i >= 0; i--) {
      
      float nx = noise(xoff) * width;
      float ny = noise(xoff2) * height;
    
      //Metaball mb = (Metaball) ballZ.get(i);
      mb.update();
      
      mb.setCenterTo(l.x,l.y); // the l position could be problematic
      
      mb.setStrength(30000);
      
    
    if (mousePressed && mouseY <= 480 && mouseX <= 639) {
      //Vector3D a = new Vector3D(0.0,0.125);
      //Vector3D v = new Vector3D(0.0,0.0);
      //Vector3D l = new Vector3D(width/2,2);

      //MetaB.setCenterTo(mouseX,mouseY);

      // Compute difference vector between mouse and object location
      // 3 steps -- (1) Get Mouse Location, (2) Get Difference Vector, (3) Normalize difference vector
      Vector3D m = new Vector3D(mouseX,mouseY);
      Vector3D diff = Vector3D.sub(m,mb.getLoc());
      diff.normalize();
      float factor = 1.3;  // Magnitude of Acceleration (not increasing it right now)
      diff.mult(factor);
      //object accelerates towards mouse
      mb.setAcc(diff);
      //MetaB.setCenterTo(l.x,l.y);
      //prevX = l.x;
      //prevY = l.y;
      //println("diff.x - "+ diff.x);
      //println("diff.y - "+ diff.y);
    } else {

      //MetaB.setAcc(new Vector3D(0,0));
      xoff += .01;
      xoff2 += .01;

      // Set this to perlin noise position
      Vector3D lm = new Vector3D(nx, ny);
      Vector3D diff2 = Vector3D.sub(lm,mb.getLoc());
      diff2.normalize();
      mb.setAcc(diff2); 
      //mb.setCenterTo(l.x,l.y);
    }
    
    
    if (keyPressed) {
      switch (key) 
       {
         case '1' :
         creation();
           //Meta_Nb = METABALLS_N - 3;
           //ballZ.set(0,new Metaball(a, v, l));
           //Vector3D l2 = new Vector3D(0.0,200.0);
           //ballZ.set(0, new Metaball(a, v, l));
           //Metaball mb_1 = (Metaball) ballZ.get(0);
           
           //mb_1.setCenterTo(100, 200);
         break;
         
         case '2' :
           //Meta_Nb = METABALLS_N - 2;
           //ballZ.add(1,new Metaball(a, v, l));
           Metaball mb_2 = (Metaball) ballZ.get(1);
           //mb_2.setCenterTo(120, 320);
         break;
                
         case '3' :
           Vector3D a3 = new Vector3D(0.0,0.0);
           Vector3D v3 = new Vector3D(0.0,0.0);
           Vector3D l3 = new Vector3D(0.0,120);
           //if (key == '3' && switch1 != false) 
           ballZ.set(0,new Metaball(a, v, l3));
           //Meta_Nb = METABALLS_N - 1;
           Metaball mb_3 = (Metaball) ballZ.get(0);
           //ballZ.trimToSize();
           //mb_3.setCenterTo(100, 400);
           
           //switch1 = false;
         break;
           
         case '4' :
           //Meta_Nb = METABALLS_N;
           ballZ.set(0,new Metaball(a, v, l));
           Metaball mb_4 = (Metaball) ballZ.get(0);
           //mb_4.setCenterTo(50, 400);
         break;
          
         case '5' :
           //Meta_Nb = METABALLS_N;
           Metaball mb_5 = (Metaball) ballZ.get(4);
           mb_5.setCenterTo(320, 300);
         break;
      }
    }
    
    
    println("num - "+ num);
    println("ballZ Size - "+ ballZ.size());
  }
  }
  

  boolean creation()
  {
      //Vector3D a3 = new Vector3D(0.0,0.0);
      //Vector3D v3 = new Vector3D(0.0,0.0);
      Vector3D l3 = new Vector3D(width,random(0,height));
      ballZ.set(0,new Metaball(a, v, l3));
      Metaball mb_3 = (Metaball) ballZ.get(0);
      return true;
  }

  // A method to test if the particle system still has particles
  boolean dead() {
    if (ballZ.isEmpty()) {
      return true;
    } else {
      return false;
    }
  }

/*
void keyPressed() 
{ 
 switch (key) 
 { 
   case '4' : 
   //ballZ.add(3,new Metaball(a, v, l));
   Meta_Nb = METABALLS_N;
   break; 
			 
   case '3' : 
           //ballZ.add(new Metaball(a, v, l));
           //Meta_Nb = METABALLS_N - 3;
           Metaball mb_3 = (Metaball) ballZ.get(1);
           mb_3.setCenterTo(200, 200);
           //switch1 = false;
   break; 
			 
   case '2' : 
   ballZ.add(3,new Metaball(a, v, l));
   //Meta_Nb = METABALLS_N - 2; 
   break; 
			 
   case '1' : 
   ballZ.add(3,new Metaball(a, v, l));
   Meta_Nb = METABALLS_N - 3; 
   break; 
 }
}
*/

  //------------------------------------------------------------
  // drawMetaCenter()
  //------------------------------------------------------------
  /*
  void drawMetaCenter()
  {
    int i,j;
    for (int n=0; n<Meta_Nb; n++)
    {
      if (MetaB.center_x >=0 && MetaB.center_x <256 && MetaB.center_y >=0 && MetaB.center_y <256)
      {
        i = MetaB.getSquareCoords_i(RES, RES);
        j = MetaB.getSquareCoords_j(RES, RES);
        stroke(red(METACENTERCOLOR), green(METACENTERCOLOR), blue(METACENTERCOLOR));
        line(
        (int) (Math_Clip((i*RES),0,255)),
        (int) (Math_Clip((j*RES),0,255)),
        (int) (Math_Clip(((i+1)*RES),0,255)),
        (int) (Math_Clip(((j+1)*RES),0,255))
          );
        line(
        (int) (Math_Clip(((i+1)*RES),0,255)),
        (int) (Math_Clip((j*RES),0,255)),
        (int) (Math_Clip((i*RES),0,255)),
        (int) (Math_Clip(((j+1)*RES),0,255))
          );
      }
    }
  }
  */


  //------------------------------------------------------------ 
  // Math_Clip() 
  //------------------------------------------------------------ 
  float Math_Clip(float val, float lo, float hi) 
  {
    if (val<lo) return lo; 
    if (val>hi) return hi; 
    return val; 
  }

  int Math_Clip(int val, int lo, int hi) 
  {
    if (val<lo) return lo; 
    if (val>hi) return hi; 
    return val; 
  }

}