/* "Copyright (c) 2012 by Fritz Sieker."
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written
 * agreement is hereby granted, provided that the above copyright notice
 * and the following two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHOR
 * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
 * BASIS, AND THE AUTHOR NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT,
 * UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.NoSuchElementException;
import java.io.FileNotFoundException;

/** This class provides code for testing the classes <code>MyXXX.java</code>
 * that you will complete. Do <b>NOT</b> change anything or add anything
 * to this class
 */

public abstract class AssignX extends Shell
{
  /** Determine if the denominator evenly divides the numerator. If a = b/c
   * (in integers) and c divides b evenly, then ac = b.
   * @param numerator - <b>any</b> integer
   * @param denominator <b>any</b> integer
   * @return <code>true</code> if <code>denominator</code> evenly divides
   * <code>numerator</code>. Otherwise, return <code>false</code>.
   */
  public abstract boolean divides (int numerator, int denominator);

  /** Find all elements of the list that are evenly divisible by the denominator
   * @param list - an array of integer values
   * @param denominator <b>any</b> integer
   * @return a list (possibly empty) containing <b>only</b> those elements
   * that are evenly divisible by the <code>denominator</code>. The values
   * in the returned list <b>must</b> be in the same order as the values occur
   * in the parameter <code>list</code>.
   */
  public abstract int[] findMultiples (int[] list, int denominator);

  /** Count the number of words and the number of lines in a file.
   * If the file does not exist, print 0 for both values. The output should be
   * the number of lines followed by a blank followed by the number of words
   * followed by a newline. For this assignment, a word is any group of
   * characters. Thus 3.14. is a word. To check you answer, you may use the
   * <code>wc</code> command from a terminal shell.
   * @param fileName - the name of the file to process.
   */
  public abstract void wordCount (String fileName);

  /** Merge two sorted lists to produce a sorted list containing all the values
   * from both lists. Duplicates are allowed. You <b>must</b> handle
   * <b>all</b> possible values for the lists, including empty/null lists.
   * You many not use any <code>java</code> sort methods. If either of the 
   * lists is <code>null</code>, return the other list as the answer.
   * @param list1 - an array of sorted values
   * @param list2 - another array of values
   * @return a sorted list containing the elements from both lists.
   */
  public abstract int[] merge (int[] list1, int[] list2);

  /** Given a list of names, print out all combinations of the names taken
   * three at a time. If the list has too few elements, don't print anything.
   * Names <b>must</b> occur in the same order that they
   * appear in the list. So, if the list contains the names <code>Kennedy,
   * Johnson, Nixon, Ford</code>, you program prints:
   * <p><pre>
   * [Kennedy, Johnson, Nixon]
   * [Kennedy, Johnson, Ford]
   * [Kennedy, Nixon, Ford]
   * [Johnson, Nixon, Ford]
   * </pre>
   * <p>Put the values in an <code>array</code> and then use the
   * <code>Arrays.toString()</code> method to print the results, one per line.
   * @param list - a list of name.
   */
  public abstract void trio (String[] list);

  /** Display a list of commands useful for testing the classes you will
   * complete for this assignment.
   * The commands are:
   * <ul>
   * <li><b>div</b> Determine if one value evenly divides another
   * <li><b>merge</b> merge two ordered lists
   * <li><b>multiples</b> find values divisible by another value
   * <li><b>trio</b> find combinations of three names
   * <li><b>wc</b> find the number of lines and words in a file.
   * </ul>
   */
   public void showHelp() {
     super.showHelp();
     System.out.println("AssignmentX commands:");
     System.out.println(" div <numerator> <denominator>");
     System.out.println(" merge <csvListOfValues> <csvListOfValues>");
     System.out.println(" multiples <csvListOfValues> <denominator>");
     System.out.println(" trio <csvListOfNames>");
     System.out.println(" wc <fileName>");
     System.out.println();
   }
   
   /** Process one command for this assignment.*/
   public void processOneCommand (String cmd, String params)
       throws FileNotFoundException, NoSuchElementException
   {
     Scanner scan = new Scanner(params);
     
     switch (cmd) {
       case "div": {
           // normally would simply print returned array. This code illustrates
           // use of Shell.format()
           int i1 = scan.nextInt();
           int i2 = scan.nextInt();
           System.out.println(format("divides(%d, %d) --> %b", i1, i2, 
                                                           divides(i1, i2)));
           break;
       }
       case "merge": {
           // normally would simply print returned array. This code illustrates
           // use of Shell.format() with arrays
           int[] a1 = getIntArray(scan);
           int[] a2 = getIntArray(scan);
           System.out.println(format("merge(%s, %s) --> %s", a1, a2,
                                                             merge(a1, a2)));
           break;
       }
       case "multiples": {
           // normally would simply print returned array. This code illustrates
           // use of Shell.format() with arrays
           int[] ia = getIntArray(scan);
           int   i  = scan.nextInt();
           System.out.println(format("findMultiples(%s, %d) --> %s", ia, i,
                                      findMultiples(ia, i)));
           break;
       }
       case "trio":
           trio(getStrArray(scan));
           break;
       case "wc":
           wordCount(scan.next());
           break;
       default:  // See if super class can handle it
           super.processOneCommand(cmd, params);
     }

     scan.close();
  }

} // end of class