boolean drawRequested = true;
boolean startingUp = true;

boolean showFileChooser = false;
PFont defaultFont10;
PFont defaultFont16;

File file;

color latticeColor = color(0,0,0,255);
color textColor = color(0,0,0,255);

color moduleMouseOverColor = color(255,230,230,255);
color moduleMouseOverInvisible = color(255,230,230,40);
color moduleColor = color(200,200,200,255);

int moduleWidth  = 60;
int moduleHeight = 60;
int roundedness  = 5;
int pad = 10;

int visibleRows = 0;
int visibleCols = 0;

//LinkedList gridModules = new LinkedList();
final int MAX_ROWS = 10;
final int MAX_COLS = 15;
GridModule[][] allGridModules = new GridModule[MAX_ROWS][MAX_COLS]; // index: [row][col]

Point mouseDownPoint = new Point(mouseX, mouseY); 


void setup(){
  background(0,0,0);
  size(610, 407);
  frameRate(20); 
  defaultFont10 = loadFont("LucidaSans-10.vlw");
  defaultFont16 = loadFont("LucidaSans-16.vlw");
  textFont(defaultFont10, 10);
}

void draw(){
  if(startingUp){
    // initial background paint seems to get missed.. 
    // just a hack to make it pretty for now.
    delay(250);
    background(0,0,0);    
    println("starting up... done");
    initGridModules();
    buildModuleList();
    loadExampleModules(); // load Example
    startingUp = false;
  }
  if(drawRequested){
    if(showFileChooser){
      renderFileChooser();
    }else{
      renderAll();
    }
    drawRequested = false;
  }  
}

void loadExampleModules(){
   allGridModules[1][0].visible = true;
   allGridModules[0][1].visible = true;
   allGridModules[2][1].visible = true;
   allGridModules[2][2].visible = true;
   allGridModules[3][1].visible = true;
   allGridModules[3][2].visible = true;
   allGridModules[1][3].visible = true;
   allGridModules[2][4].visible = true;
   allGridModules[0][5].visible = true;
   allGridModules[1][5].visible = true;      
}

void mousePressed(){
  if(showFileChooser){
    if(overOK()){
      // handle file selection
      showFileChooser = false;
      drawRequested = true;
    }
    if(overCancel()){
      // handle Cancel
      showFileChooser = false;
      drawRequested = true;
    }
    return;
  }
  mouseDownPoint.x = mouseX;
  mouseDownPoint.y = mouseY;
  if(mouseButton == RIGHT){    
    for(int row=0; row<MAX_ROWS; row++){
      for(int col=0; col<MAX_COLS; col++){
        if(allGridModules[row][col].pointInBounds(mouseX, mouseY) && allGridModules[row][col].visible){
          // got the visible module that was clicked...
          GridModule gm = allGridModules[row][col];
          println("would you like to add a purty piture to the module?  you clicked: (" + gm.row + "," + gm.col + ")");
          LinkedList visited = new LinkedList();
          Bounds b = entireBoundsFromModule(gm, visited);
          //println("--> Bounds x(" + b.minX + "," + b.maxX + ") y(" + b.minY + "," + b.maxY + ")");
          int picWidth = b.maxX - b.minX;
          int picHeight = b.maxY - b.minY;
          println(" --> ideal picture would be: (" + picWidth + "," + picHeight + ")");

          //showFileChooser = true;
          //drawRequested = true;
        }
      } 
    }   
  }
}


void renderFileChooser(){
  file = new File(".");
  background(latticeColor); 
  drawPath();
  drawCancel();
  drawOK();
  if(file.isDirectory()){
    println("file was a directory... listing files");
     File[] files = file.listFiles();
     for(int i=0; i<files.length; i++){
       println(files[i].getName());
     }
  }
}

void drawPath(){
  //fill(200,200,200,255);
  //roundedRect(25,25,width-50,25,10);
  textFont(defaultFont16, 16);
  fill(200,200,200,255);
  text("Path: " + file.getAbsolutePath(),35,42);
}

void drawCancel(){
  fill(200,200,200,255);
  roundedRect(width-125,height-50,100,25,10);
  textFont(defaultFont16, 16);
  fill(textColor);
  text("Cancel",width-100,height-33);
}

