package LongestPath;

import ui.UIAuxiliaryMethods;
import ui.UserInterfaceFactory;
import java.util.Scanner;
import ui.LabyrinthUserInterface;
import java.io.PrintStream;

public class LongestPath {
    //Name: Amir Abounnasr
    //Assignment: LongestPath
    //Date: 17/10/16

    PrintStream out;

	public final int LABYRINTH_HEIGHT = 24;
	public final int LABYRINTH_WIDTH = 32;
	public final int SEARCH_SPEED = 1;

	public final Coordinate WEST = new Coordinate(-1,0);
	public final Coordinate SOUTH = new Coordinate(0,1);
	public final Coordinate EAST = new Coordinate(1,0);
	public final Coordinate NORTH = new Coordinate(0,-1);

	public final CoordinateRow DIRECTIONS = new CoordinateRow();

	LabyrinthUserInterface ui;
	Scanner in;

	Coordinate currentWall;
	Coordinate startCoordinate;
	Coordinate finishCoordinate;
	Coordinate currentCoordinate;

	CoordinateRow wall = new CoordinateRow();
	CoordinateRow visitedPath = new CoordinateRow();
	CoordinateRow currentLongestPath = new CoordinateRow();
	CoordinateRow successfulPath = new CoordinateRow();

	LongestPath(){

		out = new PrintStream(System.out);

		DIRECTIONS.addCoordinate(WEST);
		DIRECTIONS.addCoordinate(SOUTH);
		DIRECTIONS.addCoordinate(EAST);
		DIRECTIONS.addCoordinate(NORTH);

		UserInterfaceFactory.enableLowResolution(true);
		ui = UserInterfaceFactory.getLabyrinthUI(LABYRINTH_WIDTH,LABYRINTH_HEIGHT);

	}

	void placeWalls(CoordinateRow wall){

		for (int i = 0; i < wall.numberOfElements; i++){

			ui.place(wall.coordinateRow[i].x, wall.coordinateRow[i].y, LabyrinthUserInterface.WALL);

		}

	}

	void parseWallCoordinate(Scanner wallCoordinateScanner){

		int x,y;

		wallCoordinateScanner.delimiter();

		x = wallCoordinateScanner.nextInt();
		y = wallCoordinateScanner.nextInt();

		currentWall = new Coordinate(x,y);

		wall.addCoordinate(currentWall);

	}

	void parseWallCoordinates(Scanner wallCoordinatesScanner){

		Scanner wallCoordinateScanner;

		String wallCoordinate;

		while(wallCoordinatesScanner.hasNextLine()){

			wallCoordinate = wallCoordinatesScanner.nextLine();
			wallCoordinateScanner = new Scanner(wallCoordinate);
			parseWallCoordinate(wallCoordinateScanner);
		}

		placeWalls(wall);

	}

	void encircleFinishPosition(Coordinate finishCoordinate){

		ui.encircle(finishCoordinate.x,finishCoordinate.y);

	}

	Coordinate parseFinishCoordinate(Scanner finishCoordinateScanner){

		int x,y;

		finishCoordinateScanner.delimiter();

		x = finishCoordinateScanner.nextInt();
		y = finishCoordinateScanner.nextInt();

		finishCoordinate = new Coordinate(x,y);

		encircleFinishPosition(finishCoordinate);

		return finishCoordinate;

	}

	void placePath(Coordinate coordinate){

		ui.place(coordinate.x, coordinate.y, LabyrinthUserInterface.PATH);

	}

	Coordinate parseStartCoordinate(Scanner startCoordinateScanner){

		int x,y;

		startCoordinateScanner.delimiter();

		x = startCoordinateScanner.nextInt();
		y = startCoordinateScanner.nextInt();

		startCoordinate = new Coordinate(x,y);

		placePath(startCoordinate);

		visitedPath.addCoordinate(startCoordinate);
		currentCoordinate = startCoordinate;

		return startCoordinate;

	}

	void parseInput(){

		in = UIAuxiliaryMethods.askUserForInput().getScanner();

		Scanner startCoordinateScanner;
		Scanner finishCoordinateScanner;
		Scanner wallCoordinatesScanner;

		String startCoordinate;
		String finishCoordinate;
		String wallCoordinates;

		in.useDelimiter("=");

		while(in.hasNext()){

			startCoordinate = in.next();
			startCoordinateScanner = new Scanner(startCoordinate);
			parseStartCoordinate(startCoordinateScanner);

			finishCoordinate = in.next();
			finishCoordinateScanner = new Scanner(finishCoordinate);
			parseFinishCoordinate(finishCoordinateScanner);

			wallCoordinates = in.next();
			wallCoordinatesScanner = new Scanner(wallCoordinates);
			parseWallCoordinates(wallCoordinatesScanner);

		}

		ui.showChanges();

	}

	void restorePrevious(){

		ui.place(currentCoordinate.x, currentCoordinate.y, LabyrinthUserInterface.EMPTY);
		ui.wait(SEARCH_SPEED);
		ui.showChanges();

		visitedPath.removeCoordinate();

		if(visitedPath.numberOfElements > 0){

			currentCoordinate.x = visitedPath.coordinateRow[visitedPath.numberOfElements-1].x;
			currentCoordinate.y = visitedPath.coordinateRow[visitedPath.numberOfElements-1].y;

		}

	}

	void printLongestPath(){

		for(int i = 0; i < currentLongestPath.numberOfElements; i++){

			ui.place(currentLongestPath.coordinateRow[i].x, currentLongestPath.coordinateRow[i].y, LabyrinthUserInterface.PATH);

		}

		ui.printf("Longest Path Length: %d", currentLongestPath.numberOfElements);

		ui.showChanges();
	}

	void findPath(){

		if(currentCoordinate.isEqual(finishCoordinate)){

			if(visitedPath.numberOfElements > currentLongestPath.numberOfElements){

				currentLongestPath = new CoordinateRow();

				for (int j = 0; j < visitedPath.numberOfElements; j++){

					currentLongestPath.addCoordinate(visitedPath.coordinateRow[j]);

				}


			}

		}

		for (int i = 0; i < DIRECTIONS.numberOfElements; i++){

			int x = currentCoordinate.x + DIRECTIONS.coordinateRow[i].x;
			int y = currentCoordinate.y + DIRECTIONS.coordinateRow[i].y;

			Coordinate temporaryCoordinate = new Coordinate(x,y);

			if (!wall.contains(temporaryCoordinate) && !visitedPath.contains(temporaryCoordinate)){

				currentCoordinate = temporaryCoordinate;

				visitedPath.addCoordinate(currentCoordinate);

				ui.place(currentCoordinate.x, currentCoordinate.y, LabyrinthUserInterface.PATH);

				ui.wait(SEARCH_SPEED);

				ui.showChanges();

				findPath();

				restorePrevious();

			}

		}

	}

	void start(){

		parseInput();
		findPath();
		printLongestPath();

	}

	public static void main(String[] args) {
		new LongestPath().start();

	}

}