/**
 *  Board.java
 *  CIS 260
 *  David Klick
 *  2012-03-09
 *    
 *  This class implements a grid to hold the cells of
 *  a maze. 
 * 
 *  @author Dave Klick
 *  @version 1.0 2012-03-09
*/
import java.util.ArrayList;

class Board {
    private int rows, cols;
    private Cell startCell = null, endCell = null;
    private static int MAX_ROWS = 100, MAX_COLS = 100;
    public Cell[][] cell = null;

    public ArrayList<Direction> getConnectedNeighbors(Cell c) {
        // *****                                 *****
        // ***** THIS METHOD MUST BE IMPLEMENTED *****
        // *****                                 *****
    }

    public ArrayList<Direction> getUnvisitedConnectedNeighbors(Cell c) {
        // *****                                 *****
        // ***** THIS METHOD MUST BE IMPLEMENTED *****
        // *****                                 *****
    }

    public ArrayList<Direction> getUnvisitedNeighbors(Cell c) {
        // *****                                 *****
        // ***** THIS METHOD MUST BE IMPLEMENTED *****
        // *****                                 *****
    }

    public Board(int r, int c) {
        if (r<1 || r>MAX_ROWS) {
            throw new IllegalArgumentException("Rows value out of range: "
                + r + " should be in range 0 < rows <= " + MAX_ROWS);
        }
        if (c<1 || c>MAX_COLS) {
            throw new IllegalArgumentException("Cols value out of range: "
                + c + " should be in range 0 < cols <= " + MAX_COLS);
        }
        rows = r;
        cols = c;
        cell = new Cell[rows][cols];
        for (int i=0; i<rows; i++) {
            for (int j=0; j<cols; j++) {
                cell[i][j] = new Cell(i, j);
                if (i == 0) cell[i][j].setEdge(Direction.NORTH);
                if (i == rows-1) cell[i][j].setEdge(Direction.SOUTH);
                if (j == cols-1) cell[i][j].setEdge(Direction.EAST);
                if (j == 0) cell[i][j].setEdge(Direction.WEST);
            }
        }
    }
    
    /**
     *  This method creates a text representation of the
     *  board showing the maze in a pseudo-graphical way.
     *  
     *  @return a string representation of the whole board
     *  
     */
    public String toString() {
        StringBuilder str = new StringBuilder();
        Cell x;
        int r, c;
        for (c=0; c<cols; c++) str.append(startCell.getCol()==c ? "  " : " _");
        str.append('\n');
        for (r=0; r<rows-1; r++) {
            for (c=0; c<cols; c++) {
                x = cell[r][c];
                str.append(x.hasWall(Direction.WEST) ? '|' : ' ');
                str.append(x.hasWall(Direction.SOUTH) ? '_' : ' ');
            }
            str.append("|\n");
        }
        for (c=0; c<cols; c++) {
            x = cell[rows-1][c];
            str.append(x.hasWall(Direction.WEST) ? '|' : ' ');
            str.append(x != endCell ? '_' : ' ');
        }
        str.append("|\n");
        return str.toString();
    }
    
    public Cell getStartCell() { return startCell; }
    public Cell getEndCell() { return endCell; }
    public void setStartCell(Cell c) { startCell = c; }
    public void setEndCell(Cell c) { endCell = c; }
    public Cell getCell(int r, int c) {
        if (r<0 || r>=rows) {
            throw new IllegalArgumentException("Rows value out of range: "
                + r + " should be in range 0 <= rows < " + rows);
        }
        if (c<0 || c>=cols) {
            throw new IllegalArgumentException("Cols value out of range: "
                + c + " should be in range 0 <= cols < " + cols);
        }
        return cell[r][c];
    }
    public Cell getAdjacentCell(Cell c, Direction d) {
        // return null if attempt to go past maze boundary
        if (c.hasEdge(d)) return null;
        return cell[c.getRow()+d.deltaRow][c.getCol()+d.deltaCol];
    }
    public void connect(Cell cell1, Direction d) {
        cell1.clearWall(d);
        getAdjacentCell(cell1, d).clearWall(d.opposite());
    }
    public int getRows() { return rows; }
    public int getCols() { return cols; }
    public void clearVisited() {
        for (int r=0; r<rows; r++) {
            for (int c=0; c<cols; c++) {
                cell[r][c].clearVisited();
            }
        }
    }
    public void clearValues() {
        for (int r=0; r<rows; r++) {
            for (int c=0; c<cols; c++) {
                cell[r][c].setValue(0);
            }
        }
    }
}