#include <iostream>
#include <list>
#include <vector>
#include <ctime>
#include <string>
#include <fstream>

using namespace std;

/**
 * \brief ask a question and get a answer.
 * \tparam T return parameter
 * \param question the question.
 * \return the value.
 */
template <typename T>
T ask_question(const string& question)
{
    cout << question << ": ";
    T value;
    cin >> value;
    return value;
}

/**
 * \brief Returns true if answer was 'J'. False if user answered with 'N'
 * \param question The question for user input.
 * \return 
 */
bool ask_question(const string& question)
{
    while (true)
    {
        const auto answer = ask_question<char>(question + " (J/N)");
        if (answer == 'j' || answer == 'J')
        {
            return true;
        }
        if (answer == 'n' || answer == 'N')
        {
            return false;
        }
        cout << "Ungueltige Eigabe. Bitte noch einmal versuchen!";
    }
}

/**
 * \brief Converts a int to string and fill up with '0' at first position.
 * \param value the integer value.
 * \param digits Number of digits to fill
 * \return Formatted integer as string
 */
string int_to_string(const unsigned int value, const unsigned int digits = 0)
{
    auto str = to_string(value);
    const auto len = digits > str.length() ? digits - str.length() : 0;
    for (unsigned int i = 0; i < len; ++i)
    {
        str.insert(0, "0");
    }
    return str;
}

/**
 * \brief Present a date with day, month and year
 */
class date final
{
    unsigned short day_;
    unsigned short month_;
    unsigned short year_;
    int day_num_;

    /**
     * \brief Get the day number from current day/month/year.
     * \return Number of days
     */
    int day_number_from_date() const
    {
        const auto month = (month_ + 9) % 12;
        const auto year = year_ - month / 10;
        return 365 * year + year / 4 - year / 100 + year / 400 + (month * 306 + 5) / 10 + (day_ - 1);
    }

public:
    date(const unsigned short day, const unsigned short month, const unsigned short year) : day_(day), month_(month),
                                                                                            year_(year),
                                                                                            day_num_(
                                                                                                day_number_from_date())
    {
    }

    /**
     * \brief Get day num of current day/month/year
     * \return Number of days
     */
    int get_day_num() const
    {
        return day_num_;
    }

    /**
     * \brief Output operator of date formatted as DD.MM.YYYY
     * \param ostr output stream
     * \param date current date
     * \return output stream
     */
    friend ostream& operator<<(ostream& ostr, const date& date)
    {
        ostr << int_to_string(date.day_, 2) << "."
            << int_to_string(date.month_, 2) << "."
            << int_to_string(date.year_, 4);
        return ostr;
    }
};

/**
 * \brief address containing street, no, postal code and city
 */
class address final
{
    string street_;
    string street_no_;
    string postal_code_;
    string city_;
public:
    address() = default;

    address(const string&& street, const string&& street_no, const string&& postal_code, const string&& city) :
        street_(street),
        street_no_(street_no),
        postal_code_(postal_code),
        city_(city)
    {
    }

    /**
     * \brief Input operator of address
     * \param istr output stream
     * \param address current address
     * \return output stream
     */
    friend istream& operator>>(istream& istr, address& address)
    {
        cout << "Strasse: ";
        istr >> address.street_;
        cout << "Hausnummer: ";
        istr >> address.street_no_;
        cout << "Postleitzahl: ";
        istr >> address.postal_code_;
        cout << "Ort: ";
        istr >> address.city_;
        return istr;
    }

    /**
     * \brief Output operator of address
     * \param ostr output stream
     * \param address current address
     * \return output stream
     */
    friend ostream& operator<<(ostream& ostr, const address& address)
    {
        ostr << "Strasse: " << address.street_ << endl;
        ostr << "Hausnummer: " << address.street_no_ << endl;
        ostr << "Postleitzahl: " << address.postal_code_ << endl;
        ostr << "Ort: " << address.city_ << endl;
        return ostr;
    }
};

/**
 * \brief Incremental raised number as id for customer.
 */
int next_customer_id;

/**
 * \brief Customer, represented by name, first name, address, phone and year of birth
 */
class customer final
{
    int id_;
    string name_;
    string first_name_;
    address address_;
    unsigned short year_of_birth_ = 1900;
    string phone_no_;
    bool has_driving_license_ = false;
public:
    customer() : id_(++next_customer_id)
    {
    }

