/* This is the skeleton of a program that finds the path out of a maze
   in 3 possible ways: recursively, with a stack, and with a queue.
   
   This problem illustrates searching using stacks (depth-first search)
   and queues (breadth-first search), and recursively. 
   
   Laura Toma 
   csci 210 
*/


import java.util.Stack; 
import java.util.LinkedList; 


public class Maze {
    
    final static char C=' ', X='x', S='s', E='e', V='.';
    
    //the maze
    private static char[][] maze = {
	{X, X, X, X, X, X, X, X, X, X}, 
	{X, S, C, C, C, C, C, C, C, X},
	{X, C, C, C, X, C, X, X, C, E},
	{X, C, X, X, X, C, X, X, C, X}, 
	{X, C, C, C, C, X, X, X, C, X},
	{X, X, X, X, C, X, X, X, C, X},
	{X, X, X, X, C, X, C, C, C, X},
	{X, X, C, X, C, X, X, C, C, X}, 
	{X, X, C, C, C, C, C, C, C, X},  
	{X, X, X, X, X, X, C, X, X, X}
    };
    
    //the start position 
    final static int START_I = 1, START_J = 1; 
    
    //the end position 
    final static int END_I = 2, END_J = 9; 


    public static void main(String[] args) {
	
	Maze maze = new Maze();
	maze.print();
	
	System.out.println("\n\nFind a path using a stack: ");
	maze.solveStack();
	
	System.out.println("\n\nFind a path using a queue: ");
	maze.solveQueue();
	
	System.out.println("\n\nFind a path recursively: ");
	maze.solveRec();
	
    }
    

    /* ****************************** */
    //return the size of the maze (assume square)
    public int size() {
	return maze.length;
    }
    
    //print the maze
    public void print() {
	for (int i=0; i<size(); i++) {
	    for (int j=0; j<size(); j++) {
		System.out.print(maze[i][j]);
		System.out.print(' ');
	    }
	    System.out.println();
	}
    }
    
    //mark this position in the maze
    public void mark(int i, int j) {
	assert(isInMaze(i,j)); 
	maze[i][j] = V;
    }
    public void mark(MazePos pos) {
	mark(pos.i(), pos.j());
    }    

    
    public boolean isMarked(int i, int j) {
	assert(isInMaze(i,j)); 
	return (maze[i][j] == V);
    }
    public boolean isMarked(MazePos pos) {
	return isMarked(pos.i(), pos.j()); 
    }


    public boolean isClear(int i, int j) {
	assert(isInMaze(i,j)); 
	return (maze[i][j] != X && maze[i][j] != V);
    }
    public boolean isClear(MazePos pos) {
	return isClear(pos.i(), pos.j());
    }


    //true if cell is within maze 
    public boolean isInMaze(int i, int j) {
	if (i >= 0 && i<size() && j>= 0 && j<size()) return true; 
	else return false;
    }
    //true if cell is within maze 
    public boolean isInMaze(MazePos pos) {
	return isInMaze(pos.i(), pos.j());
    }


    public boolean isFinal( int i, int j) {
	return (i== Maze.END_I && j == Maze.END_J);
    }
    public boolean isFinal(MazePos pos) {
	return isFinal(pos.i(), pos.j());
    }
    
    //creates a new maze that is a copy of the maze
    public char[][] clone() {
	
	char[][] mazeCopy = new char[size()][size()]; 
	for (int i=0; i< size(); i++) 
	    for (int j=0; j<size(); j++)
		mazeCopy[i][j] = maze[i][j];
	return mazeCopy; 
    }
    //restores the maze from the savedMaze 
    public void restore(char[][] savedMaze) {
	for (int i=0; i< size(); i++) 
	    for (int j=0; j<size(); j++)
		maze[i][j] = savedMaze[i][j];
    }
    

   
    
    //THE GOAL IS TO FIND A PATH FROM START TO END 
    
    //**************************************************
    //this solution uses a stack to keep track of possible
    //states/positions to explore; it marks the maze to remember the
    //positions that it's already explored.
    public void solveStack() {
	
    }
    
    
    
    
    //**************************************************
    //this solution uses a QUEUE to keep track of possible
    //states/positions to explore; it marks the maze to remember the
    //positions that it's already explored.
    public void solveQueue() {

	//create an empty queue
	LinkedList<MazePos> queue = new LinkedList<MazePos>(); 

	//create the initial state and put it onto the queue
	MazePos ins = new MazePos(START_I, START_J);
	queue.add(ins); 

	MazePos current; 
	while (!queue.isEmpty()) {

	    //take the first one in the queue
	    current = queue.removeFirst();
	    
	    if (isFinal(current)) break; //we found the solution 

	    //create all succesor of current and if valid add them to the queue

	    MazePos next; 
	    next = current.north(); 
	    if (isInMaze(next) &&  isClear(next))  queue.addLast(next); 

	    

	}
	
    }





    //**************************************************
    //solve using recursion
    public void solveRec() {
	
	//call the recursive solver
	if (solve(new MazePos(START_I, START_J))) 
	    System.out.println("Got it: "); 
	else System.out.println("You're stuck in the maze."); 
	print(); 
	

    }
    
    
    
    
    
    //find a path to exit the maze from this position. Works
    //recursively, by advancing to a neighbor and continuing from
    //there. Returns true if it finds a path, and false otherwise.
    public boolean solve(MazePos pos) {
	
    }
    
    
};



	

class MazePos {
    int i, j; 
	
    public MazePos(int i, int j) {
	this.i = i; 
	this.j = j;
    };
    public int i() { return i;}
    
    public int j() { return j;}
    
    public void print() {
	System.out.println("(" + i + "," + j + ")");
    }
    public MazePos north() {
	return new MazePos(i-1, j);
    }
    public MazePos south() {
	return new MazePos(i+1, j);
    }
    public MazePos east() {
	return new MazePos(i, j+1);
    }
    public MazePos west() {
	return new MazePos(i, j-1);
    }
    
    
};