class network {

  int maxdots = 1000;
  int maxsprings = 1000;
  int maxfaces = 1000;
  int ndots, nsprings, nfaces;
  dot[] dots;
  spring[] springs;
  face[] faces;
  boolean[] dotvacant, springvacant, facevacant;
    
  boolean[][] friends;
  float[][] dotdist;
  
  float constructionScaleDistance, chargeScaleDistance, congealDistance;
  float randomness;
    
  float timestep = 0.05;
//  float beta = 1;
//  float mousebeta = 0.1;
  float k = 100;
  float chargeConstant = 0.045;
  float chargeMultiplier = 1.0;
  float congealiness = 0.7;
  float transparency = 0.9;
  float dotSize;
  color basecolor;


  network(float dist, float rand, color col) {
    dots = new dot[maxdots];
    ndots = 0;
    springs = new spring[maxsprings];
    nsprings = 0;
    faces = new face[maxfaces];
    nfaces = 0;
    
    dotvacant = new boolean[maxdots];
    for (int i=0; i<maxdots; i++) {dotvacant[i]=true;}
    springvacant = new boolean[maxsprings];
    for (int i=0; i<maxsprings; i++) {springvacant[i]=true;}
    facevacant = new boolean[maxfaces];
    for (int i=0; i<maxfaces; i++) {facevacant[i]=true;}
    
    friends = new boolean[maxdots][maxdots];
    for (int i=0; i<maxdots; i++) {for (int j=0; j<maxdots; j++) {friends[i][j] = false;}}
    dotdist = new float[maxdots][maxdots];
    for (int i=0; i<maxdots; i++) {for (int j=0; j<maxdots; j++) {dotdist[i][j] = 0;}}
    
    constructionScaleDistance = dist;
    chargeScaleDistance = dist;
    congealDistance = congealiness * chargeScaleDistance;
    dotSize = x2scr(congealDistance);
    randomness = rand;
    
    basecolor = col;
  }
  
  int addDot(float x0, float y0, float ch, color col) {
    // find the first vacancy
    int i=0;
    while ((i<=maxdots-1) && (!dotvacant[i])) {i++;}
    // fill it with a new dot
    if (i<maxdots) {
      dotvacant[i] = false;
      if (i>ndots-1) {ndots = i+1;}
      dots[i] = new dot(x0,y0,ch,dotSize,col);
      return i;
    } else {
      return -1;
    }
  }
  
  int addSpring(int fromi, int toi, float k) {
    if ((fromi>-1) && (toi>-1)) {
      // find the first vacancy
      int i=0;
      while ((i<=maxsprings-1) && (!springvacant[i])) {i++;}
      // fill it with a new dot
      if (i<maxsprings) {
        springvacant[i] = false;
        if (i>nsprings-1) {nsprings = i+1;}
        springs[i] = new spring(dots[fromi],dots[toi],k);
        return i;
      } else {
        return -1;
      }
    } else {
      return -1;
    }
  }
  
  int addFace(dot[] v, color col) {
    // find the first vacancy
    int i=0;
    while ((i<=maxfaces-1) && (!facevacant[i])) {i++;}
    // fill it with a new dot
    if (i<maxfaces) {
      facevacant[i] = false;
      if (i>nfaces-1) {nfaces = i+1;}
      faces[i] = new face(v,col,transparency);
      return i;
    } else {
      return -1;
    }    
  }
  
  void removeDot(int i) {
    dotvacant[i] = true;
    dots[i].dormant = true;
    for (int j=0; j<nsprings; j++) {
      if ((springs[j].from==dots[i]) || (springs[j].to==dots[i])) {
        removeSpring(j);
      }
    }
    for (int j=0; j<ndots; j++) {
      friends[i][j] = false;
      friends[j][i] = false;
    }
    for (int j=0; j<nfaces; j++) {
      if (faces[j].contains(dots[i])) {removeFace(j);}
    }
  }
  
  void removeSpring(int i) {
    if (!springs[i].dormant) {
      springvacant[i] = true;
      springs[i].dormant = true;
      if (!springs[i].from.dormant) {springs[i].from.nlinks = springs[i].from.nlinks - 1;}
      if (!springs[i].to.dormant) {springs[i].to.nlinks = springs[i].to.nlinks - 1;}
    }
  }
  
  void removeFace(int i) {
    facevacant[i] = true;
    faces[i].dormant = true;
  }
  