void drawOK(){
  fill(200,200,200,255);
  roundedRect(width-225,height-50,75,25,10);
  textFont(defaultFont16, 16);
  fill(textColor);
  text("OK",width-200,height-33);
}

boolean overOK(){
  return (mouseX > width-225 && mouseX < width-150 && mouseY > height-50 && mouseY < height-25);
}

boolean overCancel(){
  return (mouseX > width-125 && mouseX < width-25 && mouseY > height-50 && mouseY < height-25);
}

public class ImageFilter implements FilenameFilter{ 
 public boolean accept(File f, String s){
   if(f.getName().toLowerCase().endsWith(".jpg") || 
   f.getName().toLowerCase().endsWith(".txt") || f.isDirectory()){
     return true; 
   }
   return false;
 }  
}


void mouseReleased(){
  if(showFileChooser){
    return;
  }
  if(mouseDownPoint.distToXY(mouseX, mouseY) < 5.0 && mouseButton == LEFT){
    // clicking occured without any dragging.
    for(int row=0; row<MAX_ROWS; row++){
      for(int col=0; col<MAX_COLS; col++){
        allGridModules[row][col].handleMouseClick(mouseX, mouseY);
      } 
    }   
  }else{
    fillSquares();
    mouseMoved();
  }
}

void mouseDragged(){
  if(showFileChooser){
    return;
  }
  mouseDownPoint.x = -1;
  mouseDownPoint.y = -1;
  
  if(mouseButton == LEFT){
    for(int row=0; row<MAX_ROWS; row++){
      for(int col=0; col<MAX_COLS; col++){
        allGridModules[row][col].handleMouseDragged(mouseX, mouseY);
      } 
    } 
  }
}

void renderAll(){
  background(latticeColor);
  println("Rendering");
  stroke(128);
  strokeWeight(1.0);
  smooth();
  paintAllModules();
  fillSquares();
}


void mouseMoved(){
  if(showFileChooser){
    return;
  }
  for(int row=0; row<MAX_ROWS; row++){
    for(int col=0; col<MAX_COLS; col++){
      allGridModules[row][col].handleMouseMove(mouseX, mouseY);
    } 
  }  
}

void keyPressed(){
  if(showFileChooser){
    return;
  }
  
  if(key == ' '){
    roundedness = (roundedness+5)%25;
    drawRequested = true;
  }
  if(key == 'p' || key == 'P'){
    pad = (pad)%25 + 5;
    buildModuleList();
    drawRequested = true;
  }
  
  if(key == CODED){
    switch(keyCode){
      case(UP): {
        println("got up: Decreasing module height");
        moduleHeight -= 5;
        moduleHeight = (int)Math.max(Math.min(moduleHeight, (height-3*pad)/2),30);
        buildModuleList();
        drawRequested = true;
        break;
      } 
      case(DOWN): {
        println("got down: Increasing module height");
        moduleHeight += 5;
        moduleHeight = (int)Math.max(Math.min(moduleHeight, (height-3*pad)/2),30);
        buildModuleList();
        drawRequested = true;
        break;
      } 
      case(LEFT): {
        println("got left: Decreasing module width");
        moduleWidth -= 5;
        moduleWidth = (int)Math.max(Math.min(moduleWidth, (width-3*pad)/2),30);
        buildModuleList();
        drawRequested = true;
        break;
      } 
      case(RIGHT): {
        println("got right: Increasing module width");
        moduleWidth += 5;
        moduleWidth = (int)Math.max(Math.min(moduleWidth, (width-3*pad)/2),30);
        buildModuleList();
        drawRequested = true;
        break;
      }       
    } 
  } 
}


void paintAllModules(){
  for(int row=0; row<MAX_ROWS; row++){
    for(int col=0; col<MAX_COLS; col++){
      allGridModules[row][col].drawModule();
    } 
  }
}

void initGridModules(){
   for(int row=0; row<MAX_ROWS; row++){
     for(int col=0; col<MAX_COLS; col++){
       allGridModules[row][col] = new GridModule(0, 0, 2*roundedness, 2*roundedness, row, col);
     } 
   }
}

