#include "stdafx.h"
#include <iostream>

#include <string>
#include <cstddef>

using namespace std;


//Globale Funktionen wie diese hier müssen ganz oben (vor allen anderen klassen und funktionen deklariert werden, damit
//sie verwendet werden können (dem compiler bakannt sein)
void error(string msg)
{
  cerr << msg << endl;
  exit(-1);
}

class Time
{

    int hour,          // 0 .. 23
        day,           // 1 .. 31
        month;         // 1 .. 12

  public:
    // allgemeiner Konstruktor und Standardkonstruktor
    // Falls die Wertebereiche für die Attribute nicht eingehalten werden,
    // wird das Programm mit einer Fehlermeldung abgebrochen.
    Time(int h = 0, int d = 1, int m = 1);

   /*  Kopierkonstruktor und überladene Wertzuweisung
     werden vom Compiler automatisch erzeugt */

    virtual ~Time();

    // die Zeit einstellen
    // Falls die Wertebereiche für die Attribute nicht eingehalten werden,
    // wird das Programm mit einer Fehlermeldung abgebrochen.
    void set(int h, int d, int m);

    // die Zeit auf den Bildschirm ausgeben
    virtual void display() const; // MUSS DEFINIERT WERDEN...ausschließlich '= 0' ...also rein virtuelle Methoden werden nicht definiert

  /* vergleicht das aktuelle Objekt mit dem übergebenen Objekt t
     liefert einen Wert < 0, wenn das aktuelle Objekt kleiner als t ist
                        > 0, wenn das aktuelle Objekt größer als t ist
                          0, wenn das aktuelle Objekt gleich t ist */
    /*int compareTo(const Time& t) const; */

    bool operator<(const Time& t) const;
    bool operator==(const Time& t) const;
};

Time::Time(int h, int d, int m)
{
    hour = h;
    day = d;
    month = m;
}

Time::~Time()
{

}

void Time::set(int h, int d, int m)
{
    month = m;
    hour = h;
    day = d;
}

void Time::display() const
{
    cout << hour  << endl
         << day   << endl
         << month << endl;
}

bool Time::operator==(const Time& t) const
{
    if (&t == NULL)
        error("Übergebene Referenz ist leer !");

    if (this == &t)
        return true;
    else
        return false;

}

bool Time::operator<(const Time& t) const
{
    if (&t == NULL)
        error("Übergebene Referenz ist leer !");

    if (this < &t)
        return true;
    else
        return false;
}




//a
//Implementieren  Sie  die  folgende  Klasse  Event  (zu  deutsch  Ereignis  oder  Termin),  die  von  der
//Klasse  Time  erbt.  Ein  Objekt  vom  Typ  Event  ist  also  durch  eine  Zeit  (Time)  und  einen  Text
//definiert, z.B. hour == 13,  day == 4,  month == 2,  text == "Klausur C++".

class Event : public Time
{
    // ein Zeichenketten-Objekt vom C++-Standard-Typ string
    string text;

  public:
    // allgemeiner Konstruktor, der auch als Standardkonstruktor dient
    Event(int h = 0, int d = 1, int m = 1, string s = "weiss nicht");

    // Kopierkonstruktor und überladene Wertzuweisung
    // werden vom C++-Compiler automatisch generiert

    virtual ~Event();

    // einen Termin festlegen
    void set(int h, int d, int m, string s);

    // einen Termin auf den Bildschirm ausgeben
    void display() const;

    // zwei Termine sind gleich, wenn sowohl die Zeit
    // als auch der Text übereinstimmen
    bool operator==(const Event& e) const;
};

Event::Event(int h, int d, int m, string s) : Time(h, d, m)
{
    this->text = s;
}

Event::~Event()
{
}

void Event::set(int h, int d, int m, string s)
{
    Time::set(h, d, m);
    text = s;
}

bool Event::operator==(const Event& e) const
{
    if (&e == NULL)
        error("Übergebene Referenz ist leer !");

    if (this == &e)
        return true;
    else
        return false;
}

void Event::display() const
{
    Time::display();
    cout << text  << endl
         << "---------------" << endl;
}

//b)   Implementieren  Sie  die  folgende  Klasse  Calendar,  die  einen  Terminkalender  beschreibt,  der
//Termine  vom  Typ  Event  verwaltet.  Die  Termine  stehen  nicht  chronologisch  geordnet,  sondern
//entsprechend der Reihenfolge ihrer Eingabe im Puffer buf.
//

