public class Board {
  private float x, y;
  private float bWidth,bHeight;
  private int numTilesX, numTilesY;
  private float tileSize;
  private ArrayList pieces;
  private ArrayList exits;

  Tile[][] filled;

  public Board() {
    this(8,8,width,height);
  }

  public Board(int numX, int numY, float widthX, float heightY) {
    numTilesX = numX;
    numTilesY = numY;
    bWidth = widthX;
    bHeight = heightY;

    setup();   
  }    

  private void setup() {   
    float bA = (float) (numTilesX) / (float) (numTilesY);
    float sA = bWidth/bHeight;

    float bW = 0;
    float bH = 0;

    if (bA>sA) {
      bW = bWidth;
      bH = numTilesY*bW/numTilesX;
    } 
    else {
      bH = bHeight;
      bW = numTilesX*bH/numTilesY;
    }

    x = (bWidth - bW)/2;
    y = (bHeight - bH)/2; 
    bHeight = bH;
    bWidth = bW;
    tileSize = bWidth/numTilesX;

    pieces = new ArrayList();
    filled = new Tile[numTilesX][numTilesY];
    for (int i=0; i<numTilesX; i++) {
      for (int j=0; j<numTilesY; j++) {
        filled[i][j] = new Tile(this, i, j, color(100));  
      }
    }
    
    exits = new ArrayList();
    exits.add(filled[numTilesX/2][numTilesY-1]);
    //exits.add(filled[numTilesX/2][0]);
    //exits.add(filled[numTilesX-1][numTilesY/2]);
    //exits.add(filled[0][numTilesY/2]);
    //exits.add(filled[numTilesX/2][numTilesY/2]);
    //exits.add(filled[(int)random(numTilesX)][(int)random(numTilesY)]);
    //exits.add(filled[(int)random(numTilesX)][(int)random(numTilesY)]);
    //exits.add(filled[(int)random(numTilesX)][(int)random(numTilesY)]);
    //exits.add(filled[(int)random(numTilesX)][(int)random(numTilesY)]);
    
    colorExits();
    floodBoard(this);
  }
  
  public boolean isExit(int x, int y) {
    if (inBounds(x,y)) {
      return isExit(filled[x][y]);
    }
    return false;  
  }
  
  public boolean isExit(Tile t) {
    return exits.contains(t);  
  }
  
  public void removeExit(int x, int y) {
    Tile t,ot=null;
    Iterator it;
    
    if (inBounds(x,y)) {
      it = exits.iterator();
      while (it.hasNext()) {
        t = (Tile) it.next();
        if (x==t.x && y==t.y) {
          ot = t;
          break;  
        }    
      }
      exits.remove(ot);
      ot.distanceToExit = -1; 
      resetFloodBoard();   
    }
  }
  
  public void addExit(int x, int y) {
    Tile t;
    if (inBounds(x,y)) {
      t = filled[x][y];
      exits.add(t);
      resetFloodBoard();   
    }
  }

  public void colorExits() {
    Tile t;
    float f = 1;
    float maxF = exits.size()+1;
    Iterator it = exits.iterator();
    while(it.hasNext()) {
     t = (Tile) it.next();
     //t.c = color(0,90 + random(100),random(200));
     t.c = color(f/maxF*255.0%255, f*2/maxF*255.0 % 255, f*4/maxF*255.0 % 255);

     t.distanceToExit = 0;
     
     f+=1;
    }  
  }

  public void fillBoard() {
    while (pieces.size() < numTilesX*numTilesY) addPiece();  
  }

  public void addPiece() {
    int x=-1,y=-1;
    if (pieces.size()>=numTilesX*numTilesY) return;
    while(!empty(x,y)) {
      x = (int)random(numTilesX);
      y = (int)random(numTilesY);
    }
    addPiece(x,y);
  }

  public void addPiece(int x, int y) {
    addPiece(new Piece(this,x,y), x,y);
  }