void buildModuleList(){
  println("Placing all modules...");
  visibleRows = (height-pad)/(moduleHeight + pad);
  visibleCols = (width-pad) /(moduleWidth  + pad);
  int curX = pad;
  int curY = pad;
  for(int r=0; r<MAX_ROWS; r++){
    curX = pad;
    for(int c=0; c<MAX_COLS; c++){
      allGridModules[r][c].updateXYWH(curX, curY, moduleWidth, moduleHeight);
      curX += pad + moduleWidth;
    }
    curY += pad + moduleHeight;
  }
}


class GridModule { 
  private int x, y, gmWidth, gmHeight;
  public boolean visible = false;
  boolean mouseIsOver = false;
  public final int row, col;
  
  public LinkedList mergedNeighbors = new LinkedList(); // modules that are merged to "this" module
  
  public  GridModule(int x, int y, int gmWidth, int gmHeight, int row, int col){
    this.x = x;
    this.y = y;
    this.gmWidth  = gmWidth;
    this.gmHeight = gmHeight;
    this.row = row;
    this.col = col;
  }
  
  public void updateXYWH(int x, int y, int gmWidth, int gmHeight){
    this.x = x;
    this.y = y;
    this.gmWidth  = gmWidth;
    this.gmHeight = gmHeight;
  }
  
  public void drawModule(){
    // always clear before drawing...
     noStroke();
      fill(latticeColor);
      rect(x, y, gmWidth+1, gmHeight+1);
      if(mouseIsOver && (x+gmWidth+pad) <= width && (y+gmHeight+pad) <= height){
        fill(moduleMouseOverInvisible);        
        roundedRect(x,y,gmWidth,gmHeight,roundedness);
      }
      
    if(visible && (x+gmWidth+pad) <= width && (y+gmHeight+pad) <= height){
      // show that merged modules are connected...
      fill(moduleColor);
      Iterator iter = mergedNeighbors.iterator();
      while(iter.hasNext()){
        GridModule gm = (GridModule)iter.next();
        // draw a rectangle to connect them.
        int rowDif = gm.row - this.row;
        int colDif = gm.col - this.col;
        if(rowDif == 0){
          if(colDif > 0){
            // merge to right
            rect(x+gmWidth-roundedness, y, pad+2*roundedness, gmHeight);
          }else{
            // merge to left
            rect(x-pad-roundedness, y, pad+2*roundedness, gmHeight);
          }
        }else{
          if(rowDif > 0){
            // merge down
            rect(x, y+gmHeight-roundedness, gmWidth, pad+2*roundedness);
          }else{
            // merge up
            rect(x, y-pad-roundedness, gmWidth, pad+2*roundedness);
          }
        }
      }
      
      if(mouseIsOver){
        fill(moduleMouseOverColor);
      }else{
        fill(moduleColor);
      }
      roundedRect(x,y,gmWidth,gmHeight,roundedness);
      

    }else{
      noStroke();
      fill(latticeColor);
      rect(x, y, gmWidth+1, gmHeight+1);
      if(mouseIsOver && (x+gmWidth+pad) <= width && (y+gmHeight+pad) <= height){
        fill(moduleMouseOverInvisible);        
        roundedRect(x,y,gmWidth,gmHeight,roundedness);
      }
    }
  } 
  
  public void handleMouseMove(int mx, int my){
    if(pointInBounds(mx, my)){
      mouseIsOver = true;
      drawModule();      
    }else{
      if(mouseIsOver){
        // mouse was over previously, but not anymore.. deselect it.
        mouseIsOver = false;
        drawModule();        
      }
    }
  }
  
  public void handleMouseClick(int mx, int my){
    if(mouseIsOver){
      visible = !visible;
      // remove all merges that point to this..
      // and then clear this's merge list
      Iterator iter = mergedNeighbors.iterator();
      while(iter.hasNext()){
        GridModule gm = (GridModule)iter.next();
        gm.removeMerge(this);
        boolean v = gm.visible;
        gm.visible = false;
        gm.drawModule();
        gm.visible = v;
        gm.drawModule();
        gm.drawModule();
      }
      mergedNeighbors.clear();
      clearLattice();
      drawModule();
    }
  }
  
  private void clearLattice(){
    fill(latticeColor);
    rect(x-pad, y-pad, gmWidth+2*pad, pad);
    rect(x-pad, y-pad, pad, gmHeight+2*pad);
    rect(x+gmWidth, y-pad, pad, gmHeight+2*pad);
    rect(x-pad, y+gmHeight, gmWidth+2*pad, pad);
  }
  