    customer(string&& name, string&& first_name, address&& address, unsigned short&& year_of_birth, string&& phone_no,
             bool&& has_driving_license) : id_(++next_customer_id),
                                           name_(name),
                                           first_name_(first_name),
                                           address_(address),
                                           year_of_birth_(year_of_birth),
                                           phone_no_(phone_no),
                                           has_driving_license_(has_driving_license)
    {
    }

    /**
     * \brief Input operator of customer
     * \param istr input stream
     * \param customer current address instance
     * \return output stream
     */
    friend istream& operator>>(istream& istr, customer*& customer)
    {
        cout << "Name: ";
        istr >> customer->name_;
        cout << "Vorname: ";
        istr >> customer->first_name_;
        cout << "Geburtsjahr: ";
        istr >> customer->year_of_birth_;
        istr >> customer->address_;
        cout << "Telefonnumer: ";
        istr >> customer->phone_no_;
        customer->has_driving_license_ = ask_question("Fuehrerschein der Klasse A?");
        return istr;
    }

    /**
     * \brief Output operator of customer
     * \param ostr output stream
     * \param customer current customer instance
     * \return output stream
     */
    friend ostream& operator<<(ostream& ostr, const customer& customer)
    {
        ostr << "Name: " << customer.name_ << endl;
        ostr << "Vorname: " << customer.first_name_ << endl;
        ostr << "Geburtsjahr: " << customer.year_of_birth_ << endl;
        ostr << customer.address_;
        ostr << "Telefonnummer: " << customer.phone_no_ << endl;
        ostr << "Fuehrerschein " << (customer.has_driving_license_ ? "" : "nicht ") << "vorhanden." << endl;
        return ostr;
    }

    /**
     * \brief get name of customer
     * \return name
     */
    string get_name() const
    {
        return name_;
    }

    /**
     * \brief get first name of customer
     * \return first name
     */
    string get_first_name() const
    {
        return first_name_;
    }

    /**
     * \brief get the value, if customer hast driving license
     * \return True if customer hast driving license. False otherwise.
     */
    bool get_has_driving_license() const
    {
        return has_driving_license_;
    }
};

/**
 * \brief Incremental raised number as id for a reservation.
 */
int next_reservation_id;

/**
 * \brief Reservation of a motorcycle
 */
class reservation final
{
    int id_;
    date start_;
    date end_;
    short motorcycle_index_ = -1; // => -1 means nothing reserved
    customer* customer_;
    bool canceled_;
public:
    reservation(const date start, const date end, const short motorcycle, customer* customer) :
        id_(++next_reservation_id),
        start_(start),
        end_(end),
        motorcycle_index_(motorcycle),
        customer_(customer),
        canceled_(false)
    {
    }

    /**
     * \brief get start date of reservation
     * \return date instance
     */
    date get_start_date() const
    {
        return start_;
    }

    /**
     * \brief get end date of reservation
     * \return date instance
     */
    date get_end_date() const
    {
        return end_;
    }

    /**
     * \brief get index of motorcycle array
     * \return integer value of index
     */
    short get_motorcycle_index() const
    {
        return motorcycle_index_;
    }

    /**
     * \brief get pointer of customer, attached to this instance
     * \return pointer to customer
     */
    customer* get_customer() const
    {
        return customer_;
    }

    /**
     * \brief Cancel reservation -> Give Motorcycle to the customer
     */
    void cancel_reservation()
    {
        canceled_ = true;
    }

    /**
     * \brief Get Id of the item
     * \return Auto-incremented id as integer
     */
    int get_id() const
    {
        return id_;
    }

    /**
     * \brief get cancellation status of the reservation
     * \return True is canceled. False otherwise.
     */
    bool get_cancellation() const
    {
        return canceled_;
    }
};

/**
 * \brief All available motorcycles
 */
string motorcycles[] =
{
    "Suzuki Bandit",
    "Honda TransAlp",
    "BMW F 650 GS",
    "Kawasaki ZZR1400"
};

/**
 * \brief Collection of customer-pointers
 */
list<customer*> customers;

/**
 * \brief Collection of reservation pointers.
 */
list<reservation*> reservations;

/**
 * \brief Creates a new customer, let the user check the input and push it on the list.
 */
