/* Title: FTS_Quiz.java
** For: CMPS 134
** Author: P.M.J., R.W.M.
**
** This Java application contains several methods that are for the purpose of 
** modifying and retrieving information from a Field-Terminated String (FTS).
** An FTS is a character string that, typically, contains several related
** pieces of information, each referred to as a "field".  So that the beginning
** and ending of each field can be found unambiguously, a "terminator" character
** (or string) appears immediately after each field.  For the purposes of this
** program, it is assumed that whatever character is assigned to the DELIMITER
** constant (i.e., final variable) plays the role of the terminator.
** 
** As an example, the string 
**
**        "R01234567;Brown;Charlie;charlie.brown@scranton.edu;" 

** (in which the semicolon plays the role of the terminator) is an FTS 
** containing four fields, namely "R01234567", "Brown", "Charlie",
** and "charlie.brown@scranton.edu".  
*/
public class FTS_Quiz {

   private static final char DELIMITER = ';';

   /* The main() method is for the purpose of testing the reverseOf1()
   ** and reverseOf2() methods, which are solutions to the problem posed
   ** in the quiz.
   */
   public static void main(String[] args) {
      String fts = args[0];      // args[0] is the command line argument
      System.out.println("reverseOf1() being applied to " + quoted(fts));
      String fts_reverse1 = reverseOf1(fts);
      System.out.println("\nreverseOf1() maps " + quoted(fts) + " to " +
                         quoted(fts_reverse1));

      System.out.println("\n\nreverseOf1() being applied to " + quoted(fts));
      String fts_reverse2 = reverseOf2(fts);
      System.out.println("\nreverseOf2() maps " + quoted(fts) + " to " +
                         quoted(fts_reverse2));
   }
   
   
   /* Returns the given string augmented with a leading and trailing
   ** double quote character.
   */
   public static String quoted(String s) {
      return "\"" + s + "\"";
   }


   // What remain are the methods of interest.
   // ----------------------------------------
   
   /* Given an FTS, returns the number of fields in it.
   */
   public static int numberOfFields(String fts) {
      int result = 0;
      for(int index = 0; index != fts.length(); index++) {
         if(fts.charAt(index) == DELIMITER) {
            result = result + 1;
         }
      }
      return result;
   }

   /* Given an FTS and an integer i, returns the character position, within 
   ** the FTS, at which its i-th field begins.  Fields are numbered starting
   ** at zero and going left to right.
   ** Example: In the FTS "R01234567,Brown,Charlie,charlie.brown@scranton.edu",
   ** fields #0, #1, #2, and #3 begin, respectively, at positions 0, 10, 16,
   ** and 24.
   **
   ** Pre-condition: 0 <= i < numberOfFields(fts)
   */
   private static int indexOfField(String fts, int i) {
      int start = 0;;
      for(int fieldNumber=0; fieldNumber<i; fieldNumber++) {
         start = fts.indexOf(DELIMITER,start) + 1;
      }
      return start;
   }
   
   /* Given an FTS and an integer i, returns the i-th field within that FTS.
   ** Fields are numbered starting at zero and going left to right.
   **
   ** Pre-condition: 0 <= i < numberOfFields(fts)
   */
   public static String getField(String fts, int i) {
      String result = "";
      int start = indexOfField(fts,i);
      int next = fts.indexOf(DELIMITER,start);
      result = fts.substring(start,next);
      return result;
   }
   
   /* Given an FTS, an integer i, and a "replacement field", returns a new 
   ** FTS that is obtained from the given FTS by replacing its i-th field by 
   ** the given replacement field.
   ** Pre-condition: 0 <= i < numberOfFields(fts)
   */
   public static String setField(String fts, int i, String replField) {
      String result = "";
      int start = indexOfField(fts,i);
      int next = fts.indexOf(DELIMITER,start);
      result = fts.substring(0,start) + replField + fts.substring(next);
      return result;
   }
   
   /* Given an FTS and an integer i, returns a new FTS that is obtained from
   ** the given FTS by removing its i-th field.
   ** Pre-condition: 0 <= i < numberOfFields(fts)
   */
   public static String removeField(String fts, int i) {
      String result = "";
      int start = indexOfField(fts,i);
      int next = fts.indexOf(DELIMITER,start);
      result = fts.substring(0,start) + fts.substring(next+1);
      return result;
   }
   
   /* Given an FTS and an integer i, returns a new FTS that is obtained
   ** from the given one by inserting the empty string as its i-th field.
   ** The i-th, (i+1)-st, (i+2)-nd, etc., fields in the given FTS are the
   ** (i+1)-st, (i+2)-nd, (i+3)-rd, etc., fields in the returned FTS.
   ** 
   ** Pre-condition: 0 <= i <= numberOfFields(fts)
   */
   public static String insertField(String fts, int i) {
      String result = "";
      int start = indexOfField(fts,i);
      result = fts.substring(0,start) + DELIMITER + fts.substring(start);
      return result;
   }
   
   /* Given an FTS, an integer i, and a "new field", returns a new FTS that
   ** is obtained from the given one by inserting the new field as its i-th
   ** field.  The i-th, (i+1)-st, (i+2)-nd, etc., fields in the given FTS are 
   ** the (i+1)-st, (i+2)-nd, (i+3)-rd, etc. fields in the returned FTS.
   **
   ** Pre-condition: 0 <= i <= numberOfFields(fts)
   */
   public static String insertField(String fts, int i, String newField) {
      String result = "";
      result = setField(insertField(fts,i),i,newField);
      return result;
   }


   /* Given an FTS, returns a new FTS having the same fields as the given
   ** one, but in the opposite order.
   ** Algorithm: Let the given FTS be x_0;x_1;x_2;...;x_n.
   ** This version employs a loop each iteration of which "adds" one more
   ** field to beginning of the FTS under construction, so that, after the
   ** k-th loop iteration, the FTS under construction has value
   ** x[k-1];x[k-2];x[k-3]; ... ;x[0];
   */
   public static String reverseOf1(String fts) {
      final int N = numberOfFields(fts);
      String result = "";
      for (int k=0; k != N; k = k+1) {
         // place the k-th field of fts at the beginning of 'result'
         String fieldToInsert = getField(fts,k);
         //result = fieldToInsert + ";" + result;
         // alternative having same effect as the line above:
          result = insertField(result, 0, fieldToInsert);

         //for debugging purposes:
         System.out.println("result: " + result);
      }   
      return result;
   }

   /* Given an FTS, returns a new FTS having the same fields as the given
   ** one, but in the opposite order.
   ** Algorithm: Let the given FTS be x_0;x_1;x_2;...;x_n.
   ** This version employs a loop each iteration of which "adds" one more
   ** field to end of the FTS under construction, so that, after the
   ** k-th loop iteration, the FTS under construction has value
   ** x[n];x[n-1];x[n-2]; ... ;x[n-k+1];
   */
   public static String reverseOf2(String fts) {
      final int N = numberOfFields(fts);
      String result = "";
      for (int k=0; k != N; k = k+1) {
         // place field N-1-k of fts at the end of 'result'
         String fieldToInsert = getField(fts,N-1-k);
         //result = result + fieldToInsert + ";";
         // alternative having same effect:
         result = insertField(result,k, fieldToInsert);
     
         //for debugging purposes:
         System.out.println("result: " + result);
      }   
      return result;
   }

}