/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

import processing.phone.*;
import processing.sound.*;

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

class Location
{
  private int row;
  private int column;

  public Location (int _r, int _c)
  {
    setRow(_r);
    setColumn(_c);
  }

  public void setRow(int _r)
  {
    row = _r;
  }

  public void setColumn(int _c)
  {
    column = _c;
  }

  public int getRow()
  {
    return row;
  }

  public int getColumn()
  {
    return column;
  }

  public boolean equals(int r, int c)
  {
    return (row == r) && (column == c);
  }
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

class Bubble
{
  public final color[] types = { 
    color(129, 240, 112),         // Verde
    color(  0, 183, 239),         // Azul
    color(255, 121, 121),         // Rojo
    color(255, 211,  79)   };     // Amarillo

  private color type;
  private boolean selected;
  private int width; 
  private int height;

  public Bubble(int width, int height)
  {
    setTypeByIndex(random(0, 3));

    this.width = width;
    this.height = height;

    selected = false;
  }

  public color getType()
  {
    return type;
  }

  public color getColor()
  {
    return type;
  }

  public void setTypeByIndex(int t)
  {
    type = types[t];
  }

  public void setType(color t)
  {
    type = t;
  }

  public color getGenericType(int i)
  {
    return types[i];
  }

  public boolean isSelected()
  {
    return selected;
  }

  public void setSelected(boolean s)
  {
    selected = s;
  }

  public void draw(int x, int y, boolean user_selected)
  {
    ///////////////////////////////////////////

    rectMode(CORNER);
    if(selected)
    {
      fill(color(229, 170, 122));
      rect(x, y, width, height);    
    }

    ///////////////////////////////////////////

    rectMode(CORNER);
    if(user_selected)
    {
      fill(color(234, 0, 117));
      rect(x, y, width, height);
    }

    ///////////////////////////////////////////

    if(!selected && !user_selected)
    {
      fill(color(0, 0, 0));
      rect(x, y, width, height);
    }

    ///////////////////////////////////////////

    fill(getColor());
    ellipseMode(CORNER);
    ellipse(x, y, width, height);

    ///////////////////////////////////////////

    if(selected)  // again
    {
      fill(color(0, 0, 0));
      line(x, y, x + width, y + height);
      line(x + width, y, x, y + height);
    }

    ///////////////////////////////////////////
  }
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

class Board
{
  private Bubble[][] board;
  private int rows;
  private int columns;
  private int top;
  private int width;
  private int height;
  private int boardWidth;
  private int boardHeight;
  private Location selection;
  private int selectionCount;
  private int scorePoints;
  private int scoreExploded;
  private int scoreShots;
  private int status;

  public final int ENABLED  = 1;
  public final int DISABLED = 2;

  public Board(int rows, int columns, int width, int height)
  {
    this.rows = rows;
    this.columns = columns;

    this.boardWidth = width;
    this.boardHeight = height;

    this.top = 30;
    this.width = boardWidth / columns;
    this.height = (boardHeight - top) / rows;

    initialize();
  }

  private void initialize()
  {
    this.status = ENABLED;

    board = new Bubble[rows][columns];

    for(int r=0; r<rows; r++)
    {
      for(int c=0; c<columns; c++)
      {
        board[r][c] = new Bubble(width, height);
      }
    }

    selection = new Location(0, 0);

    selectionCount = processSelection();

    scorePoints   = 0;
    scoreShots    = 0;
    scoreExploded = 0;
  }

  public void draw()
  {
    String message = "Scr: " + scorePoints + "; Exp: " + scoreExploded + "; Sho: " + scoreShots;
    fill(color(255, 255, 255));
    text(message, 0, 0, boardWidth, top);

    for(int r=0; r<rows; r++)
    {
      for(int c=0; c<columns; c++)
      {
        Bubble cell = board[r][c];

        if(cell != null)
        {
          cell.draw(c * width, r * height + top, selection.equals(r, c));
        }
        else
        {
          if(selection.equals(r, c))
          {
            rectMode(CORNER);
            fill(color(234, 0, 117));
            rect(c * width, r * height + top, width, height);
          }
        }
      }
    }
  }

  public boolean moveSelection(int direction)
  {
    int r = selection.getRow();
    int c = selection.getColumn();

    switch(direction)
    {
    case UP:
      r = r - 1;
      break;
    case DOWN:
      r = r + 1;
      break;
    case LEFT:
      c = c - 1;
      break;
    case RIGHT:
      c = c + 1;
      break;
    }

    if(r < 0 || c < 0)
      return false;

    if(r == rows || c == columns)
      return false;

    selection = new Location(r, c);

    selectionCount = processSelection();    

    return true;
  }

  private void deselectAll()
  {
    for(int r=0; r<rows; r++)
    {
      for(int c=0; c<columns; c++)
      {
        if(board[r][c] != null)
          board[r][c].setSelected(false);
      }
    }
  }
  
