private static void calculate(String methodOfInputP) {
		//I am creating a string array that will hold the days of the week
		String [] daysArray = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};//I will initialize it with the days of the week
		//I am creating a Duration object array that will hold the different duration object for each day of the week
		Duration [] durationArray = new Duration [7];//I will initialize it with 7 empty elements
		//Now in order to get the users input and put it in the above string, I need a scanner:
		Scanner promptReader = new Scanner(System.in);//<--I create a new Scanner object (which I also imported)
		//I am creating an int variable that will act as a counter for our while loop
		int i = 0;//<--I will initialize it with 0

		/*We will need to throw different errors based on the argument passed in. We could utilize a series of if statements to evaluate each scenario. 
		 * However, a switch statement will be more efficient. We will base each evaluation on the methodOfInputP parameter and then construct our case
		 * accordingly.
		 */

		switch (methodOfInputP) {
		/*If the user's input is either Android or iP we will start welcome the user to the ExerciseCalculator and ask them to enter in their times 
		 * as hh:mm:ss or seconds. So we will chain two cases that is either "Android" or "iP" and then we will print the welcome message to the 
		 * exercise calculator.
		 */
		case "Android":
		case "iP":
			//If the arguments are either Android or iP we will print the welcome message and welcome the user to the ExceriseCalculator
			System.out.println("Hello. Welcome to the ExerciseCalculator. (Input times as hh:mm:ss or seconds).");//<--this prints the welcome message to our ExerciseCalculator
			/*At this point we will need to construct a while loop. This is needed as if the user enters in the wrong type of input we will need to 
			 * re-prompt the user to enter a valid input. If the user enters a valid input then we will exit out of this while loop. Since 
			 * we need 7 inputs for the entire week, we will set the the while loop to run until 7 iterations. We will use this counter 
			 * to dynamically asks the user for the prompts for different days of the week.
			 */
			//We will need to create a while loop that will run for 7 iterations and then break out of the loop once the condition no longer is valid
			while (i < 7) {
				/*At this point we will need to print out different prompts for the different days of the week. If it is Sunday or Saturday 
				 * then we will need to print out a statement that is different than the rest of days of the week. 
				 */
				//So if it is Sunday we will print a different prompt than the rest of the week.
				if (i==0){//<--this will check if we are on the first prompt, which should be Sunday
					//If this is the case then we will print out the corresponding prompt.
					System.out.println("How much time did you exercise on Sunday?");//<--this will be our prompt for Sunday
				//If the day is Saturday then we will have to print a different prompt that is unique to Saturday
				}else if (i==6){//<--this will check if we are on Saturday, or check if we are on the very last prompt
					System.out.println("And on Saturday?");//<--this is the message that we will print if we are on the last prompt
				//If the day we are on is not either Saturday or Sunday then we will print the same message for all those days. The only difference will be day of the week in the prompts
				}else{//<--this will be true if we are not on either Saturday or Sunday.
					/*If we are on a day that isn't either Saturday or Sunday then we will print the corresponding message for that day. Since the 
					 * prompts only vary in the days that is mentioned, i.e "On Monday?" or "On Tuesday ?". We will grab the correct day from a days 
					 * array that will pick the right day from the array for the day we are on.
					 */
					//We will use our counter to grab the correct day from the daysArray and print the correct day in our prompt
					System.out.println("On " + daysArray[i-1] + "?");//<--this statement will grab the correct day form the array and concatenate it to the statement that will print it
				}
				//Now we need to wait for the user's input. The user's input ends when they will hit enter.
				String userInput = promptReader.nextLine();//<--using nextLine() instead of next to include all the white characters that they will potentially enter. (spaces, tabs, etc)
				/*Now we will utilize a private method to ensure that the user's input is valid and that we are getting a correct array of 
				 * values that we can use to evaluate the statements further. The method extractValidPromptInput will return a null if the 
				 * user's input was invalid and doesn't match the necessary conditions set by us. Then we will ask the user to try again 
				 * and re-prompt for that particular day. If it was a valid prompt then we will store that valid prompt into the durationArray. 
				 * We will store the valid prompts starting from Monday as the week begins from Monday. This will also make our calculations 
				 * and finding the minimum value easier later in the program.
				 */
				//We will only continue if the user entered a valid prompt. So we will set our overall if statement to work only if the extractValidPromptInput didn't return a null value
				if (!(extractValidPromptInput(userInput) == null)){
					int[] extractedInput = extractValidPromptInput(userInput);//<--this is our valid user input that is extracted and put into an array
					//We will want to store Sundays input at the end of the durationArray if we are at the prompt for Sunday, this will make calculations easier later on
					if (i==0){//<--this will be true if we are on Sunday's prompt
						/*The extractedInput will contain either an array of 3 ints or 1 int depending on whether the user typed a response as hh:mm:ss 
						 * or simply as seconds. So we will need to feed these ints into the proper duration constructor so that we can create the 
						 * appropriate duration objects.
						 */
						//If the extracted input contains 3 ints as an array then we will feed it to the Duration constructor that takes in 3 ints
						if (extractedInput.length < 4 && extractedInput.length > 1){//<--this will check if the the array contains 3 ints
							durationArray[6] = new Duration(extractedInput[0], extractedInput[1], extractedInput[2]);//<--this will feed those 3 ints to create a duration object and put it in the last position in the array
						}
						//If the extracted input contains only one int in the array, then we will feed this into the Duration constructor that takes in only one int
						if (extractedInput.length <2){//<--this will check if the array contains only one int
							durationArray[6] = new Duration(extractedInput[0]);//<--this will feed those 3 ints to create a duration object and put it in the last position in the array
						}
					}
					//We will want to store the input in the durationArray starting at the 0 position from Monday to Saturday
					else {
						//If the input was entered as hh:mm:ss then we will feed this input into the appropriate Duration object that takes in 3 ints
						if (extractedInput.length < 4 && extractedInput.length > 1){//<--this will check if the the extractedInput array contains 3 ints
							durationArray[i-1] = new Duration(extractedInput[0], extractedInput[1], extractedInput[2]);//<--we will store the duration object in the first position and store subsequent duration objects in the next position of the array
						}
						//If the input that was entered was in seconds, then we will feed this input into the appropriate Duration object that takes in one int
						if (extractedInput.length <2){//<--this will check if the array contains only one int
							durationArray[i-1] = new Duration(extractedInput[0]);//<--this will check if the extractedInput array contains 1 int
						}
					}
					i++;//<--we will increase our counter for the while loop if the user entered a valid input
				//If the user didn't enter a valid prompt then we will ask the user to try again.
				} else {//<--if the user's input isn't valid then we will run this statement
					System.out.println("Please try again.");//<--this is the prompt asking the user to retry entering their input
				}
			}//end of while loop that prompts the user for the an input
			//Once we have the inputs we will tell the user that we are calculating the total duration for the week
			System.out.println("Thanks. Calculating...");//<--this will notify the user that we are calculating the total duration
			/**We will then calculate the total by grabbing each duration from the durationArray and then adding
			 * it to the sum duration object. This will be initialized as 00:00:00. So upon adding the a duration
			 * object to the sum object it will keep increasing and keep a running total of the duration.
			 * Then we will print out the answer.
			 */
			Duration sum = new Duration();//<--we will create our sum duration object using the default constructor. will have the values 0 hours, 0 minutes and 0 seconds
			for (Duration weekday : durationArray) {//<--this enhanced for loop will go through each duration object in out durationArray
				sum = sum.add(weekday);//We will add each duration object to the sum duration object.
			}
			//Our sum duration object should now reflect the total for all the duration objects in our durationArray, we will get the hours, minutes and seconds from the sum duration object
			System.out.println("Your total exercise time this week is " + sum.getHours() + " hours, " + sum.getMinutes() +" minutes, " + sum.getSeconds() + " seconds.");//<--this will print out the total concatenating the values from the sum duration object into this string

			/*Now we will need to calculate the lowest duration object that exists in our durationArray. My algorithim is this:
			 * 
			 * 1. Create and initialize a minimum duration object using the first element in our durationArray
			 * 2. Create a variable to hold the duration that is being compared to our set minimum
			 * 3. Loop through the array and check if our minimum is still lower than the object we are comparing it to
			 * 4. If the duration object we are comparing against the minimum duration object is indeed lower, then we will set that object 
			 * to be the new minimum.
			 * 5. We will be utilizing the compareTo method form the duration class, if this method returns something that is greater than 
			 * 0 then we will set the minimum to duration object that is being evaluated. We will also note the minimum duration day by 
			 * grabbing the corresponding day from our daysArray.
			 */
			//We will initialize a duration object called minimum using the first duration object present in our durationArray
			Duration minimum = durationArray[0];//<--this duration object called minimum is initialized with the first duration object from the durationArray
			//We will also initialize a duration object called beingCompared that will hold the duration object at location k as indicated by our for loop
			Duration beingCompared = new Duration ();//<--this duration object called minimum is initialized with the default values
			//We will need a string that will contain the day that corresponds to the day the user worked out least
			String minimumDay = "";//<--this string will be initialized with an empty string
			//We will also need a variable that holds the output of the compareTo method. The output of compareTo will be an int
			int comparison = 0;//<--we will initialize this variable with 0
			//We will use a for loop to iterate through the durationArray and check if the value being iterated is the minimum
			for (int k = 1; k < durationArray.length; k++) {//<--this will go through each element in the durationArray until the last element in the durationArray
				//We will set the current element in the array to value we are comparing to
				beingCompared = durationArray[k];
				//We will store the output of the comparison between our minimum duration object and object we are comparing to in this int variable
				comparison = minimum.compareTo(beingCompared);
				//If the object we are comparing is lower than our minimum duration object, we will set that duration object to be the new minimum
				if (comparison > 0){//<--this checks if the duration object is lower than the minimum
					minimum = durationArray[k];//<<--we will set the duration object we were comparing to be the new minimum
					minimumDay = daysArray[k];//<<--we will also set the minimum day as the k value would represent the same element in both arrays
				}
			}
			//After we have gone through finding the lowest duration object we will print out the duration that the user worked out the least
			System.out.println("You didn't exercise enough on " + minimumDay + ".");//<--this will print out the statement of when the user worked out the least
			break;//<--then we will break out and terminate the program
			/*If the user entered the other three valid prompts we will have to throw them an error stating that the argument they passed in hasn't 
			 * been implemented yet. So if the arguments Watch, Wristband or CardioMachine is passed then we will print out a message stating so.
			 */
			//If the arguments passed in matches either Watch, Wristband or CardioMachine we will print a message
		case "Watch":
		case "Wristband":
		case "CardioMachine":
			System.out.println("***** This input method has not yet been implemented");//<--we will print this message
			break;//<--then we will break out and terminate the program
			/*If the user enters something else than the valid arguments listed. Then we will also have to handle this case and throw the appropriate 
			 * message. To handle all the other cases we will utilize the default case and print the appropriate message.
			 */
		default://<--this will be evaluated if it doesn't match any of the above cases
			System.out.println("***** Unrecognized input method");//<--if so we will print this error message 
			break;//<--then we will break out and terminate the program

		}//end of our Switch Statement
		promptReader.close();//we will close our scanner that reads the user's input as we no longer need it

	}//end of private method calculate