#include <iostream>
#include <new>
#include <fstream>
#include <sstream>
#include <string>

using namespace std;
struct UserInformation {
    string name; // the name of the applicant
    int averageScore{};  //average score
};

// клас, що реалізує стек у вигляді динамічного масиву
template<typename T>
class STACK {
private:
    T *stack; // Динамічний масив-покажчик на стек
    int count; // Вершина стеку - к-сть елементів типу T в стеку

public:
    // конструктор за замовчуванням
    STACK() {
        stack = nullptr; // необов'язково
        count = 0; // к-сть елементів у стеку визначається за значенням count
    }

    // помістити елемент в стек
    void push(T item) {
        T *tmp; // тимчасовий покажчик

        // блок try необхідний для перехоплення виключення, якщо пам'ять не виділиться
        try {
            // покажчик показує на stack (щоб не загубити адресу покажчика stack)
            tmp = stack;

            // виділити пам'ять на 1 елемент більше, ніж було виділено перед цим в стеку
            stack = new T[count + 1];

            // збільшити кількість елементів в стеку на 1
            count++;

            // скопіювати дані з пам'яті, на яку вказує tmp в пам'ять,
            // на яку вказує stack
            for (int i = 0; i < count - 1; i++)
                stack[i] = tmp[i];

            // додати останній елемент
            stack[count - 1] = item;

            // звільнити пам'ять, яка була перед цим виділена для stack,
            // на цю пам'ять вказує tmp
            if (count > 1)
                delete[] tmp;
        }
        catch (bad_alloc e) {
            // якщо пам'ять не виділилась
            cout << e.what() << endl;
        }
    }

    // конструктор копіювання STACK(const STACK&) - необхідний для уникнення
    // недоліків побітового копіювання
    STACK(const STACK &st) {
        try {
            // 1. Виділити нову ділянку пам'яті для масиву stack
            stack = new T[st.count];

            // 2. Скопіювати дані з st в поточний об'єкт
            count = st.count;
            for (int i = 0; i < count; i++)
                stack[i] = st.stack[i];
        }
        catch (bad_alloc e) {
            // якщо пам'ять не виділилась, то вивести відповідне повідомлення
            cout << e.what() << endl;
        }
    }

    // операторна функція operator=(const STACK&) - необхідна для уникнення
    // недоліків побітового копіювання
    STACK operator=(const STACK &st) {
        // Потрібно скопіювати з st в поточний об'єкт
        // 1. Звільнити попередньо виділену пам'ять для поточного об'єкту
        if (count > 0) {
            count = 0;
            delete[] stack; // звільнити пам'ять під попередній масив
        }

        // 2. Виділити нову ділянку пам'яті для масиву stack
        try {
            // спроба виділити пам'ять
            stack = new T[st.count];

            // 3. Скопіювати дані з st в поточний об'єкт
            count = st.count;
            for (int i = 0; i < count; i++)
                stack[i] = st.stack[i];
        }
        catch (bad_alloc e) {
            // якщо не вдалось виділити пам'ять, то вивести відповідне повідомлення
            cout << e.what() << endl;
        }

        // 4. Повернути поточний об'єкт
        return *this;
    }

    // Деструктор - звільняє пам'ять
    ~STACK() {
        if (count > 0)
            delete[] stack;
    }

    // Кількість елементів у стеку
    int Count() {
        return count;
    }

    // Функція, що виводить стек
    void Print(int o) {
        T *p; // тимчасовий покажчик, рухається по елементах стеку

        // 1. Встановити покажчик p на вершину стеку
        p = stack;

        // 2. Вивід
        if (count == 0)
            cout << "is empty." << endl;
        if (o == -1) {
            for (int i = 0; i < count; i++) {
                cout << *p;
                p++; // прокрутити покажчик на наступний елемент
            }
        } else {
            for (int i = count - o; i < count; i++) p++;

            cout << *p;
        }
    }
};

int main() {
    //---------------------------------------------------------------------------
    STACK<UserInformation> ST;
    UserInformation temporaryStructure;

    STACK<int> stX;
    STACK<string> stY;
    //import file
    ifstream file;
    file.open("..\\tess.txt");

    //read line by line and write to database
    string line;
    int min = -1;

    while (getline(file, line)) {
        stringstream word(line);
        word >> temporaryStructure.name;
        word >> temporaryStructure.averageScore;
        if (min == -1 || min > temporaryStructure.averageScore) {
            min = temporaryStructure.averageScore;
            stX = *new STACK<int>;
            stY = *new STACK<string>;
            stX.push(temporaryStructure.averageScore);
            stY.push(temporaryStructure.name);
        } else if (min == temporaryStructure.averageScore) {
            stX.push(temporaryStructure.averageScore);
            stY.push(temporaryStructure.name);
        }

    }
    cout << "---[1]---" << endl;

    for (int i = 0; i < stY.Count(); i++) {
        stY.Print(i);
        cout << " ";
        stX.Print(i);
        cout << endl;
    }


    cout << endl << endl << "-------------------------" << endl;
    //---------------------------------------------------------------------------
}