//********************************************************************
//  Keyboard.java       Author: Lewis and Loftus
//
//  Facilitates keyboard input by abstracting details about input
//  parsing, conversions, and exception handling.
//********************************************************************

package MAP0809;

import java.io.*;
import java.util.*;

public class Keyboard {
	// ************* Error Handling Section **************************

	private static boolean printErrors = true;

	private static int errorCount = 0;

	// -----------------------------------------------------------------
	// Returns the current error count.
	// -----------------------------------------------------------------

	public static int getErrorCount() {
		return errorCount;
	}

	// -----------------------------------------------------------------
	// Resets the current error count to zero.
	// -----------------------------------------------------------------

	public static void resetErrorCount(int count) {
		errorCount = 0;
	}

	// -----------------------------------------------------------------
	// Returns a boolean indicating whether input errors are
	// currently printed to standard output.
	// -----------------------------------------------------------------
	public static boolean getPrintErrors() {
		return printErrors;
	}

	// -----------------------------------------------------------------
	// Sets a boolean indicating whether input errors are to be
	// printed to standard output.
	// -----------------------------------------------------------------
	public static void setPrintErrors(boolean flag) {
		printErrors = flag;
	}

	// -----------------------------------------------------------------
	// Increments the error count and prints the error message if
	// appropriate.
	// -----------------------------------------------------------------
	private static void error(String str) {
		errorCount++;
		if (printErrors)
			System.out.println(str);
	}

	// ************* Tokenized Input Stream Section ******************

	private static String current_token = null;

	private static StringTokenizer reader;

	private static BufferedReader in = new BufferedReader(
			new InputStreamReader(System.in));

	// -----------------------------------------------------------------
	// Gets the next input token assuming it may be on subsequent
	// input lines.
	// -----------------------------------------------------------------
	private static String getNextToken() {
		return getNextToken(true);
	}

	// -----------------------------------------------------------------
	// Gets the next input token, which may already have been read.
	// -----------------------------------------------------------------
	private static String getNextToken(boolean skip) {
		String token;

		if (current_token == null)
			token = getNextInputToken(skip);
		else {
			token = current_token;
			current_token = null;
		}

		return token;
	}

	// -----------------------------------------------------------------
	// Gets the next token from the input, which may come from the
	// current input line or a subsequent one. The parameter
	// determines if subsequent lines are used.
	// -----------------------------------------------------------------
	private static String getNextInputToken(boolean skip) {
		final String delimiters = " \t\n\r\f";
		String token = null;

		try {
			if (reader == null)
				reader = new StringTokenizer(in.readLine(), delimiters, true);

			while (token == null || ((delimiters.indexOf(token) >= 0) && skip)) {
				while (!reader.hasMoreTokens())
					reader = new StringTokenizer(in.readLine(), delimiters,
							true);

				token = reader.nextToken();
			}
		} catch (Exception exception) {
			token = null;
		}

		return token;
	}

	// -----------------------------------------------------------------
	// Returns true if there are no more tokens to read on the
	// current input line.
	// -----------------------------------------------------------------
	public static boolean endOfLine() {
		return !reader.hasMoreTokens();
	}

	// ************* Reading Section *********************************

	// -----------------------------------------------------------------
	// Returns a string read from standard input.
	// -----------------------------------------------------------------
	public static String readString() {
		String str;

		try {
			str = getNextToken(false);
			while (!endOfLine()) {
				str = str + getNextToken(false);
			}
		} catch (Exception exception) {
			error("Error reading String data, null value returned.");
			str = null;
		}
		return str;
	}

	// -----------------------------------------------------------------
	// Returns a space-delimited substring (a word) read from
	// standard input.
	// -----------------------------------------------------------------
	public static String readWord() {
		String token;
		try {
			token = getNextToken();
		} catch (Exception exception) {
			error("Error reading String data, null value returned.");
			token = null;
		}
		return token;
	}

	// -----------------------------------------------------------------
	// Returns a boolean read from standard input.
	// -----------------------------------------------------------------
	public static boolean readBoolean() {
		String token = getNextToken();
		boolean bool;
		try {
			if (token.toLowerCase().equals("true"))
				bool = true;
			else if (token.toLowerCase().equals("false"))
				bool = false;
			else {
				error("Error reading boolean data, false value returned.");
				bool = false;
			}
		} catch (Exception exception) {
			error("Error reading boolean data, false value returned.");
			bool = false;
		}
		return bool;
	}

	// -----------------------------------------------------------------
	// Returns a character read from standard input.
	// -----------------------------------------------------------------
	public static char readChar() {
		String token = getNextToken(false);
		char value;
		try {
			if (token.length() > 1) {
				current_token = token.substring(1, token.length());
			} else
				current_token = null;
			value = token.charAt(0);
		} catch (Exception exception) {
			error("Error reading char data, MIN_VALUE value returned.");
			value = Character.MIN_VALUE;
		}

		return value;
	}

	// -----------------------------------------------------------------
	// Returns an integer read from standard input.
	// -----------------------------------------------------------------
	public static int readInt() {
		String token = getNextToken();
		int value;
		try {
			value = Integer.parseInt(token);
		} catch (Exception exception) {
			error("Error reading int data, MIN_VALUE value returned.");
			value = Integer.MIN_VALUE;
		}
		return value;
	}

	// -----------------------------------------------------------------
	// Returns a long integer read from standard input.
	// -----------------------------------------------------------------
	public static long readLong() {
		String token = getNextToken();
		long value;
		try {
			value = Long.parseLong(token);
		} catch (Exception exception) {
			error("Error reading long data, MIN_VALUE value returned.");
			value = Long.MIN_VALUE;
		}
		return value;
	}

	// -----------------------------------------------------------------
	// Returns a float read from standard input.
	// -----------------------------------------------------------------
	public static float readFloat() {
		String token = getNextToken();
		float value;
		try {
			value = (new Float(token)).floatValue();
		} catch (Exception exception) {
			error("Error reading float data, NaN value returned.");
			value = Float.NaN;
		}
		return value;
	}

	// -----------------------------------------------------------------
	// Returns a double read from standard input.
	// -----------------------------------------------------------------
	public static double readDouble() {
		String token = getNextToken();
		double value;
		try {
			value = (new Double(token)).doubleValue();
		} catch (Exception exception) {
			error("Error reading double data, NaN value returned.");
			value = Double.NaN;
		}
		return value;
	}
}