/***************************************************************************
 * MUSTERLOESUNG     PI1 WS99/00      Uebungsblatt 9         Aufgabe 1
 *
 * Autor : Justin Nziki      Datum : 13.01.00
 * Datei : AdressenListeVListe.java
 * Beschreibung :
 * Implementierung einer Adressverwaltung unter Verwendung einer verketteten
 * Liste zur Speicherung und Sortierung der Adressen.
 * Im Speziellen liest das Programm die Verwaltungskommandos aus einer Datei
 * ( kommandos*.txt ) ein und bearbeitet danach diese Adresseliste.
 * Listenelemente koennen eingefuegt ("add"), geloescht ("delete")
 * und gesucht ("search") werden.
 * Weiterhin kann die komplette Liste ueber ein "print"-Kommando
 * in sortierter Reihenfolge ausgegeben werden.
 ****************************************************************************/

import java.io.*;
import java.util.StringTokenizer;


class AdressElement {

  // Datenelemente fuer die Adresse
    private String name;
    private String strasse;
    private String ort;


  // Konstruktor - Initialisierung der neuen Datenelemente
  public AdressElement () {
    this.name    = "";
    this.strasse = "";
    this.ort     = "";
  }

  // Adresse in Datenelemente eintragen
  public void setzeAdresse (String name, String strasse, String ort) {
    this.name    = name;
    this.strasse = strasse;
    this.ort     = ort;
  }

  // AdressElement in druckbaren String umwandeln
  public String toString() {
    String s = name + ";" + strasse + ";" + ort + "";
    return s;
  }

  // Der Schluessel der Adressverwaltung ist der Name des jeweiligen
  // Listeneintrages. Ueber "getName" kann man auf diesen zugreifen.
  public String getName() {
    String s = name;
    return s;
  }
}

class ListenElement {
    public ListenElement nachfolger = null; // Referenz auf das nachfolgende
                                            // Listenelement
    public AdressElement adresse    = null; // Adressdaten (Referenz auf die
                                            // Eintraege )
}


public class AdressenListeVListe {

    // Referenz auf das erste Element
    static private ListenElement listenAnfang = new ListenElement();

    // Referenz auf das letzte Element
    static private ListenElement listenEnde   = null;

//****************************************************************************

  /***************************************************************
    * Hier wird das eigentliche Einfuegen vorgenommen
    * Parameter : Listenanfang und die einzutragenden Daten
    * Gibt Referenz zurueck, um ein ggf eingefuegten Datensatz zu
    * beruecksichtigen
    **************************************************************/
    static ListenElement insert(ListenElement liste,String name, String strasse, String ort){

	//Wenn noch keine Adresse vorhanden, dann ein neues AdressElement erzeugen
	if (liste.adresse==null){
	    liste.adresse=new AdressElement();
	    liste.adresse.setzeAdresse(name,strasse,ort);
	} else {
	    String eingetrName=liste.adresse.getName();
	    if ( (liste.nachfolger==null) && (name.compareTo(eingetrName)>=0) ){

                // Wenn der einzutragende Name als letztes in der Sortierung vorkommt
                // so tragen wir ihn am Ende der Liste ein.
		liste.nachfolger=new ListenElement();
		liste.nachfolger=insert(liste.nachfolger,name,strasse,ort);
	    } else {

		// Nachfolger existiert => ueberpruefen
		// ob "name" vor "eingetrName" ???
		if (name.compareTo(eingetrName)<0) {

                    // Wenn JA dann vor den aktuellen Datensatz stellen
		    // und die Referenz zu Nachfolger sichern !!
		    ListenElement helpReferenz = liste;

		    // Neuer Datensatz erstellen
		    liste=new ListenElement();

		    // gesicherten Nachfolger als Nachfolger des neuen Datensatzes
		    liste.nachfolger=helpReferenz;

		    // Daten in diesen neuen Datensatz schreiben
		    liste=insert(liste,name,strasse,ort);
		} else {

		    // Name kommt nach dem aktuellen Datensatz
                    //(auch wenn die Namen gleich sind !)
		    liste.nachfolger=insert(liste.nachfolger,name,strasse,ort);
		}
	    }
	}
      	return liste;
    }

  /***********************************************************************
    * Fuegt eine Adresse in die Liste ein. Die Liste ist immer nach Namen
    * aufsteigend sortiert.
    **********************************************************************/
    static void einfuegen(String name, String strasse, String ort){
	listenAnfang=insert(listenAnfang,name,strasse,ort);
    }

//****************************************************************************