  private int checkGameStatus()
  {
    for(int r=0; r<rows; r++)
    {
      for(int c=0; c<columns; c++)
      {
        if(board[r][c] != null)
        {
          deselectAll();
          color type = (board[r][c] != null) ? board[r][c].getType() : color(0, 0, 0);
          int count = processSelectionOn(r, c, type);
          
          if(count > 1)
          {
            processSelection();
            
            this.status = this.ENABLED;

            return this.status;
          }
        }
      }
    }
    
    deselectAll();
   
    this.status = this.DISABLED;
    
    return this.status;
  }

  private int processSelection()
  {
    deselectAll();

    int r = selection.getRow();
    int c = selection.getColumn();

    color type = (board[r][c] != null) ? board[r][c].getType() : color(0, 0, 0);

    return processSelectionOn(r, c, type);
  }

  private int processSelectionOn(int r, int c, color type)
  {
    int[] dr = {
      -1, 0, 1,  0    };
    int[] dc = { 
      0, 1, 0, -1    };

    if(r < 0 || c < 0 || r >= rows || c >= columns)
      return 0;

    if(board[r][c] == null)
      return 0;

    if(board[r][c].getType() != type)
      return 0;

    if(board[r][c].isSelected())
      return 0;

    board[r][c].setSelected(true);

    int count = 1;

    for(int i=0; i<dr.length; i++)
    {
      int nr = r + dr[i];
      int nc = c + dc[i];

      count = count + processSelectionOn(nr, nc, type);
    }

    return count;
  }

  public int blowSelected()
  {
    if (selectionCount < 2)
      return 0;

    for(int r=0; r<rows; r++)
    {
      for(int c=0; c<columns; c++)
      {
        if(board[r][c] != null && board[r][c].isSelected())
          board[r][c] = null;
      }
    }

    int hits = selectionCount;
    selectionCount = 0;

    fitBubbles();

    selectionCount = processSelection();

    scorePoints   = scorePoints + hits * hits;
    scoreShots    = scoreShots + 1;
    scoreExploded = scoreExploded + hits;

    checkGameStatus();

    return hits;
  }

  private void makeBubblesFall()
  {
    int row = rows - 1;

    for(int c=0; c<columns; c++)
    {
      int emptyRow = -1;

      for(int r=row; r>=0; r--)
      {
        if(board[r][c] == null)
        {
          if(emptyRow == -1)    // Undefined
            emptyRow = r;
          // else, this is an empty space more, I already  have one
        }
        else
        {
          if(emptyRow != -1)    // I have an empty space already detected and I found the first following bubble
          {
            board[emptyRow][c] = board[r][c];
            board[r][c] = null;
            r = emptyRow;
            emptyRow = -1;
          }
          // else, I haven't found any holes to fill
        }
      }
    }
  }

  private boolean isEmptyColumn(int index)
  {
    for(int r=0; r<rows; r++)
    {
      if(board[r][index] != null)
        return false;
    }

    return true;
  }

  private void moveBubblesColumn(int from, int to)
  {
    for(int r=0; r<rows; r++)
    {
      board[r][to] = board[r][from];
      board[r][from] = null;
    }
  }

  private void crushTheBubbles()
  {
    int emptyColumn = -1;

    for(int c=0; c<columns; c++)
    {
      if(isEmptyColumn(c))
      {
        if(emptyColumn == -1)
        {
          emptyColumn = c;
        }
      }
      else
      {
        if(emptyColumn != -1)
        {
          moveBubblesColumn(c, emptyColumn);
          c = emptyColumn;
          emptyColumn = -1;
        }
      }
    }
  }

  private void fitBubbles()
  {
    makeBubblesFall();
    crushTheBubbles();
  } 
  
  public int getStatus()
  {
    return this.status;
  }
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

Phone phone = null;
Board board = null;

void setup()
{
  phone = new Phone(this);

  board = new Board(10, 10, width, height);

  PFont font = loadFont(FACE_MONOSPACE, STYLE_PLAIN, SIZE_MEDIUM); 
  textFont(font); 
  
  softkey("New Game");
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

void keyPressed()
{
  if(keyCode == UP || key == '2')
    board.moveSelection(UP);

  if(keyCode == DOWN || key == '8')
    board.moveSelection(DOWN);

  if(keyCode == LEFT || key == '4')
    board.moveSelection(LEFT);

  if(keyCode == RIGHT || key == '6')
    board.moveSelection(RIGHT);

  if(keyCode == FIRE || key == '5')
  {
    if(board.getStatus() == board.DISABLED)
    {
      Sound.playTone(120, 10, 100);
      return;
    }
    
    int bubblesExploded = board.blowSelected();

    if (bubblesExploded > 0)
    {
      phone.vibrate(50);
    }
  }
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

void softkeyPressed(String label)
{
  if(label == "New Game")
  {
    board.initialize();
    redraw();
  }
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////

void draw()
{
  if(board != null)
  {
    if(board.getStatus() == board.ENABLED)
        background(0);
    if(board.getStatus() == board.DISABLED)
        background(color(245, 228, 156));
  }
  else
    background(0);

  if(board != null)
    board.draw();
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////