void create_customer();
void create_reservation();
void rent_a_motorcycle();
void export_reservations();
void main_menu();

/**
 * \brief Main entry method. Starts the main menu.
 * \return success code
 */
int main()
{
    main_menu();
    return 0;
}

/**
 * \brief Let the user choice an option.
 */
void main_menu()
{
    try
    {
        while (true)
        {
            system("cls");
            cout << "Motorradvermietung (" << reservations.size() << " Reservierungen; " << customers.size() <<
                " Kunden)"
                << endl << endl;
            cout << "Bitte w\x84hlen Sie eine Option:" << endl;
            cout << "1: Neuen Kunden anlegen" << endl;
            cout << "2: Erstellen einer Reservierung" << endl;
            cout << "3: Motorrad herausgeben" << endl;
            cout << "4: Reservierungen exportieren" << endl;
            cout << endl;
            cout << "0: Programm beenden" << endl;
            const auto input = ask_question<int>("Ihre Eingabe");

            switch (input)
            {
            case 1:
                create_customer();
                break;
            case 2:
                create_reservation();
                break;
            case 3:
                rent_a_motorcycle();
                break;
            case 4:
                export_reservations();
                break;
            case 0:
                {
                    return;
                }
            default:
                cout << "Unerlaubte Eingabe" << endl;
                system("pause");
            }
        }
    }
    catch (...)
    {
        cout << "Etwas unvorhergesehendes ist passiert. Tut mir leid." << endl;
        system("pause");
    }
}


/**
 * \brief Creates a new customer, let the user check the input and push it on the list.
 */
void create_customer()
{
    while (true)
    {
        system("cls");
        cout << "Neuen Kunden anlegen" << endl;
        cout << "------------------------------------" << endl;

        auto c = new customer;
        cin >> c;
        cout << endl << endl;
        cout << *c;
        if (ask_question("Angaben korrekt?"))
        {
            customers.push_back(c);
            return;
        }
    }
}


/**
 * \brief Finds customers by last name
 * \param name Last name
 * \return Returns a vector of customers with the same last name
 */
vector<customer*> find_customers_by_name(const string& name)
{
    vector<customer*> result;
    for (auto customer : customers)
    {
        if (customer->get_name() == name)
        {
            result.push_back(customer);
        }
    }
    return result;
}

/**
 * \brief Find the first customer by first name.
 * \param filtered_customers  A vector of customers with the same last name
 * \param first_name The first name
 * \return The first customer with the matching first name. If no customer found, it returns a nullptr
 */
customer* find_customer_by_first_name(const vector<customer*>& filtered_customers, const string& first_name)
{
    for (auto c : filtered_customers)
    {
        if (c->get_first_name() == first_name)
        {
            return c;
        }
    }
    return nullptr;
}

/**
 * \brief Gets the validated date
 * \param question Question to ask the user
 * \return A date object.
 */
date get_validated_date(const string&& question)
{
    while (true)
    {
        auto date_as_string = ask_question<string>(question + " (tt.mm.jjjj)");

        auto day = 0, month = 0, year = 0;
        const auto res = sscanf_s(date_as_string.c_str(), "%2d.%2d.%4d",
                                  &day,
                                  &month,
                                  &year);

        if (res == 3 && (month >= 1 && month <= 12) && (day >= 1 && day <= 31) && (year >= 1900 && month <= 2200))
        {
            return date{
                static_cast<const unsigned short>(day),
                static_cast<const unsigned short>(month),
                static_cast<const unsigned short>(year)
            };
        }
        cout << "Fehlerhafte Eingabe." << endl;
    }
}

/**
 * \brief 
 * \return 
 */
int select_motorcycle()
{
    while (true)
    {
        cout << "Bitte w\x84hlen sie ein Motorrad aus:" << endl;
        auto index = 0;
        for (const auto& cycle : motorcycles)
        {
            cout << ++index << ": " << cycle << endl;
        }
        const auto answer = ask_question<int>("Auswahl");
        if (answer > 0 && answer <= index)
        {
            return answer - 1;
        }
        cout << "Ung\x81ltige Eingabe" << endl << endl;
    }
}


