--  ---------------------------------------------------------------------------
--  @Main: Geschenkeverwaltung.adb
--
--  @Project: PSE, Sheet 10, Problem 3
--  @Version: 1.0
--  @Created: 19.12.2011
--  @Author: Alexander Miller
--
--  @Description: Programm zur Verwaltung einer Wunschliste.
--
--  @Modifications:
--
--  @Notes : Es passiert manchmal ohne jeden ersichtloichen Grund, dass die
--    Formatierung der Wunschliste streikt und bei den Stadtnamen zB
--    -Bad Liebenzell eingelesen wird.
--  ---------------------------------------------------------------------------

with Ada.Text_IO;
with Ada.Strings.Unbounded;
with Ada.Strings.Unbounded.Text_IO;

use Ada.Text_IO;
use Ada.Strings.Unbounded;
use Ada.Strings.Unbounded.Text_IO;

procedure Geschenkeverwaltung is

   --  Variablen folgender Typen werden im weiteren Verlauf des Programmes
   --  durchgehend als G wie Geschenke, K wie Kind und S wie Stadt bezeichnet
   type Geschenke;
   type Ref_Geschenke is access Geschenke;
   type Geschenke is record
      Name : Unbounded_String;
      Next : Ref_Geschenke;
   end record;

   type Kind;
   type Ref_Kind is access Kind;
   type Kind is record
      Name        : Unbounded_String;
      Zu_Schenken : Ref_Geschenke;
      Next        : Ref_Kind;
   end record;

   type Stadt;
   type Ref_Stadt is access Stadt;
   type Stadt is record
      Name   : Unbounded_String;
      Kinder : Ref_Kind;
      Next   : Ref_Stadt;
   end record;

   type Anker;
   type Ref_Anker is access Anker;
   type Anker is record
      First : Ref_Stadt;
   end record;

   Liste : Ref_Anker;

   --  ------------------------------------------------------------------------
   --  @Procedure: Wunschliste_Einlesen
   --
   --  @Description: Liest eine Wunschliste aus einer Textdatei ein und legt
   --   eine entsprechende Kammliste an.
   --
   --  @Parameter: -
   procedure Wunschliste_Einlesen is

      Quelle            : File_Type;
      Gelesen           : Unbounded_String;
      --  Hilfszeiger, die jeweils die Einfuegeprozeduren wissen lassen, wohin
      --  ein  neues Element hinzuzufuegen ist
      Jetzige_Stadt     : Ref_Stadt;
      Jetziges_Kind     : Ref_Kind;
      Jetziges_Geschenk : Ref_Geschenke;

      --  ---------------------------------------------------------------------
      --  @Procedure: Insert_Stadt
      --
      --  @Description: Fuegt eine neue Stadt an das Ende der bestehenden Kamm-
      --   liste hinzu.
      --
      --  @Parameter:
      --   +L: Anker der Liste.
      --   +Name: Der Name der einzufuegenden Stadt.
      procedure Insert_Stadt
      (S    : in Ref_Stadt;
       Name : in Unbounded_String) is
      begin
         --  Einfuegen der Stadt an die erste Stelle und entsprechende Aende-
         --  rung des Ankers im Fall einer leeren Liste
         if S = null then
            Liste.First       := new Stadt'(Delete (Name, 1, 1), null, null);
            Jetzige_Stadt     := Liste.First;
         else
            S.Next        := new Stadt'(Delete (Name, 1, 1), null, null);
            Jetzige_Stadt := S.Next;
         end if;
      end Insert_Stadt;

      --  ---------------------------------------------------------------------
      --  @Procedure: Insert_Kind
      --
      --  @Description: Fuegt ein neues Kind an das Ende der bestehenden Kamm-
      --   liste hinzu.
      --
      --  @Parameter:
      --   +S: Die Stadt, zu der das Kind zugefuegt werden soll.
      --   +Name: Der Name des einzufuegenden Kindes.
      procedure Insert_Kind
      (S    : in Ref_Stadt;
       K    : in Ref_Kind;
       Name : in Unbounded_String) is
      begin
         --  Einfuegen des Kindes an die erste Stelle im Fall einer leeren
         --  Liste
         if S.Kinder = null then
            S.Kinder      := new Kind'(Delete (Name, 1, 1), null, null);
            Jetziges_Kind := S.Kinder;
         else
            K.Next        := new Kind'(Delete (Name, 1, 1), null, null);
            Jetziges_Kind := K.Next;
         end if;
      end Insert_Kind;

      --  ---------------------------------------------------------------------
      --  @Procedure: Insert_Geschenk
      --
      --  @Description: Fuegt ein neues Geschenk an das Ende der bestehenden
      --   Kammliste hinzu.
      --
      --  @Parameter:
      --   +K: Das Kind, zu dem das Kind zugefuegt werden soll.
      --   +Name: Der Name des einzufuegenden Geschenkes.
      procedure Insert_Geschenk
      (K    : in Ref_Kind;
       G    : in Ref_Geschenke;
       Name : in Unbounded_String) is
      begin
         --  Einfuegen des Geschenkes an die erste Stelle im Fall einer leeren
         --  Liste
         if K.Zu_Schenken = null then
            K.Zu_Schenken     := new Geschenke'(Delete (Name, 1, 1), null);
            Jetziges_Geschenk := K.Zu_Schenken;
         else
            G.Next            := new Geschenke'(Delete (Name, 1, 1), null);
            Jetziges_Geschenk := G.Next;
         end if;
      end Insert_Geschenk;

   begin

      Liste := new Anker;
      Open (Quelle, In_File, "wunschliste.txt");

      while not End_Of_File (Quelle) loop
         Gelesen := Get_Line (Quelle);
         case (Element (Gelesen, 1)) is
            when '-'    => Insert_Stadt
                           (Jetzige_Stadt, Gelesen);
            when '+'    => Insert_Kind
                           (Jetzige_Stadt, Jetziges_Kind, Gelesen);
            when '*'    => Insert_Geschenk
                           (Jetziges_Kind, Jetziges_Geschenk, Gelesen);
            when others => null;
         end case;
      end loop;

      Close (Quelle);

   end Wunschliste_Einlesen;

   --  ------------------------------------------------------------------------
   --  @Procedure: Menue
   --
   --  @Description: Stellt eine simple Benutzeroberflaeche fuer die Verwaltung
   --   der Wunschliste zur Verfuegung.
   --
   --  @Parameter: -
   procedure Menue is

      Schalter : Boolean := False;
      Eingabe  : Unbounded_String;
      S        : Ref_Stadt := Liste.First;

      --  ---------------------------------------------------------------------
      --  @Procedure: Geschenke_Zeigen
      --
      --  @Description: Zeigt, nachdem Stadt und Kind gewaehlt wurden,
      --   saemtliche Geschenke des Kindes an.
      --
      --  @Parameter:
      --   +K: Kind, dessen Geschenke gezeigt werden sollen.
      procedure Geschenke_Zeigen
      (K : in Ref_Kind) is
         G       : Ref_Geschenke := K.Zu_Schenken;
         Eingabe : Unbounded_String;
      begin
         New_Line;
         Put ("Liste aller Geschenke fuer " & K.Name & " :");
         while G /= null loop
            New_Line;
            Put ("-" & G.Name);
            G := G.Next;
         end loop;
         New_Line;
         New_Line;
         Put ("Zum Fortfahren Enter druecken.");
         New_Line;
         Eingabe := Get_Line;
         New_Line;
      end Geschenke_Zeigen;

      --  ---------------------------------------------------------------------
      --  @Procedure: Kind_Waehlen
      --
      --  @Description: Gibt eine Liste aller Kinder in der gewaehlten Stadt
      --   aus und laesst eines davon auswaehlen, um seine Geschenke zu zeigen.
      --
      --  @Parameter:
      --   +S: Die Stadt aus der ein Kind zu waehlen ist.
      procedure Kind_Waehlen
      (S : in Ref_Stadt) is

         Eingabe  : Unbounded_String;
         Schalter : Boolean  := False;
         Gefunden : Boolean  := False;
         K        : Ref_Kind := S.Kinder;

      begin
         New_Line;
         Put ("Liste aller Kinder in " & S.Name & ":");
         New_Line;
         while K /= null loop
            Put (" -" & K.Name);
            New_Line;
            K := K.Next;
         end loop;

         while not Schalter loop
            --  resetten der Hilfsvariablen fuer den Fall, dass die Schleife
            --  neu startet
            K := S.Kinder;
            Gefunden := False;

            Put ("Wessen Geschenke sollen angezeigt werden?");
            New_Line;
            Put ("('return' eingeben, um zum vorherigen Menue zu gelangen.)");
            New_Line;
            Eingabe := Get_Line;

            --  durch Eingabe von return wird der Schalter, der die gesamte
            --  Eingabeschleife laufen laesst, umgelegt, d.h. das Unterprogramm
            --  beendet sich und das Menue kehrt zur Eingabe der Stadt zurueck
            if
            Eingabe = "return" or Eingabe = "Return" or Eingabe = "RETURN" then
               Schalter := True;
               New_Line;
            else
               --  die Liste wird nach dem eingegebenen Namen durchsucht, wird
               --  er gefunden, so werden die Geschenke angezeigt
               while K /= null and not Gefunden loop
                  if K.Name = Eingabe then
                     Gefunden := True;
                     Geschenke_Zeigen (K);
                  end if;
                  K := K.Next;
               end loop;

               if not Gefunden then
                     New_Line;
                     Put ("------------------------------------- ");
                     New_Line;
                     Put ("Fehler: Das Kind wurde nicht gefunden.");
                     New_Line;
                     Put ("Eingabe muss wiederholt werden.       ");
                     New_Line;
                     Put ("------------------------------------- ");
                     New_Line;
                     New_Line;
               end if;
            end if;
         end loop;
      end Kind_Waehlen;

      --  ---------------------------------------------------------------------
      --  @Procedure: Stadt_Waehlen
      --
      --  @Description: Gibt eine Liste aller Stadte  aus und laesst eine davon
      --   auswaehlen, um ihre Kinder anzuzeigen.
      --
      --  @Parameter: -
      procedure Stadt_Waehlen is

         Eingabe  : Unbounded_String;
         Gefunden : Boolean   := False;
         Schalter : Boolean   := False;
         S        : Ref_Stadt := Liste.First;

      begin
         while not Schalter loop
            --  resetten der Hilfsvariablen fuer den Fall, dass die Schleife
            --  neu startet
            Gefunden := False;
            S        := Liste.First;
            Put ("Liste aller Staedte auf der Wunschliste:");
            New_Line;
            S := Liste.First;
            while S /= null loop
               Put (" -" & S.Name);
               S := S.Next;
               New_Line;
            end loop;
            Put ("Die Liste der Kinder in welcher Stadt soll gezeigt werden?");
            New_Line;
            Put ("'return' eingeben, um zum vorherigen Menue zu gelangen.");
            New_Line;
            Eingabe := Get_Line;

            if Eingabe = "return"
            or Eingabe = "Return"
            or Eingabe = "RETURN"
            then
               Schalter := True;
            else
               --  resetten der Hilfsvariablen fuer den Fall, dass die Schleife
               --  neu startet
               Gefunden := False;
               S    := Liste.First;
               --  die Liste wird nach dem eingegebenen Namen durchsucht, wird
               --  er gefunden, so werden alle Kinder in der eingegebenen Stadt
               --  angezeigt
               while S /= null and not Gefunden loop
                  if S.Name = Eingabe then
                     Gefunden := True;
                     Kind_Waehlen (S);
                  end if;
                  S := S.Next;
               end loop;

               if not Gefunden then
                  New_Line;
                  Put ("-------------------------------------- ");
                  New_Line;
                  Put ("Fehler: Die Stadt wurde nicht gefunden.");
                  New_Line;
                  Put ("Eingabe muss wiederholt werden.        ");
                  New_Line;
                  Put ("-------------------------------------- ");
                  New_Line;
                  New_Line;
               end if;
            end if;
         end loop;

      end Stadt_Waehlen;

      --  ---------------------------------------------------------------------
      --  @Procedure: Geschenk_Zaehlen
      --
      --  @Description: Laesst einen Namen eines Geschenkes eingeben und findet
      --   dann heraus wie oft dieses Geschenk insgesamt auf der Wunschliste
      --   steht.
      --
      --  @Parameter: --
      procedure Geschenk_Zaehlen is
         Eingabe  : Unbounded_String;
         Gelesen  : Unbounded_String;
         Zaehler  : Natural   := 0;
         Gefunden : Boolean   := False;
         Quelle   : File_Type;
      begin
         New_Line;
         Put ("Welches Geschenk soll gezaehlt werden?");
         New_Line;
         Eingabe := Get_Line;
         Eingabe := "*" & Eingabe;
         New_Line;

         Open (Quelle, In_File, "wunschliste.txt");
         while not End_Of_File (Quelle) loop
            Gelesen := Get_Line (Quelle);
            if Gelesen = Eingabe then
               Gefunden := True;
               Zaehler := Zaehler + 1;
            end if;
         end loop;
         Close (Quelle);

         if Gefunden then
            Put (Delete (Eingabe, 1, 1) & " steht insgesamt" & Zaehler'Img);
            Put (" auf der Wunschliste.");
            New_Line;
            New_Line;
         else
            Put ("Dieses Geschenk kommt in der Wunschliste nicht vor.");
            New_Line;
            New_Line;
         end if;
      end Geschenk_Zaehlen;

      --  ---------------------------------------------------------------------
      --  @Procedure: Geschenke_Einer_Stadt
      --
      --  @Description: Laesst eine Stadt eingeben und gibt dann aus, welche
      --   Geschenke, wie oft, in dieser Stadt vorkommen
      --
      --  @Parameter: -
      procedure Geschenke_Einer_Stadt is

         --  neuer Typ fuer eine Liste, der mit angibt, wie oft ein Geschenk
         --  vorgekommen ist
         type Zaehler;
         type Ref_Zaehler is access Zaehler;
         type Zaehler is record
            Name   : Unbounded_String;
            Anzahl : Natural;
            Next   : Ref_Zaehler;
         end record;

         type Zaehler_Anker;
         type Ref_Zaehler_Anker is access Zaehler_Anker;
         type Zaehler_Anker is record
            First : Ref_Zaehler;
         end record;

         Zaehl_Liste   : Ref_Zaehler_Anker;
         Z             : Ref_Zaehler;
         S             : Ref_Stadt := Liste.First;
         K             : Ref_Kind;
         Eingabe       : Unbounded_String;
         Gefunden      : Boolean := False;

         --  ------------------------------------------------------------------
         --  @Procedure: Zaehl_Liste_Erstellen
         --
         --  @Description: Wird genutzt, um festzustellen, wie oft welche Ge-
         --   schenke  bei einem gegeben Kind vorkommen.
         --
         --  @Parameter:
         --   +K: Das Kind deseen Geschenke zu zaehlen sind.
         procedure Zaehl_Liste_Erstellen
         (K : in Ref_Kind) is
            G        : Ref_Geschenke := K.Zu_Schenken;
            Z        : Ref_Zaehler   := Zaehl_Liste.First;
            Gefunden : Boolean       := False;
         begin
            --  iterieren durch die Liste aller Geschenke des Kindes und Ein-
            --  fuegen in die Zaehlliste
            while G /= null loop
               Gefunden := False;
               Z := Zaehl_Liste.First;
               --  einfuegen eines Geschenkes falls die Zaehlliste leer ist
               if Z = null then
                  Zaehl_Liste.First := new Zaehler'(G.Name, 1, null);
               else
                  --  sonst wird die Zaehlliste durchsucht, sollte ein Element
                  --  den gleichen Namen haben wie das jetzige Geschenk, so
                  --  die Anzahl dieses Elementes um 1 erhoeht
                  while Z /= null and not Gefunden loop
                     if G.Name = Z.Name then
                        Z.Anzahl := Z.Anzahl + 1;
                        Gefunden := True;
                     end if;
                     Z := Z.Next;
                  end loop;
                  --  wenn der Name des Geschenkes in der Liste bisher nicht
                  --  vorkommt wird entsprechend ein neues Element mit Anzahl 1
                  --  hinzugefuegt
                  if not Gefunden then
                     Z := Zaehl_Liste.First;
                     while Z.Next /= null loop
                        Z := Z.Next;
                     end loop;
                     Z.Next := new Zaehler'(G.Name, 1, null);
                  end if;
               end if;
               G := G.Next;
            end loop;
         end Zaehl_Liste_Erstellen;

      begin
         while not Gefunden loop
            S := Liste.First;
            K := S.Kinder;

            Put ("Liste aller Staedte auf der Wunschliste:");
            New_Line;
            while S /= null loop
               Put (" -" & S.Name);
               S := S.Next;
               New_Line;
            end loop;
            S := Liste.First;
            Zaehl_Liste := new Zaehler_Anker;

            Put ("Eine Liste der Geschenke welcher Stadt soll");
            Put (" angezeigt werden?");
            New_Line;
            Eingabe := Get_Line;
            --  die Wunschliste wird nach der eingegebenen Stadt durchsucht,
            --  wurde sie gefunden, so wird die Zaehlliste um die Geschenke
            --  von jedem Kind dieser Stadt erweitert, wenn die Stadt nicht ge-
            --  funden wurde muss die Eingabe wiederholt werden
            while not Gefunden and S /= null loop
               if Eingabe = S.Name then
                  Gefunden := True;
                  K := S.Kinder;
                  while K /= null loop
                     Zaehl_Liste_Erstellen (K);
                     K := K.Next;
                  end loop;
               end if;
               S := S.Next;
            end loop;

            if not Gefunden then
               New_Line;
               Put ("-------------------------------------- ");
               New_Line;
               Put ("Fehler: Die Stadt wurde nicht gefunden.");
               New_Line;
               Put ("Eingabe muss wiederholt werden.        ");
               New_Line;
               Put ("-------------------------------------- ");
               New_Line;
               New_Line;
            end if;
         end loop;

         New_Line;
         Put ("Geschenke fuer " & Eingabe & ":");
         New_Line;
         Z := Zaehl_Liste.First;
         while Z /= null loop
            Put (" -" & Z.Anzahl'Img & "x " & Z.Name);
            New_Line;
            Z := Z.Next;
         end loop;

      end Geschenke_Einer_Stadt;

   begin
      while not Schalter loop
         Put ("-------------------------------------------------------------");
         Put ("------------");
         New_Line;
         Put ("'1' eingeben, um die Geschenke eines einzelnen Kindes");
         Put (" einzusehen.");
         New_Line;
         Put ("'2' eingeben, um alle Geschenke einer einzelnen Stadt");
         Put (" anzeigen zu lassen.");
         New_Line;
         Put ("'3' eingeben, um anzeigen zu lassen, wie oft ein bestimmtes ");
         New_Line;
         Put ("    Geschenk auf der Wunschliste steht.");
         New_Line;
         Put ("'exit' eingeben, um das Programm zu beenden.");
         New_Line;
         Put ("-------------------------------------------------------------");
         Put ("------------");
         New_Line;
         Eingabe := Get_Line;
         if Eingabe = "1" then
            Stadt_Waehlen;
         elsif Eingabe = "2" then
            Geschenke_Einer_Stadt;
         elsif Eingabe = "3" then
            Geschenk_Zaehlen;
         elsif Eingabe = "exit" or Eingabe = "Exit" or Eingabe = "EXIT" then
            Schalter := True;
         else
            New_Line;
            Put ("Eingabe war ungueltig und muss wiederholt werden.");
            New_Line;
            New_Line;
         end if;
      end loop;
   end Menue;

begin

   Wunschliste_Einlesen;
   Menue;

end Geschenkeverwaltung;