  public void handleMouseDragged(int mx, int my){
    if(visible && mouseIsOver){
      // mouseIsOver only "true" for the element that the drag started on. :)
      for(int row=0; row<MAX_ROWS; row++){
        for(int col=0; col<MAX_COLS; col++){
          if(allGridModules[row][col].visible && allGridModules[row][col].pointInBounds(mx, my)){
            GridModule gm = allGridModules[row][col];
            if(row == this.row && col == this.col){ 
              // dragging over self
              return;
            }
            if(row == this.row+1 && col == this.col){
              // dragging to next module down
              this.addMerge(gm);
              gm.addMerge(this);
              mouseIsOver = false;
              gm.mouseIsOver = true; // transfer mouseIsOver for sweeping selections.
              drawModule();
              gm.drawModule();
            }
            if(row == this.row-1 && col == this.col){
              // dragging to next module up
              this.addMerge(gm);
              gm.addMerge(this);     
              mouseIsOver = false;
              gm.mouseIsOver = true; // transfer mouseIsOver for sweeping selections.              
              drawModule();      
              gm.drawModule();
            }
            if(row == this.row && col == this.col+1){
              // dragging to next module right
              this.addMerge(gm);
              gm.addMerge(this);      
              mouseIsOver = false;
              gm.mouseIsOver = true; // transfer mouseIsOver for sweeping selections.              
              drawModule();      
              gm.drawModule(); 
            }
            if(row == this.row && col == this.col-1){
              // dragging to next module left
              this.addMerge(gm);
              gm.addMerge(this);     
              mouseIsOver = false;
              gm.mouseIsOver = true; // transfer mouseIsOver for sweeping selections.              
              drawModule();      
              gm.drawModule();   
            }           
          }
        } 
      }
    } 
  }
  
  public void addMerge(GridModule gm){
    if(mergedNeighbors.contains(gm)){
      return;
    }else{
      mergedNeighbors.add(gm);
      println("added merge! (" + row + "," + col + ")");
    } 
  }

  public void removeMerge(GridModule gm){
    if(mergedNeighbors.contains(gm)){
      println("remove merge! rem (" + gm.row + "," + gm.col + ") from (" + row + "," + col + ")");
      mergedNeighbors.remove(gm);      
    }
  }
  
  public boolean hasMergedModules(){
    return (mergedNeighbors.size() > 0);
  }

  public boolean pointInBounds(int px, int py){
    return (px > x && px < x+gmWidth && py > y && py < y+gmHeight);
  }
  
  public void includeInBounds(Bounds b){
    b.includePoint(x,y);
    b.includePoint(x+gmWidth, y+gmHeight);
  }
}


/**
 * Draw a rounded rectangle.  oh, so smooth and sensual! :]
 * looks best with smooth() enabled.
 * Corner smoothness is given directly
 */
void roundedRect(int x, int y, int rWidth, int rHeight, int rounded){
  noStroke();
  rect(x+rounded, y, rWidth-2*rounded+1, rHeight);
  rect(x, y+rounded, rWidth, rHeight-2*rounded+1); 
  //line(x+rounded, y, x+rWidth-rounded, y);
  //line(x+rounded, y+rHeight, x+rWidth-rounded, y+rHeight);
  //line(x, y+rounded, x, y+rHeight-rounded);
  //line(x+rWidth, y+rounded, x+rWidth, y+rHeight-rounded);
  arc(x+rounded, y+rounded, 2*rounded, 2*rounded, PI, 3.0*PI/2.0);
  arc(x+rounded, y+rHeight-rounded, 2*rounded, 2*rounded, PI/2.0, PI);
  arc(x+rWidth-rounded, y+rHeight-rounded, 2*rounded, 2*rounded, 0.0, PI/2.0);
  arc(x+rWidth-rounded, y+rounded, 2*rounded, 2*rounded, 3.0*PI/2.0, 0.0); 
}  

/**
 * Draw a rounded rectangle.  oh, so smooth and sensual! :]
 * looks best with smooth() enabled.
 * Corner smoothness is a percent of the Math.min(rectWidth,rectHeight);
 */