  color randomcolor() {
    color R = shift(basecolor,random(-randomness/2,randomness/2));
    color G = shift(basecolor,random(-randomness/2,randomness/2));
    color B = shift(basecolor,random(-randomness/2,randomness/2));
    return color(red(R),green(G),blue(B));
  }

    
  color assigncolor(int N) {
    color c;
    if (basecolor == colors[0]) {
      if (N<=4) {
        c = bluecolor;
      } else if (N==5) {
        c = yellowcolor;
      } else if ((N==6) || (N==7)) {
        c = greencolor;
      } else {
        c = orangecolor;
      }
    } else {
      c = basecolor;
    }
    return c;
  }
  
  color assignchildcolor(int N) {
    if (basecolor == colors[0]) {
      if ((N==6) || (N==7)) {
        return ltgreencolor;
      } else if (N>7) {
        return yellowcolor;
      } else {
        return lighten(assigncolor(N));
      }
    } else {
      return lighten(basecolor);
    }
  }


  void addPolygon(float x0, float y0, int N, color col) {
    int j;
    int[] n = new int[N];
    
    float dtheta = TWO_PI/N;
    float rad = 2 * constructionScaleDistance/sqrt(2*(1-cos(TWO_PI/N)));
    float ch = 1;
        
    col = shift(col,random(randomness/4,randomness/4));
    
    n[0] = addDot(x0+rad,y0,ch,darken(col));
    for (int i=1; i<N; i++) {
      n[i] = addDot(x0+rad*cos(i*dtheta),y0+rad*sin(i*dtheta),ch,darken(col));
      j = addSpring(n[i-1],n[i],k);
      if (j>-1) {springs[j].kpush = 0;}
    }
    j = addSpring(n[N-1],n[0],k);
    if (j>-1) springs[j].kpush = 0;
    
    for (int i=0; i<N; i++) {
      if (n[i]>-1) {
        for (int k=0; k<N; k++) {
          if (n[k]>-1) {
            friends[n[i]][n[k]] = true;
            friends[n[k]][n[i]] = true;
          }
        }
      }
    }
    
    dot[] v = new dot[N];
    for (int i=0; i<N; i++) {v[i] = dots[n[i]];}
    addFace(v,col);
  }
  
  
  void addPolygonFamily(float x0, float y0, int N) {
    int nsubpolys = N;
    int subpolysize = min(5,N);
    float spacing = 1.2;
    color col = assigncolor(N);
    color subcol = assignchildcolor(N);
    
    addPolygon(x0,y0,N,col);
    float rad = spacing * 2 * constructionScaleDistance * (1/sqrt(2*(1-cos(TWO_PI/N))) + 1/sqrt(2*(1-cos(TWO_PI/nsubpolys))));
    float dtheta = TWO_PI/nsubpolys;
    for (int i=0; i<N; i++) {
      addPolygon(x0+rad*cos((i+0.5+random(-0.2,0.2))*dtheta),y0+rad*sin((i+0.5+random(-0.2,0.2))*dtheta),subpolysize, subcol);
    }
  } 
  
  
  boolean over() {
    boolean f = false;
    for (int i=0; i<ndots; i++) {
      if ((!dots[i].dormant) && (dots[i].over())) {f = true;}
    }
    for (int i=0; i<nsprings; i++) {
      if ((!springs[i].dormant) && (springs[i].over())) {f = true;}
    }
    return f;
  }
  
  
  void mergedots(int i, int j) {
    // make springs that go to j go to i
    for (int k=0; k<nsprings; k++) {
      if (springs[k].from == dots[j]) {springs[k].from = dots[i];}
      if (springs[k].to == dots[j]) {springs[k].to = dots[i];}
    }
    dots[i].nlinks = dots[i].nlinks + dots[j].nlinks;
    // replace j with i in faces
    for (int k=0; k<nfaces; k++) {
      for (int m=0; m<faces[k].N; m++) {
        if (faces[k].vertices[m]==dots[j]) {
          faces[k].vertices[m]=dots[i];
        }
      }
    }
    // move i to the average position, charge, and color of i and j
    dots[i].x = (dots[i].x + dots[j].x)/2;
    dots[i].y = (dots[i].y + dots[j].y)/2;
    dots[i].charge = (dots[i].charge + dots[j].charge)/2;
    dots[i].normalcolor = colorblend(dots[i].normalcolor,dots[j].normalcolor,0.5);
    dots[i].activecolor = colorblend(dots[i].activecolor,dots[j].activecolor,0.5);
    dots[i].lockedcolor = colorblend(dots[i].lockedcolor,dots[j].lockedcolor,0.5);
    dots[i].immobilecolor = colorblend(dots[i].immobilecolor,dots[j].immobilecolor,0.5);
    // a friend of j's is a friend of i's
    for (int k=0; k<ndots; k++) {
      friends[i][k] = (friends[i][k] || friends[j][k]);
      friends[k][i] = (friends[k][i] || friends[k][j]);
    }
    // active & mobile tags
    dots[i].active = (dots[i].active || dots[j].active);
    dots[i].mobile = (dots[i].mobile && dots[j].mobile);
    dots[i].mouselocked = (dots[i].mouselocked || dots[j].mouselocked);
    // deactivate j
    removeDot(j);
  }
  
  
  void mergesprings(int i, int j) {
    removeSpring(j);
  }
  
 
  void onmouserelease() {
    for (int i=0; i<ndots; i++) {
      dots[i].onmouserelease();
    }
  }  
  
