#pragma once

#ifndef _H_PARKING_

#define _H_PARKING_

#include <iostream>
#include <exception>

class car
{
public:
    car():number(), place_where_wife_wake_up() {}

    car(int number, int place_where_wife_wake_up) :number(number), place_where_wife_wake_up(place_where_wife_wake_up) {}

    friend std::ostream& operator<< (std::ostream& out, const car& car);
    friend bool operator==(car const& left, car const& right);

    void set_number_of_car(int number)
    {
        this->number = number;
    }

    void set_place_where_wife_wake_up(int place_where_wife_wake_up)
    {
        this->place_where_wife_wake_up = place_where_wife_wake_up;
    }

    int get_number_of_car()
    {
        return number;
    }

    int get_place_where_wife_wake_up()
    {
        return place_where_wife_wake_up;
    }

private:
    int number;
    int place_where_wife_wake_up;
};

inline std::ostream& operator<<(std::ostream& out, const car& car)
{
    out << "number: " << car.number << "| place where wife wake up: " << car.place_where_wife_wake_up;
    return out;
}

inline bool operator==(car const& left, car const& right)
{
    return left.number == right.number && left.place_where_wife_wake_up == right.place_where_wife_wake_up;
}

class parking
{
public:
    parking(unsigned int size):number_of_cars_in_the_parking(0), size(size)
    {
        if (size > 0)
        {
            table = new car* [size];
            for (unsigned int i = 0; i < size; i++)
            {
                table[i] = nullptr;
            }
        }
        else
        {
            throw std::exception("size <= 0");
        }
    }

    ~parking()
    {
        for (unsigned int i = 0; i < size; i++)
        {
            delete table[i];
        }

        delete table;

        size = 0;
    }

    bool add(unsigned int key, car value)
    {
        if (size <= key - 1)
        {
            return false;
        }

        for (unsigned int i = key - 1; i < size; ++i)
        {
            if (!table[i])
            {
                table[i] = new car(value);
                ++number_of_cars_in_the_parking;
                return true;
            }
        }
        return false;
    }

    void erase(car erase)
    {
        for (int i = 0; i < size; ++i)
        {
            if (table[i] && *table[i] == erase)
            {
                delete table[i];
                table[i] = nullptr;
                --number_of_cars_in_the_parking;
                return;
            }
        }
    }

    car& operator[](int index)
    {
        if (index >= 1 && table[index - 1])
        {
            return *table[index];
        }
        else
        {
            throw std::exception("empty index");
        }
    }

    unsigned int get_size()
    {
        return size;
    }

    unsigned int get_number_of_cars_in_the_parking()
    {
        return number_of_cars_in_the_parking;
    }

    friend std::ostream& operator<< (std::ostream& out, const parking& hash_table);

private:
    car **table;
    unsigned int size;
    unsigned int number_of_cars_in_the_parking;
};

inline std::ostream& operator<<(std::ostream& out, const parking& hash_table)
{
    for (unsigned int i = 0; i < hash_table.size; i++)
    {
        if (hash_table.table[i])
        {
            out << i + 1 << " (" << *hash_table.table[i] << ")\n";
        }
    }

    return out;
}

#endif // !_H_PARKING_