/* Beispielloesung zu Uebungsblatt 14, AI 1, WS 2006/07

   nh - 01/2007
*/

import IOulm.*;

public class Chiffre {

   public static final int lowerBound = 32; // untere Grenze des ASCII-Bereichs
   public static final int upperBound = 127; // obere Grenze des ASCII-Bereichs
   public static final String PROGNAME = "Chiffre";
   public static String message = "";   // zu codierender Text
   public static boolean reverse = false; // wird true bei Reverse-Option
   public static boolean shiftUp = false; // wird true bei Verschieben n. v.
   public static boolean shiftDown = false; // wird true bei Verschieben n. h.
   public static int shiftWidth = 0; // Schrittweite bei (evtl.) Verschieben

   // Gibt die Usage-Meldung aus und bricht das Programm mit Exit-Code 1 ab.
   public static void usage() {
      Write.Line("USAGE: java " + PROGNAME + " [-dn -un -r -mtext -?]");
      System.exit(1); // 1 indiziert Fehlerzustand
   }

   // Wird aufgerufen, wenn das Programm mit der Option "-?" gestartet wird
   public static void showManual() {
      Write.Line("Folgende Optionen stehen zur Verfügung:");
      Write.Line("-r:     gibt den eingelesenen String rückwärts aus");
      Write.Line("-un:    verschiebt die Zeichen um n Positionen nach oben");
      Write.Line("-dn:    verschiebt die Zeichen um n Positionen nach unten");
      Write.Line("-mtext: verwendet text als Nachricht (kein Lesen von STDIN)");
      Write.Line("-?:     gibt (nur) diesen Hilfetext aus");
      System.exit(0);
   }

   // Fuehrt eine Ueberpruefung der Argumente durch. Der Rueckgabewert ist
   // 'true', wenn die Ueberpruerfung erfolgreich war, andernfalls (z.B. bei
   // nicht zulaessigen Optionen) ist er 'false'.
   public static boolean checkArgs(String[] args) {
      // Keine Argumente angegeben
      if (args.length == 0)
         return false;

      // Pruefen, ob alle Argumente mit "-" beginnen
      for (int i=0; i<args.length; i++) {
         if (args[i].charAt(0) != '-')
	         return false;
         switch (args[i].charAt(1)) {
            case 'r': reverse = true; break;
            case 'd': if (shiftUp) 
	                      return false;   // entweder up oder down
		                if (args[i].length()<=2)
		                   return false;   // es kam kein Wert
		                shiftDown=true;
                      String dummyString1 = args[i].substring(2).trim();
            // Hier wuerde es schief gehen, wenn keine Zahl sondern etwas
            // anderes eingegeben wurde; das Problem liesse sich mit Hilfe
            // des Exception-Handlings (das Gegenstand des zweiten Semesters
            // sein wird) loesen; der Einfachheit halber verzichten wir
            // an dieser Stelle aber auf weitere Pruefungen und gehen davon
            // aus, dass wirklich eine Zahl kam.
		                shiftWidth = Integer.valueOf(dummyString1).intValue();
		                break;
	         case 'u': if (shiftDown) 
	                      return false;   // entweder up oder down
		                shiftUp=true;
		                if (args[i].length()<=2)
		                   return false;   // es kam kein Wert
		                String dummyString2 = args[i].substring(2).trim();
                      // siehe Anmerkung im Fall 'd'
		                shiftWidth = Integer.valueOf(dummyString2).intValue();
		                break;
            case 'm': if (args[i].length()<=2)
		                   return false;   // es kam kein Wert
                      message = args[i].substring(2);
		                break;
	         case '?': showManual(); break;
            default:  return false;
         }
      }
      // Wenn wir hier angekommen sind, dann lag kein Fehler vor
      return true;
   }

   // Liest einen String von der Standardeingabe und speichert ihn in der
   // globalen Variable "message".
   public static String readMessage() {
      if (!Urc.readString()) {
         Write.Line("Fehler beim Einlesen der Nachricht");
	      System.exit(2);   // Zur Unterscheidung vom Abbruch durch Usage-Meldung
      }
      return Urc.getString();
   }

   // Liefert einen String zurueck, der den als Parameter uebergebenen String
   // "von hinten nach vorne" geschrieben enthaelt;
   // in unserem Kontext braeuchte man den String nicht extra zu uebergeben,
   // da wir mit einer globalen Variable arbeiten; dies ist aber stilistisch
   // nach Moeglichkeit zu vermeiden, daher macht diese Methode von der
   // zur Verfuegung stehenden globalen Variable KEINEN Gebrauch!
   public static String reverseString(String msg) {
      String tmp = "";
      for (int i=msg.length()-1;i>=0;i--)
         tmp = tmp + msg.charAt(i);
      return tmp;
   }

   // das gleiche: globale Variable, bla bla
   public static String shiftString(String msg, int sw) {
      String tmp = "";
      int tmpShift;
      for (int i=0; i<msg.length(); i++) {
         int charVal = (int) msg.charAt(i);
         if (charVal<lowerBound || charVal>upperBound) {
	         tmp = tmp + msg.charAt(i);
	         continue;
         }
         tmpShift = charVal + sw;
	      if (tmpShift < lowerBound)
	         tmpShift += (upperBound-lowerBound);
         if (tmpShift >= upperBound)
	         tmpShift = (tmpShift % upperBound) + lowerBound;
         tmp = tmp + (char) (tmpShift);
      }
      return tmp;
   }

   // Das Hauptprogramm, das dank der Verwendung von Methoden nun recht
   // uebersichtlich gehalten werden kann
   public static void main (String[] args) {
      // Argumente pruefen und verarbeiten
      if (!checkArgs(args))
         usage();

      // Falls die Option "-w" nicht gesetzt war, muss der zu verschluesselnde
      // Text von der Standardeingabe gelesen werden. Dies erledigt unsere
      // Methode readMessage().
      if (message == "")
         message = readMessage();

      if (reverse)
         message = reverseString(message);

      if (shiftUp) 
         message = shiftString(message, shiftWidth);

      if (shiftDown)
         message = shiftString(message, shiftWidth*(-1));

      Write.Line(message);
   }
}