#include <iostream>
#include <thread>
#include <condition_variable>

#define THREAD_COUNT 4
#define ARRAY_SIZE 1000000

int wart = 0;
std::mutex mt;

int squareFunction(int x)
{
    return ((x * x) + 2);
}

void decrease(int arg, int &x)
{
    for (int i = 0; i < arg; ++i)
    {
        mt.lock();
        x -= 1;
        mt.unlock();
    }
}

void increase(int arg, int &x)
{
    for (int i = 0; i < arg; ++i)
    {
        mt.lock();
        x += 1;
        mt.unlock();
    }
}

int* generateArray()
{
    int *tab = new int[ARRAY_SIZE]();
    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        tab[i] = rand() % 100000 + 1;
    }

    tab[34251] = -10;
    tab[523671] = -100;
    return tab;
}

void findMinimum(int indexOfStart, int indexOfEnd, int &minimum, int *array)
{
    for (int i = indexOfStart; i < indexOfEnd; ++i)
    {
        mt.lock();
        if (minimum > array[i])
        {
            minimum = array[i];
        }
        mt.unlock();
    }
}

void calculateIntegral(int begining, int ending, int &result)
{
    int height = ending - begining;
    result += ((squareFunction(begining) + squareFunction(ending)) / 2) * height;
}

int main()
{

    {
        std::thread increaseThread(increase, 1000000, std::ref(wart));
        std::thread decreaseThread(decrease, 1000000, std::ref(wart));

        increaseThread.join();
        decreaseThread.join();

        std::cout << "Wartosc wart z zdania pierwszego: " << wart << '\n';
    }


    {
        std::thread minimumFindingThreads[THREAD_COUNT];

        int minimum = 0;
        int *tab = generateArray();

        int startingIndex = 0;
        int endingIndex = ARRAY_SIZE / THREAD_COUNT;
        int interval = endingIndex;
        for (int i = 0; i < THREAD_COUNT; ++i)
        {
            minimumFindingThreads[i] = std::thread(findMinimum, startingIndex, endingIndex,
                std::ref(minimum), tab);
            startingIndex = endingIndex;
            endingIndex += interval;
        }

        for (int i = 0; i < THREAD_COUNT; ++i)
        {
            minimumFindingThreads[i].join();
        }

        std::cout << "Najmniejszy element tablicy: " << minimum << '\n';
    }

    {
        int result = 0;

        std::thread calculateIntegralThreads[THREAD_COUNT];
        int fromIntegral = 0;
        int toIntegral = 12 / THREAD_COUNT;
        int interval = toIntegral;
        for (int i = 0; i < THREAD_COUNT; ++i)
        {
            calculateIntegralThreads[i] = std::thread(calculateIntegral, fromIntegral, toIntegral,
                    std::ref(result));
            fromIntegral += interval;
            toIntegral += interval;
        }
        for (int i = 0; i < THREAD_COUNT; ++i)
        {
            calculateIntegralThreads[i].join();
        }

        std::cout << "Calka: " << result << '\n';
    }


}