class Calendar
{
    Event *buf;        // Zeiger auf Array mit Termineinträgen (Auch als dynamisches Element bekannt)
    int maxSize;       // Anzahl der maximal möglichen Einträge
    int count;         // aktuelle Anzahl der Einträge

    // falls ein Termin mit der Zeit des Termins e vorhanden ist,
    // wird der entsprechende Index geliefert, ansonsten -1
    int findTime(const Event& e) const;

    // falls ein Termin mit der Zeit und dem Text des Termins e
    // vorhanden ist, wird der entsprechende Index geliefert, ansonsten -1
    int findEvent(const Event& e) const;

    // gibt den Index des nächsten Termins zurück;
    // der nächste Termin ist derjenige mit der kleinsten Zeit;
    // falls das Array buf leer ist, wird -1 zurückgegeben
    int findNext() const;

  public:
    Calendar(int size = 100);
    Calendar(const Calendar& c);
    ~Calendar();
    Calendar& operator=(const Calendar& c);

    // Termin e eintragen;
    // falls die entsprechende Zeit schon belegt ist, dann keine Aktion
    void enter(const Event& e);

    // alle eingetragenen Termine auf den Bildschirm ausgeben
    // und zwar in der Reihenfolge, in der sie im Array buf stehen
    void display() const;

    // Termin e löschen;
    // beim Vergleich sollen sowohl Zeit als auch Text übereinstimmen;
    // falls der Termin nicht vorhanden ist, dann keine Aktion;
    // die eventuell entstehende Lücke im Feld buf wird durch den letzten
    // Eintrag im Feld ersetzt, falls es mindestens einen weiteren Eintrag gibt
    void cancel(const Event& e);

    // eine Kopie des nächsten Termins liefern;
    // der nächste Termin ist derjenige mit der kleinsten Zeit
    Event readNext() const;
};

int Calendar::findTime(const Event& e) const
{
    for (int i = 0; i < maxSize; i++)
    {
        if ((Time)buf[i] == (Time)e)
            return i;
    }

    return -1;
}

int Calendar::findEvent(const Event& e) const
{
    for (int i = 0; i < maxSize; i++)
    {
        if (buf[i] == e)
            return i;
    }

    return -1;
}

int Calendar::findNext() const
{
    if (buf == NULL)
        return -1;

    int i = 0;

    Time* temp = &buf[i];

    while (i < maxSize)
    {
        if (temp[i] < temp[i+1])
            temp = &(Time)buf[i];

        i++;
    }

    return i;
}

//Konstruktor
Calendar::Calendar(int size)
{
    maxSize = size;
    count = 0;
    buf = new Event[maxSize]; //Speicherplatz für n vektorelemente reservieren

}

//Kopierkonstruktor
Calendar::Calendar(const Calendar& c)
{
    if (&c == NULL)
        error("Zugewiesener Calender ist NULL !");

    buf = new Event[maxSize];

    for (int i = 0; i < maxSize; i++)
        buf[i] = c.buf[i];

    this->maxSize = c.maxSize;
    this->count = c.count;
}

//Destruktor
Calendar::~Calendar()
{
    delete [] buf;
}

Calendar& Calendar::operator=(const Calendar& c)
{
    if (this != &c)
    {
        delete [] buf;

        buf = new Event[c.maxSize];
        for (int i = 0; i < maxSize; i++)
            buf[i] = c.buf[i];

        maxSize = c.maxSize;
        count = c.count;
    }

    return *this;
}

void Calendar::enter(const Event& e)
{
    if (findEvent(e) == -1)
        return;
    else
    {
        if (count < maxSize)
        {
            buf[count++] = e;   //i increase the counter by one
        }
    }
}

void Calendar::display() const
{
    if (buf== NULL)
        return;

    for (int i = 0; i < count; i++) //maxSize
    {
        buf[i].display();
    }
    cout << count; //TEEEEST...Why do i get 0 ??
}

void Calendar::cancel(const Event& e)
{
    for (int i = 0; i < count; i++)
    {
        if (buf[i] == e)
        {
            if (count > 1)
                buf[i] = buf[count];
            else
                buf[i] = NULL;
        }

        count--;
    }
}

Event Calendar::readNext() const
{
    return findNext();
}


int _tmain(int argc, _TCHAR* argv[])
{
    Calendar c = Calendar(5);
    Event e = Event(13, 10, 2, "C++ Klausur");

    c.enter(e); //add one element (add the counter by one)
    c.display(); //doesn't display anything...says counter is still zero

    char f;
    cin >> f;
    return 0;
}