void roundedRectPercent(int x, int y, int rWidth, int rHeight, int cornerPercent){  
  int rounded = (int)(Math.max(Math.min(cornerPercent/100.0,1.0),0.0)/2.0*Math.min(rWidth, rHeight));
  roundedRect(x, y, rWidth, rHeight, rounded);
}

// kind of unfortunate.. need to fill in sets of 4 that form a square or
// else a piece of the background lattice will show in the center.
void fillSquares(){
  //println(" ---- running fill squares --- ");
  for(int row=0; row<MAX_ROWS; row++){
    for(int col=0; col<MAX_COLS; col++){
      if(allGridModules[row][col].hasMergedModules()){
        // traverse upto depth 4 to look for squares...
        GridModule gmA = allGridModules[row][col];
        Iterator iterA = gmA.mergedNeighbors.iterator();
        while(iterA.hasNext()){
          GridModule gmB = (GridModule)iterA.next();
          if(gmB.row != gmA.row || gmB.col != gmA.col){
            Iterator iterB = gmB.mergedNeighbors.iterator();
            while(iterB.hasNext()){
              GridModule gmC = (GridModule)iterB.next();
              if((gmC.row != gmB.row || gmC.col != gmB.col) 
                    && (gmC.row != gmA.row || gmC.col != gmA.col)){
                Iterator iterC = gmC.mergedNeighbors.iterator();
                while(iterC.hasNext()){
                  GridModule gmD = (GridModule)iterC.next(); 
                  if((gmD.row != gmC.row || gmD.col != gmC.col) 
                        && (gmD.row != gmB.row || gmD.col != gmB.col) 
                        && (gmD.row != gmA.row || gmD.col != gmA.col)){
                    Iterator iterD = gmD.mergedNeighbors.iterator();
                    while(iterD.hasNext()){
                      GridModule gmE = (GridModule)iterD.next();
                      if(gmE.row == gmA.row && gmE.col == gmA.col){
                        double aveRow = (gmA.row + gmB.row + gmC.row + gmD.row) / 4.0;
                        double aveCol = (gmA.col + gmB.col + gmC.col + gmD.col) / 4.0;
                        fill(moduleColor);
                        int fillX = (int)((pad+moduleWidth)/2.0 + aveCol*(moduleWidth+pad));
                        int fillY = (int)((pad+moduleHeight)/2.0 + aveRow*(moduleHeight+pad));
                        rect(fillX,fillY, pad, pad);
                        //println(" GOT SQUARE!! (" + gmA.row + "," + gmA.col + ") (" + gmB.row + "," + gmB.col + ") (" + gmC.row + "," + gmC.col + ") (" + gmD.row + "," + gmD.col + ") (");
                        //println("SQUARE at ave: (" + aveRow + "," + aveCol + ")");
                      }
                    }
                  }
                }
              }
            } 
          }
        } 
      }
    } 
  }   
}


class Point {
  public int x;
  public int y; 
  public Point(int x, int y){
    this.x = x;
    this.y = y;
  }  
  
  public double distToXY(int px, int py){
    int xDiff = x-px;
    int yDiff = y-py;
    return Math.sqrt(xDiff*xDiff + yDiff*yDiff); 
  }
}

class Bounds {
  public int minX;
  public int minY;
  public int maxX;
  public int maxY;

  public Bounds(){
    minX = width;
    maxX = 0;
    minY = height;
    maxY = 0;
  }

  public void includePoint(int x, int y){
    minX = (int)Math.min(x, minX);
    minY = (int)Math.min(y, minY);
    maxX = (int)Math.max(x, maxX);
    maxY = (int)Math.max(y, maxY);
  }    
}


Bounds entireBoundsFromModule(GridModule gm, LinkedList visited){
  Bounds b = new Bounds(); 
  gm.includeInBounds(b);
  visited.add(gm);
  includeBoundsSet(gm, visited, b);
  return b;
}

void includeBoundsSet(GridModule gm, LinkedList visited, Bounds b){
  Iterator iter = gm.mergedNeighbors.iterator();
  while(iter.hasNext()){
    GridModule gmB = (GridModule)iter.next();
    if(!visited.contains(gmB)){
       gmB.includeInBounds(b);
       visited.add(gmB);
       includeBoundsSet(gmB, visited, b);
    }
  } 
}