// NumberTranslate.java

package net.jtank.protocol;

/**
 * A toolset for converting digital numbers, eg "1" into their English equivalent, eg "one".
 *
 * <p>Title: Number Translate</p>
 * <p>Description:  Translate was created by William Denniss in March 2001.  The original DOS QBASIC version was created in 1998.</p>
 * <p>Basically, this class takes long integer, and returns the translation in words of that number as a String.
 * It was developed for the NumberTranslator application by William Denniss, but could be used in other programs.</p>
 *
 * <p>An example of this class in use can be found in the Tank Software program NumberTranslator (it is called Translate in that program)</p>
 * <p>Copyright: Copyright (c) 2002, free non-commercial use is permitted.</p>
 * <p>Company: Tank Software</p>
 *
 * @author William Denniss
 * @version 1.0 - March 2001
 */
public class NumberTranslate {


	public static final String PROGRAM_NAME = "Number";
	public static final String VERSION_NUMBER = "2.1";
	public static final String DATE_CREATED = "March 2001";
	public static final String DATE_UPDATED = "13 April 2001";
	public static final String AUTHOR = "William Denniss";

    /**
	 * Translate a long number that is in the range 0 to 999,999,999,999,999,999.
	 * This method divides the long integer into groups of three, gets the translations of those, and adds them together.
     * For more details regarding the rules it uses, look at "NumberTranslator - Naming Convention.txt"
     *
     * @param longNum The number to be translated into words
     * @return The String representation the English representaiton of the number.
     */
	public static String longTranslation (long longNum) {

		if (longNum == 0) return "zero";

		String longTransCurrent = "";
		String largeNumberTrans = "";

		int[] numberParts = new int [6]; //A long integer has 6x3 parts (eg. 150,213,125)

		String conversion;

		for (int i=5; i >= 0; i--) {
			numberParts[i]= Integer.parseInt(longNum % 1000 + ""); //extract the last 3 digits

			longNum = longNum / 1000; //trim the last 3 digits


		}

		// Process all of the groups, and add them together

		for (int i=0; i <=5; i++) {
			switch (i) {
			 case 0:
				 largeNumberTrans = " quadrillion";
				 	//	check to see if an and is nessesary

				 if (numberParts[1] == 0 && numberParts[2] == 0 && numberParts[3] == 0 && numberParts[4] == 0 && numberParts[5] != 0 && numberParts[5] / 100 == 0) {
				 	largeNumberTrans = largeNumberTrans + " and ";
				 } else if (numberParts[1] != 0 || numberParts[2] != 0) {
				 	//	check to see if a space is nessesary

				 	largeNumberTrans = largeNumberTrans + ", ";
				 }
				 break;

			 case 1:
				 largeNumberTrans = " trillion";
				 	//	check to see if an and is nessesary

				 if (numberParts[2] == 0 && numberParts[3] == 0 && numberParts[4] == 0 && numberParts[5] != 0 && numberParts[5] / 100 == 0) {
				 	largeNumberTrans = largeNumberTrans + " and ";
				 } else if (numberParts[1] != 0 || numberParts[2] != 0) {
				 	//	check to see if a space is nessesary

				 	largeNumberTrans = largeNumberTrans + ", ";
				 }
				 break;

			 case 2:
				largeNumberTrans = " billion";
					//	check to see if an and is nessesary

				if (numberParts[3] == 0 && numberParts[4] == 0 && numberParts[5] != 0 && numberParts[5] / 100 == 0) {
					largeNumberTrans = largeNumberTrans + " and ";
				} else if (numberParts[1] != 0 || numberParts[2] != 0) {
					//	check to see if a space is nessesary

					largeNumberTrans = largeNumberTrans + ", ";
				}
				break;


			 case 3:
				largeNumberTrans = " million";
					//	check to see if an and is nessesary

				if (numberParts[4] == 0 && numberParts[5] != 0 && numberParts[5] / 100 == 0) {
					largeNumberTrans = largeNumberTrans + " and ";
				} else if (numberParts[4] != 0 || numberParts[5] != 0) {
					//	check to see if a space is nessesary

					largeNumberTrans = largeNumberTrans + ", ";
				}
				break;

			 case 4:
				largeNumberTrans = " thousand";
					//	check to see if an and is nessesary

				if (numberParts[5] != 0 && numberParts[5] / 100 == 0) {
					largeNumberTrans = largeNumberTrans + " and ";
				} else if (numberParts[5] != 0){
					//	check to see if a space is nessesary

					largeNumberTrans = largeNumberTrans + ", ";
				}
				break;
			 case 5:
				largeNumberTrans = "";
				break;
			}


			if (numberParts[i] != 0) longTransCurrent = longTransCurrent +
				tripleTranslation(numberParts[i]) + largeNumberTrans;
		}
		return 	longTransCurrent;
	}