  /********************************************************************
    * Das eigentliches Loeschen
    * Parameter : Listenanfang und Name als Schluessel des Datensatzes
    *******************************************************************/
    static ListenElement delete(ListenElement liste, String name){

	// Abbruch wenn Ende der Liste erreicht, leere Liste oder kein Eintrag !
	if ( (liste!=null) && (liste.adresse!=null)  ){
	    if (liste.adresse.getName().equals(name)) {

		// wenn Datensatz gefunden, Nachfolger als aktuellen Datensatz
                // fixieren, um die Referenz freizugeben und den Rest der Liste
                // dabei nicht zu verlieren !
		liste=liste.nachfolger;

		// nachsten Datensatz anschauen (Name evtl. mehrfach)
		liste=delete(liste,name);
	    }
	    else {

	        //naechsten Datensatz anschauen
	        liste.nachfolger=delete(liste.nachfolger,name);
            }
	}
	return liste;
    }

  /*************************************************************************
    * loescht einen Namen (der auch mehrfach vorkommen kann !)aus der Liste
    ************************************************************************/
    static void loeschen(String name){
	listenAnfang=delete(listenAnfang,name);
    }

//****************************************************************************

  /*********************************************************
    * Das eigentliche Suchen
    * Parameter : Listenanfang, Name (Schluessel) und Anzahl
    * Rueckgabe:  Anzahl der gefundenen Eintraege
    *********************************************************/
    static int search(ListenElement liste,int anzahl,String name){
	if (liste.adresse!=null){
	    if (liste.adresse.getName().equals(name)) { // Name gefunden
		System.out.println(liste.adresse.toString());

                // "anzahl" merkt sich hier die Anzahl der Eintraege
		anzahl++;
	    }
	    if (liste.nachfolger!=null) {

		// Naechsten Datensatz in der Liste ansehen
		anzahl=search(liste.nachfolger,anzahl,name);
	    }
	}
        else {
	    System.out.println("Kein gueltiger Eintrag vorhanden !");
	}
	return anzahl;
    }

  /*******************************************************
    * Sucht alle Datensaetze eines Namen und gibt sie aus
    ******************************************************/
    static void suchen(String name){
	if (listenAnfang!=null) {
	    if (search(listenAnfang,0,name)==0)

		//Wenn kein Datensatz gefunden, LEER ausgeben
		System.out.println("LEER");
	}
    }

//****************************************************************************

  /****************************
    * Die eigentliche Ausgabe
    * Parameter : Listenanfang
    ***************************/
    static void out(ListenElement liste){
	if (liste.adresse!=null){     // Abbruch am Ende der Liste
	    System.out.println(liste.adresse.toString());
	    if (liste.nachfolger!=null) {

                // naechstes Element ausgeben
		out(liste.nachfolger);
	    }
	}
        else {
	    System.out.println("Kein gueltiger Eintrag vorhanden !");
	}
    }

  /****************************************
    * Druckt die sortierte Adressliste aus
    ***************************************/
    static void print(){
	if (listenAnfang.adresse==null){
	    System.out.println("LEER");
	} else {
	    out(listenAnfang);
	}
    }

//****************************************************************************

  /****************************************************************
    * Untersucht einen String nach einem Befehl und fuehrt ihn aus
    * Parameter : String
    ***************************************************************/
    static void befehl(String S){
	String tmp,name,strasse,ort;
	StringTokenizer st= new StringTokenizer(S);
	name=strasse=ort="";

	// Lese Befehl ein
	tmp=st.nextToken();
	if (tmp.compareTo("add")==0) {

	    // Lese Parameter ein
	    name=st.nextToken();
	    strasse=st.nextToken();
	    ort=st.nextToken();
	    einfuegen(name,strasse,ort);
	} else {
	    if (tmp.compareTo("delete")==0) {

		// Lese Parameter ein
		name=st.nextToken();
		loeschen(name);
	    } else {
		if (tmp.compareTo("search")==0) {

		    // Lese Parameter ein
		    name=st.nextToken();
		    suchen(name);
		} else {
		    if (tmp.compareTo("print")==0) {
			print();
		    }
		}
	    }
	}
    }

//****************************************************************************

    public static void main (String[] args){

	String         S = "";
	boolean     done = false;
	FileReader     fr= null;
	BufferedReader in= null;

	// Oeffne Kommandodatei
	try {
	    fr= new FileReader(args[0]);
	    in= new BufferedReader(fr);
	} catch(FileNotFoundException fnfe) {
	    System.out.println("Datei "+args[0]+" nicht gefunden!");
	    System.exit(1);
	}

	// Lese Befehle
	while (!done) {
	    try { // lese Zeile
		S = in.readLine();
	    } catch (IOException ioe) {
		System.out.println("IO Exception");
		System.exit(1);
	    }
	    if (S==null) done=true;
	    // Wenn Ende der Datei nicht erreicht, Zeile nach Befehlen durchsuchen
	    if ( (!done) && !(S==null) ) befehl(S);
	}
    }
}