/**
 *  Maze1.java
 *  CIS 260
 *  David Klick
 *  2012-03-09
 *    
 *  This class creates a maze.
 * 
 *  @author Dave Klick
 *  @version 1.0 2012-03-09
*/

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
import java.util.Stack;

public class Maze1 {
    private Random rnd = new Random();
    private static int ROWS = 30, COLS = 30;
    private Board b = null;
    private Cell startCell = null, endCell = null;

    public Maze1() {
        b = new Board(ROWS, COLS);
        Random rnd = new Random();

        // *****                                  *****
        // ***** THIS SECTION MUST BE IMPLEMENTED *****
        // *****                                  *****

        System.out.println("All cells on board visited: " + allCellsVisited());
        System.out.println("All boundaries correct: " + allBoundariesCorrect());
        System.out.println("All cells reachable: " + allCellsReachable());
        b.setStartCell(b.getCell(0, rnd.nextInt(COLS)));
        b.setEndCell(b.getCell(ROWS-1, rnd.nextInt(COLS)));
        System.out.println(b);
    }
    
    public static void main(String[] args) {
        if (args.length > 2 || (args.length == 1 && (args[0].matches("--?([hH]|[hH][eE][lL][pP])")))) {
            System.err.println("Usage: java Maze1 [rows [columns]]");
            System.exit(1);
        }
        try {
            if (args.length > 1) COLS = Integer.parseInt(args[1]);
            if (args.length > 0) ROWS = Integer.parseInt(args[0]);
        } catch (NumberFormatException e) {
            System.err.println("Illegal integer argument");
            System.exit(2);
        }
        new Maze1();
    }
    
    /**
     *  Method used to test a maze to make sure all cells
     *  have been visited.
     *  
     *  @return true if all cells have been visited, otherwise false 
     *  
     */
    private boolean allCellsVisited() {
        for (int r=0; r<ROWS; r++) {
            for (int c=0; c<COLS; c++) {
                if (!b.getCell(r,c).isVisited()) return false;
            }
        }
        return true;
    }

    /**
     *  Method used to test a maze to make sure all edges
     *  on boundaries exist.
     *  
     *  @return true if all edge boundaries exist, otherwise false 
     *  
     */
    private boolean allBoundariesCorrect() {
        for (int r=0; r<ROWS; r++) {
            if (!b.getCell(r,0).hasEdge(Direction.WEST)
                || !b.getCell(r,0).hasWall(Direction.WEST)
                || !b.getCell(r,COLS-1).hasEdge(Direction.EAST)
                || !b.getCell(r,COLS-1).hasWall(Direction.EAST)) return false;
        }
        for (int c=0; c<COLS; c++) {
            if (!b.getCell(0,c).hasEdge(Direction.NORTH)
                || !b.getCell(0,c).hasWall(Direction.NORTH)
                || !b.getCell(ROWS-1,c).hasEdge(Direction.SOUTH)
                || !b.getCell(ROWS-1,c).hasWall(Direction.SOUTH)) return false;
        }
        return true;
    }
    
    /**
     *  Method used to test a maze to make sure all cells
     *  are reachable.
     *  
     *  @return true if all cells reachable, otherwise false 
     *  
     */
    private boolean allCellsReachable() {
        int r, c;
        Cell cell = null, cell2 = null;
        // Set all cells to a unique value (starting with 1) and unvisit them
        b.clearVisited();
        for (r=0; r<ROWS; r++) {
            for (c=0; c<COLS; c++) {
                b.getCell(r,c).setValue(r*COLS+c+1);
            }
        }
        
        // Now keep reducing connected cells to lowest value.
        // If all are connected, then all cells should end up as 1.
        boolean changed = true, modify = false;
        ArrayList<Direction> lst = new ArrayList<Direction>();
        int min, v = 0;
        while (changed) {
            changed = false;
            for (r=0; r<ROWS; r++) {
                for (c=0; c<COLS; c++) {
                    modify = false;
                    cell = b.getCell(r,c);
                    lst = b.getConnectedNeighbors(cell);
                    // Get minimum value for connected cells
                    min = v = cell.getValue();
                    for (Direction d: lst) {
                        v = b.getAdjacentCell(cell, d).getValue();
                        if (v < min) {
                            modify = true;
                            min = v;
                        }
                    }
                    // Change values in connected cells if needed
                    if (modify) {
                        changed = true;
                        cell.setValue(min);
                        for (Direction d: lst) b.getAdjacentCell(cell, d).setValue(min);
                    }
                }
            }
        }
        // Now find out if all cells have value 1 (all connected)
        for (r=0; r<ROWS; r++) {
            for (c=0; c<COLS; c++) {
                if (b.getCell(r,c).getValue() != 1) return false;
            }
        }
        return true;
    }
}