bool validate_reservation(reservation* const reservation)
{
    const auto start_sum = reservation->get_start_date().get_day_num();
    const auto end_sum = reservation->get_end_date().get_day_num();
    for (auto r : reservations)
    {
        if (r->get_motorcycle_index() == reservation->get_motorcycle_index())
        {
            if (start_sum < r->get_end_date().get_day_num() && end_sum > r->get_start_date().get_day_num()
                || end_sum > r->get_start_date().get_day_num() && end_sum < r->get_end_date().get_day_num())
            {
                return false;
            }
        }
    }
    return true;
}

customer* get_customer()
{
    const auto name = ask_question<string>("Name des Kunden");
    auto customers = find_customers_by_name(name);
    if (customers.size() > 1)
    {
        const auto first_name = ask_question<string>("Vorname des Kunden");
        return find_customer_by_first_name(customers, first_name);
    }
    if (customers.empty())
    {
        return nullptr;
    }
    return customers.front();
}

void create_reservation()
{
    system("cls");
    const auto current = get_customer();
    if (current == nullptr)
    {
        cout << "Kunde nicht gefunden" << endl;
        system("pause");
        return;
    }
    cout << "Kunde gefunden: " << current->get_first_name() << " " << current->get_name() << endl;
    if (!current->get_has_driving_license())
    {
        cout << "Der Kunde hat keinen entsprechenden Fuehrerschein." << endl;
        system("pause");
        return;
    }
    const auto start_date = get_validated_date("Startdatum");
    const auto end_date = get_validated_date("Enddatum");
    const auto motorcycle = select_motorcycle();
    const auto r = new reservation(start_date, end_date, motorcycle, current);
    if (validate_reservation(r))
    {
        reservations.push_back(r);
    }
    else
    {
        cout << "Reservierung konnte nicht angelegt werden." << endl;
        cout << "Die Zeitperiode ueberschneidet sich mit einer vorhandenen Reservierung" << endl;
        system("pause");
    }
}


reservation* get_reservation_for_customer(customer* const current_customer)
{
    auto index = 0;
    vector<reservation*> reservations_of_customer;
    for (auto reservation : reservations)
    {
        if (reservation->get_customer() == current_customer)
        {
            cout << ++index << ". " << reservation->get_start_date() << " - " << reservation->get_end_date() << ": " <<
                motorcycles[reservation->get_motorcycle_index()] << endl;
            reservations_of_customer.push_back(reservation);
        }
    }
    index = ask_question<int>("Waehlen Sie eine Reservierung aus");
    return reservations_of_customer[index - 1];
}

void rent_a_motorcycle()
{
    system("cls");
    const auto current = get_customer();
    if (current == nullptr)
    {
        cout << "Kunde nicht gefunden" << endl;
        system("pause");
        return;
    }
    auto r = get_reservation_for_customer(current);
    const auto cancel_reservation = ask_question("Motorrad ausgeben?");
    cout << endl;
    if (cancel_reservation)
    {
        r->cancel_reservation();
        cout << "Motorrad reserviert!" << endl;
    }
    else
    {
        cout << "Reservierung abgebrochen" << endl;
    }
    system("pause");
}

string current_date_time()
{
    auto t = time(nullptr);
    struct tm buf{};
    localtime_s(&buf, &t);
    const auto time = int_to_string(buf.tm_hour, 2)
        + ":" + int_to_string(buf.tm_min, 2)
        + ":" + int_to_string(buf.tm_sec, 2);
    const auto date = int_to_string(buf.tm_mday, 2)
        + "." + int_to_string(1 + buf.tm_mon, 2)
        + "." + int_to_string(1900 + buf.tm_year, 4);

    return date + " " + time;
}

void export_reservations()
{
    ofstream f;
    f.open("reservierungen.txt", ios::app);
    f << "Export (" << current_date_time() << ")" << endl;
    f << "Id;Motorcycle;Start;End;Name;First_Name;Cancelled" << endl;
    for (auto reservation : reservations)
    {
        f << reservation->get_id() << ";";
        f << motorcycles[reservation->get_motorcycle_index()] << ";";
        f << reservation->get_start_date() << ";";
        f << reservation->get_end_date() << ";";
        f << reservation->get_customer()->get_name() << ";";
        f << reservation->get_customer()->get_first_name() << ";";
        f << (reservation->get_cancellation() ? "True" : "False") << endl;
    }
    f << "------------" << endl;
    f.close();
}