  void ondeletekey() {
    for (int i=0; i<ndots; i++) {
      if (dots[i].active) {removeDot(i);}
    }
  }
  
  void onescapekey() {
    for (int i=0; i<ndots; i++) {
      if (dots[i].active) {dots[i].active=false;}
    }
  }
  
  void update() {
    if (ndots > 0) {
    // calc distances
    for (int i=0; i<ndots; i++) {
      if (!dots[i].dormant) {
        for (int j=i+1; j<ndots; j++) {
          if (!dots[j].dormant) {
            dotdist[i][j] = sqrt(sq(dots[j].x-dots[i].x)+sq(dots[j].y-dots[i].y));
          }
        }
      }
    }
    
    // congeal dots closer than congealDistance
    for (int i=0; i<ndots; i++) {
      if (!dots[i].dormant) {
        for (int j=i+1; j<ndots; j++) {
          if (!dots[j].dormant) {
            if (dotdist[i][j]<(congealDistance)) {mergedots(i,j);}
          }
        }
      }
    }
    
    // remove springs that go to and from the same dot
    for (int i=0; i<nsprings; i++) {
      if (springs[i].from==springs[i].to) {removeSpring(i);}
    }

    // deactivate dots not connected to any springs
    for (int i=0; i<ndots; i++) {dots[i].nlinks = 0;}
    for (int i=0; i<nsprings; i++) {
      if (!springs[i].dormant) {
        springs[i].from.nlinks++;
        springs[i].to.nlinks++;
      }
    }
    for (int i=0; i<ndots; i++) {
      if (dots[i].nlinks<=0) {removeDot(i);}
    }

    // congeal springs with matching from & to
    for (int i=0; i<nsprings; i++) {
      for (int j=i+1; j<nsprings; j++) {
        if (((springs[i].to==springs[j].to) && (springs[i].from==springs[j].from)) || ((springs[i].to==springs[j].from) && (springs[i].from==springs[j].to))) {
          mergesprings(i,j);
        }
      }
    }
    
    // initialize accelerations, add damping
    float b = beta;
//    if (mousePressed) {b = mousebeta;}
    for (int i=0; i<ndots; i++) {
      if (!dots[i].dormant) {
        dots[i].ax = -b*dots[i].u*max(abs(dots[i].u),1);
        dots[i].ay = -b*dots[i].v*max(abs(dots[i].v),1);
      }
    }
    
    // calc "charge" forces: friends strongly repel, non-friends attract (this is a inconsistent metaphor.) 
    float F, theta, dax, day;
    for (int i=0; i<ndots; i++) {
      for (int j=i+1; j<ndots; j++) {
        if ((!dots[i].dormant) && (!dots[j].dormant)) {
          if (friends[i][j]) {
            F = dots[i].charge * dots[j].charge / pow(dotdist[i][j]/chargeScaleDistance,2);
          } else if (dotdist[i][j] > chargeScaleDistance) {
            F = - chargeConstant * chargeMultiplier * dots[i].charge * dots[j].charge / pow(dotdist[i][j]/chargeScaleDistance,2.5);
          } else {
            F = - chargeConstant * chargeMultiplier * dots[i].charge * dots[j].charge / pow(dotdist[i][j]/chargeScaleDistance,3);
          }
          
          theta = atan2(dots[j].y-dots[i].y,dots[j].x-dots[i].x);
          if (abs(theta)<=TWO_PI) {
            dax = F*cos(theta);
            day = F*sin(theta);
          } else {
            dax = 0;
            day = 0;
          }
          dots[j].ax = dots[j].ax + dax; // note: assuming all dots have a mass of 1
          dots[j].ay = dots[j].ay + day;
          dots[i].ax = dots[i].ax - dax;
          dots[i].ay = dots[i].ay - day;
        }
      }
    }
    
    for (int i=0; i<nsprings; i++) {springs[i].update();}
    for (int i=0; i<ndots; i++) {dots[i].update(timestep);}
  }
  }
  
  void draw() {
    for (int i=0; i<nfaces; i++) {faces[i].draw();}
    for (int i=0; i<nsprings; i++) {springs[i].draw();}
    for (int i=0; i<ndots; i++) {dots[i].draw();}
  }
  
}