	/**
	 *Translate a three digit number.
	 *For example: an input of '123' would return "one hundred and twenty-three"
	 * @param tripleNum The number to be translated
	 * @return The translation of tripleNum
	 */
	public static String tripleTranslation (int tripleNum) {


		String tripleTransCurrent = "";

		// Translate the first digit

		if (tripleNum > 99) {
			tripleTransCurrent = singleTranslation(tripleNum / 100);
			tripleTransCurrent = tripleTransCurrent + " hundred";
			if (tripleNum % 100 != 0) tripleTransCurrent = tripleTransCurrent + " and ";
		}

		// Translate the last 2 digits

		switch ((tripleNum % 100) / 10) { //extract the middle digit

		 case 0:
		 	// This number, has no second digit

			tripleTransCurrent = tripleTransCurrent + singleTranslation(tripleNum % 10);
			break;

		 case 1:
		 	// This number's middle digit is one, therefore it is a "teen" number and special rules apply
			switch (tripleNum % 100) { //extract the last 2 digits

			 case 10:
				tripleTransCurrent = tripleTransCurrent + "ten";
				break;
			 case 11:
				tripleTransCurrent = tripleTransCurrent + "eleven";
				break;
			 case 12:
				tripleTransCurrent = tripleTransCurrent + "twelve";
				break;
			 case 13:
				tripleTransCurrent = tripleTransCurrent + "thirteen";
				break;
			 case 14:
				tripleTransCurrent = tripleTransCurrent + "fourteen";
				break;
			 case 15:
				tripleTransCurrent = tripleTransCurrent + "fifteen";
				break;
			 case 16:
				tripleTransCurrent = tripleTransCurrent + "sixteen";
				break;
			 case 17:
				tripleTransCurrent = tripleTransCurrent + "seventeen";
				break;
			 case 18:
				tripleTransCurrent = tripleTransCurrent + "eighteen";
				break;
			 case 19:
				tripleTransCurrent = tripleTransCurrent + "nineteen";
				break;
			}
			break;

		default:
			// This numbers middle digit is not 0 or 1, therefor these rules apply

			switch ((tripleNum % 100) / 10) {
			 case 2:
				tripleTransCurrent = tripleTransCurrent + "twenty";
				break;
			 case 3:
				tripleTransCurrent = tripleTransCurrent + "thirty";
				break;
			 case 4:
				tripleTransCurrent = tripleTransCurrent + "fourty";
				break;
			 case 5:
				tripleTransCurrent = tripleTransCurrent + "fifty";
				break;
			 case 6:
				tripleTransCurrent = tripleTransCurrent + "sixty";
				break;
			 case 7:
				tripleTransCurrent = tripleTransCurrent + "seventy";
				break;
			 case 8:
				tripleTransCurrent = tripleTransCurrent + "eighty";
				break;
			 case 9:
				tripleTransCurrent = tripleTransCurrent + "ninety";
				break;
			 case 0:
				break;
			}

	 		// Add the last digit, and separate the two words with a dash

			if (tripleNum % 10 !=0) tripleTransCurrent = tripleTransCurrent + "-" + singleTranslation(tripleNum % 10);

			break;
		}
		return tripleTransCurrent;

	}

	/**
	 * Translate an single digit number.
	 * For example: an input of '1' would return "one"
	 * @param singleNum The number to be translated
	 * @return The translation of singleNum
	 */
	public static String singleTranslation (int singleNum) { //translates a one digit number


		String singleTransCurrent = "";

		switch (singleNum) {
		 case 1:
			singleTransCurrent = "one";
			break;
		 case 2:
			singleTransCurrent = "two";
			break;
		 case 3:
			singleTransCurrent = "three";
			break;
		 case 4:
			singleTransCurrent = "four";
			break;
		 case 5:
			singleTransCurrent = "five";
			break;
		 case 6:
			singleTransCurrent = "six";
			break;
		 case 7:
			singleTransCurrent = "seven";
			break;
		 case 8:
			singleTransCurrent = "eight";
			break;
		 case 9:
			singleTransCurrent = "nine";
			break;
		}

		return singleTransCurrent;
	}

}