  public void addPiece(Piece p, int x, int y) {
    filled[x][y].add(p);
    p.x = x;
    p.y = y;
    pieces.add(p);          
  }

  public int numPieces() {
    return pieces.size();
  }

  public boolean inBounds(int x, int y) {
    return !(x<0 || y<0 || x>=filled.length || y>=filled[0].length);
  }

  public boolean empty(int x, int y) {
    if (!inBounds(x,y)) return false;
    return (filled[x][y].empty());  
  }

  public boolean mouseIn(int bX, int bY) {
    if (bX<0 || bY<0 || bX>=numTilesX || bY>=numTilesY) return false;

    return ((mouseX >= getSX(bX)) && (mouseX < getSX(bX+1)) &&
      (mouseY>= getSY(bY)) && (mouseY<getSY(bY+1))); 
  }

  public float getSX(int bX) {
    return x+bX*tileSize;  
  }

  public float getSY(int bY) {
    return y+bY*tileSize; 
  }

  public int getX(float _x) {
    return (int) ((_x-x)/tileSize);  
  }
  public int getY(float _y) {
    return (int) ((_y-y)/tileSize);
  }

  public Tile get(int x, int y) {
    if (x<0 || y<0 || x>=filled.length || y>=filled[0].length) return null; 
    return filled[x][y];
  }

  public void movePiece(Piece p, int x, int y) {
    if ((p.tickLastMoved != ticks) || (p.tickLastMoved == ticks && x == p.ox && y == p.oy)) {
      filled[p.x][p.y].remove(p);
      filled[x][y].add(p);
      if (p.tickLastMoved == ticks)
        p.tickLastMoved = -1;
      else {
        p.ox = p.x;
        p.oy = p.y;
        p.tickLastMoved = ticks;
      }
      p.x = x;
      p.y = y;
    }
  }

  public void draw() {
    drawBoard();
    drawPieces();
  }  

  public void updateBoard() {
    Piece p;
    for (int i=0; i<numTilesX; i++) {
      for (int j=0; j<numTilesY; j++) {
        filled[i][j].tick();
      }
    }    
  }

  public void resetFloodBoard() {
    Piece p;
    for (int i=0; i<numTilesX; i++) {
      for (int j=0; j<numTilesY; j++) {
        if (filled[i][j].distanceToExit != 0) filled[i][j].distanceToExit = -1;
      }
    }
    colorExits();
    floodBoard(this);    
  }


  public void drawBoard() {
    boolean legal = false;

    stroke(0,0,50);
    for (int i=0; i<numTilesX; i++) {
      for (int j=0; j<numTilesY; j++) {
        filled[i][j].draw();
      }
    }    
  }

  public void drawPieces() {
    Piece p;
    for (int i=0; i<pieces.size(); i++) {
      p = (Piece) pieces.get(i);
      p.draw();
    }  
  }

  public boolean clearBottom() {
    boolean f = true, b = false;
    for (int i=0; i<numTilesX; i++) {
      if (filled[i][numTilesY-1] == null) f = false;
    }

    if (f) {
      for (int i=0; i<numTilesX; i++) {
        remove(i, numTilesY-1);
      }
      b = true;  
    }
    return b;   
  } 


  public Piece remove(int bX, int bY) {
    Piece p = filled[bX][bY].get(0);
    pieces.remove(p);
    //if (pickedPiece == p) pickedPiece = null;
    filled[bX][bY].remove(p);  
    return p;  
  }

  public void reset() {
    Piece p;
    while (pieces.size()>0) {
      p = (Piece) pieces.get(0);
      remove(p.x,p.y);
    }
    updateBoard();  
  }

  public boolean move() {
    Collections.shuffle(pieces);
    boolean b = false;
    Piece p;
    for (int i=0; i<pieces.size(); i++) {
      p = (Piece) pieces.get(i);
      if (p.exit()) {
        i--;
        b=true;
      } 
      else if (p.move()) b=true;
    }
    return b;
  }
}