/*
1. Создайте проект из 2х cpp файлов и заголовочного (main.cpp, mylib.cpp, mylib.h)
во втором модуле mylib объявить 3 функции: для инициализации массива (типа float),
печати его на экран и подсчета количества отрицательных и положительных элементов.
Вызывайте эти 3-и функции из main для работы с массивом.
2. Описать макрокоманду (через директиву define), проверяющую, входит ли переданное
ей число (введенное с клавиатуры) в диапазон от нуля (включительно) до переданного
ей второго аргумента (исключительно) и возвращает true или false, вывести на экран
«true» или «false».
3. Задайте массив типа int. Пусть его размер задается через директиву препроцессора
#define. Инициализируйте его через ввод с клавиатуры. Напишите для него свою функцию
сортировки (например Пузырьком). Реализуйте перестановку элементов как макрокоманду
SwapINT(a, b). Вызывайте ее из цикла сортировки.
4.* Объявить структуру Сотрудник с различными полями. Сделайте для нее побайтовое
выравнивание с помощью директивы pragma pack. Выделите динамически переменную этого
типа. Инициализируйте ее. Выведите ее на экран и ее размер с помощью sizeof.
Сохраните эту структуру в текстовый файл.
5.* Сделайте задание 1 добавив свой неймспейс во втором модуле (первое задание тогда
можно не делать).
*/

#include <iostream>
#include "mylib.h"
#include <fstream>

void BubbleSort(int*, size_t);

int main()
{
    /* ********************** TASK #1 ********************** */
    // 5th task was made instead of the 1st

    /* ********************** TASK #2 ********************** */
    std::cout << "\t\tTASK #2\n\n";

    unsigned int iRightBoundary = 0U;
    unsigned int iUserNumber = 0U;

    std::cout << "\tEnter your number: ";
    std::cin >> iUserNumber;
    std::cout << "\tEnter the right range boundary: ";
    std::cin >> iRightBoundary;

    std::cout << "Answer is:\t" << std::boolalpha << CHECK_RANGE(iUserNumber, iRightBoundary);
    std::cout << std::noboolalpha << std::endl;
    system("pause");
    system("cls");

    /* ********************** TASK #3 ********************** */
    std::cout << "\t\tTASK #3\n\n";
    size_t iArraySize = 0U;

    std::cout << "Enter array size: ";
    DEFINE_NUMBER(iArraySize);

    int* aInts_3 = new (std::nothrow) int[iArraySize];

    if (iArraySize > 0 && aInts_3 != nullptr)
    {
        for (size_t i = 0U; i < iArraySize; i++)
        {
            PRINT_MSG(i, iArraySize);
            DEFINE_NUMBER(aInts_3[i]);
        }

        std::cout << "\n\tArray before sort: \n";
        PrintIntArray(aInts_3, iArraySize);
        BubbleSort(aInts_3, iArraySize);
        std::cout << "\n\tArray after sort: \n";
        PrintIntArray(aInts_3, iArraySize);

        delete[] aInts_3;
    }
    else
    {
        std::cerr << "Something wrong with array allocation!\n";
        return -1;
    }

    system("pause");
    system("cls");

    /* ********************** TASK #4 ********************** */
    std::cout << "\t\tTASK #4\n\n";

    S_Employee* empl = new S_Employee;
    std::cout << "\tEnter data about employee:\n";
    std::cout << "1. ID: ";
    std::cin >> empl->ID;
    std::cout << "2. Age: ";
    std::cin >> empl->age;
    std::cout << "3. Mark: ";
    std::cin >> empl->mark;
    std::cout << "4. Child Quantity: ";
    std::cin >> empl->ChildQuantity;
    std::cout << std::endl;

    std::cout << "\tSize of structure: " << sizeof(S_Employee) << std::endl;
    std::cout << "ID: " << empl->ID << "\n"
        << "Age: " << empl->age << "\n"
        << "Mark: " << empl->mark << "\n"
        << "Child Quantity: " << empl->ChildQuantity << std::endl;

    std::ofstream fout("Employee.txt");
    if (!fout)
    {
        std::cerr << "Something wrong with file creating!\n";
        return -2;
    }

    fout << "ID: " << empl->ID << "\n"
        << "Age: " << empl->age << "\n"
        << "Mark: " << empl->mark << "\n"
        << "Child Quantity: " << empl->ChildQuantity << "\n";
    fout.close();

    delete empl;
    system("pause");
    system("cls");

    /* ********************** TASK #5 ********************** */
    std::cout << "\t\tTASK #5\n\n";

    float* aFloats = new (std::nothrow) float[iArraySize];
    if (iArraySize > 0 && aFloats != nullptr)
    {
        size_t PositiveNumbers = 0U;
        size_t NegativeNumbers = 0U;
        MyNamespace::InitArray(aFloats, iArraySize);
        MyNamespace::PrintArray(aFloats, iArraySize);
        PositiveNumbers = MyNamespace::PosQuanArray(aFloats, iArraySize);
        NegativeNumbers = iArraySize - PositiveNumbers;

        std::cout << "Quantity of positive numbers: " << PositiveNumbers << std::endl;
        std::cout << "Quantity of negative numbers: " << NegativeNumbers << std::endl;

        delete[] aFloats;
    }

    system("pause");
    system("cls");

    return 0;
}

void BubbleSort(int* pArr, size_t size)
{
    for (size_t j = 1U; j < size; j++)
    {
        for (size_t i = 0U; i < size - j; i++)
        {
            if (pArr[i] > pArr[i + 1])
            {
                SwapINT(pArr[i], pArr[i + 1]);
            }
        }
    }
}