void TbbZad1()
{
    tbb::tick_count start, end;

    std::cout << "SEKWENCYJNIE" << std::endl;

    start = tbb::tick_count::now();
    for (int i = 0; i < 16; i++) printf("Hello world %d\n", i);
    end = tbb::tick_count::now();
    printf("Sekwencyjnie time: %12.8f\n\n", (end - start).seconds());




    std::cout << "ROWNOLEGLE" << std::endl;
    printf("parallel invoke lambda \n");
    start = tbb::tick_count::now();
    tbb::parallel_invoke(
        []() { for (int i = 0; i < 8; i++) printf("Hello world %d\n", i); },
        []() { for (int i = 0; i < 8; i++) printf("Hello world %d\n", i); }
    );
    end = tbb::tick_count::now();
    printf("Parallel invoke lambda time: %12.8f\n", (end - start).seconds());


    printf("parallel invoke pointer to function \n");
    start = tbb::tick_count::now();
    tbb::parallel_invoke(
        tbbPrintHello,
        tbbPrintHello
    );
    end = tbb::tick_count::now();
    printf("Parallel invoke pointer to function time: %12.8f\n", (end - start).seconds());

    printf("parallel invoke funktor \n");
    FuncClass obj1, obj2;
    start = tbb::tick_count::now();
    tbb::parallel_invoke(
        obj1,
        obj2
    );
    end = tbb::tick_count::now();
    printf("Parallel invoke funktor time: %12.8f\n", (end - start).seconds());

}

void TbbZad2()
{
    std::vector<int> vecTBB;
    tbb::tick_count start, end;

    for (int i = 0; i < 100; i++)
    {
        vecTBB.push_back(rand());

    }
    std::cout << "SEKWENCYJNIE" << std::endl;
    start = tbb::tick_count::now();

    for (int i = 0; i < 100; i++)
    {
        printf("%d\n", vecTBB[i]);
    }
    end = tbb::tick_count::now();
    printf("Sekwencyjnie time:  %12.8f\n\n", (end - start).seconds());

    std::cout << "ROWNOLEGLE" << std::endl;
    start = tbb::tick_count::now();
    tbb::parallel_for_each(vecTBB.begin(), vecTBB.end(), [&](int& v) {printf("%d\n", v); });
    end = tbb::tick_count::now();
    printf("parallel_for_each time:  %12.8f\n", (end - start).seconds());

}

void TbbZad3()
{

    std::vector<int> vecTBB;

    tbb::tick_count start, end;
    for (int i = 0; i < 100; i++)
    {
        vecTBB.push_back(i);
    }


    std::cout << "SEKWENCYJNIE" << std::endl;

    start = tbb::tick_count::now();
    for (int i = 0; i < 100; i++)
    {
        if (vecTBB[i] % 2 == 0)
        {
            printf("%d\n", vecTBB[i]);
        }
    }
    end = tbb::tick_count::now();
    printf("Sekwencyjnie time:  %12.8f\n\n", (end - start).seconds());



    std::cout << "ROWNOLEGLE" << std::endl;
    start = tbb::tick_count::now();
    tbb::parallel_for(tbb::blocked_range<int>(0, vecTBB.size()),
        [&](tbb::blocked_range<int> r)
        {
            for (int i = r.begin(); i < r.end(); ++i)
            {
                if (vecTBB[i] % 2 == 0)
                {
                    printf("%d \n", vecTBB[i]);
                }
            }
        });

    end = tbb::tick_count::now();
    printf("parallel_for_each time: %g\n", (end - start).seconds());
}

bool isPrime(int n)
{
    if (n <= 1)
        return false;

    for (int i = 2; i < n; i++)
        if (n % i == 0)
            return false;

    return true;
}

void TbbZad4()
{
    tbb::tick_count start, end;
    std::vector<int>numbers;
    std::vector<int>primeNumbers;

    for (int i = 0; i < 100; i++)
    {
        numbers.push_back(i);
    }

    auto isPrime = [&primeNumbers](int& n)
    {
        bool retVaal = true;
        if (n <= 1)
            retVaal = false;

        for (int i = 2; i < n; i++)
        {
            if (n % i == 0)
            {
                retVaal = false;
            }
        }

        if (retVaal == true)
        {
            primeNumbers.push_back(n);
        };
    };

    std::cout << "SEKWENCYJNIE" << std::endl;

    start = tbb::tick_count::now();
    for (int i = 0; i < numbers.size(); i++)
    {
        isPrime(numbers[i]);
    }
    std::sort(primeNumbers.begin(), primeNumbers.end());
    for (int i = 0; i < primeNumbers.size(); i++)
    {
        std::cout << primeNumbers[i] << std::endl;
    }

    end = tbb::tick_count::now();
    printf("Sekwencyjnie time:  %12.8f\n\n", (end - start).seconds());



    primeNumbers.clear(); // clear vector xD

    numbers[90] = 127;
    std::cout << "ROWNOLEGLE" << std::endl;

    start = tbb::tick_count::now();
    tbb::parallel_do(numbers, isPrime);

    //  std::sort(primeNumbers.begin(), primeNumbers.end());
    tbb::parallel_sort(primeNumbers.begin(), primeNumbers.end());

    for (int i = 0; i < primeNumbers.size(); i++)
    {
        std::cout << primeNumbers[i] << std::endl;
    }

    end = tbb::tick_count::now();
    printf("Rownolegle time:  %12.8f\n\n", (end - start).seconds());

}

void TbbZad5()
{
    std::vector<int> vecTBB;

    tbb::tick_count start, end;
    for (int i = 0; i < 100; i++)
    {
        vecTBB.push_back(i);
    }

    /* sum */
    std::cout << "SEKWENCYJNIE" << std::endl;

    int sum = 0;
    start = tbb::tick_count::now();
    for (int i = 0; i < 100; i++)
    {
        sum += vecTBB[i];
    }
    end = tbb::tick_count::now();
    std::cout << "SUMA: " << sum << std::endl;

    printf("Suma sekwencyjnie time: %g\n\n", (end - start).seconds());


    std::cout << "ROWNOLEGLE" << std::endl;

    start = tbb::tick_count::now();
    auto total = tbb::parallel_reduce(
        tbb::blocked_range<int>(0, vecTBB.size()),
        0.0,
        [&](tbb::blocked_range<int> r, double running_total)
        {
            for (int i = r.begin(); i < r.end(); ++i)
            {
                running_total += vecTBB[i];
            }

            return running_total;
        }, std::plus<int>());
    end = tbb::tick_count::now();


    std::cout << total << std::endl;
    printf("Suma parallel_reduce time: %g\n\n", (end - start).seconds());



    /* max */
    std::cout << "SEKWENCYJNIE" << std::endl;

    int max = MININT;
    start = tbb::tick_count::now();
    for (int i = 0; i < 100; i++)
    {
        if (vecTBB[i] > max)
        {
            max = vecTBB[i];
        }
    }
    end = tbb::tick_count::now();
    std::cout << "max: " << max << std::endl;

    printf("max sekwencyjnie time: %g\n\n", (end - start).seconds());


    std::cout << "ROWNOLEGLE" << std::endl;

    start = tbb::tick_count::now();
    auto maxx = tbb::parallel_reduce(
        tbb::blocked_range<int>(0, vecTBB.size()),
        0,
        [&](tbb::blocked_range<int> r, int val)
        {
            //printf("Val: %d\n", val);
            for (int i = r.begin(); i < r.end(); ++i)
            {
                if (vecTBB[i] > val)
                    val = vecTBB[i];
            }

            return val;
        },
        [](int a, int b) { return std::max<int>(a, b); });

    end = tbb::tick_count::now();


    std::cout << "max: " << maxx << std::endl;
    printf("Max parallel_reduce time: %g\n\n", (end - start).seconds());


    /* min */
    std::cout << "SEKWENCYJNIE" << std::endl;

    vecTBB[90] = -123;

    int min = MAXINT;
    start = tbb::tick_count::now();
    for (int i = 0; i < 100; i++)
    {
        if (vecTBB[i] < min)
        {
            min = vecTBB[i];
        }
    }
    end = tbb::tick_count::now();
    std::cout << "min: " << min << std::endl;

    printf("min sekwencyjnie time: %g\n\n", (end - start).seconds());

    std::cout << "ROWNOLEGLE" << std::endl;

    start = tbb::tick_count::now();
    auto minn = tbb::parallel_reduce(
        tbb::blocked_range<int>(0, vecTBB.size()),
        0,
        [&](tbb::blocked_range<int> r, int val)
        {
            //printf("Val: %d\n", val);
            for (int i = r.begin(); i < r.end(); ++i)
            {
                if (vecTBB[i] < val)
                    val = vecTBB[i];
            }

            return val;
        },
        [](int a, int b) { return std::min<int>(a, b); });

    end = tbb::tick_count::now();


    std::cout << "min: " << minn << std::endl;
    printf("Max parallel_reduce time: %g\n\n", (end - start).seconds());


}

void printMatrix(float** matrix, int rows, int cols)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

bool loadMatrix(float**& matrix, const char* path, int& _rows, int& _cols)
{
    std::ifstream dataFile;
    dataFile.open(path);
    int rows, cols;

    if (dataFile.fail())
        return false;

    dataFile >> rows;
    dataFile >> cols;

    matrix = new float* [rows];
    for (int i = 0; i < rows; i++)
    {
        matrix[i] = new float[cols];
    }

    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            float x;
            dataFile >> x;

            matrix[i][j] = x;
        }
    }

    _rows = rows;
    _cols = cols;
    dataFile.close();


    return true;
}

void generateMatrix(int rows, int cols, const char* path)
{
    std::ofstream outFile;
    outFile.open(path);
    outFile << rows << " " << cols << std::endl;

    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            outFile << (static_cast <float> (rand()) / static_cast <float> (RAND_MAX)) * 100 << " ";
        }

        outFile << std::endl;
    }
    outFile.close();
}

void clearMemory(float** matrix, int rows)
{

    for (int i = 0; i < rows; i++)
    {
        delete[] matrix[i];
    }
    delete[] matrix;
}



void TbbZad6()
{
    srand(time(NULL));

    const char* pathA = "matrixA.txt";
    const char* pathB = "matrixB.txt";

    generateMatrix(1000, 500, pathA);
    generateMatrix(500, 1000, pathB);

    int rowsA, colsA, rowsB, colsB, rowsC, colsC;
    float** matrixA = nullptr;
    float** matrixB = nullptr;
    float** matrixCS = nullptr;
    float** matrixCR = nullptr;
    loadMatrix(matrixA, pathA, rowsA, colsA);
    loadMatrix(matrixB, pathB, rowsB, colsB);

    std::cout << "Macierz A" << std::endl;
    //printMatrix(matrixA, rowsA, colsA);
    std::cout << "\nMacierz B" << std::endl;
    //printMatrix(matrixB, rowsB, colsB);

    if (rowsA == colsB && rowsB == colsA)
    {

        rowsC = rowsA;
        colsC = colsB;

        matrixCS = new float* [rowsC];
        matrixCR = new float* [rowsC];

        for (int i = 0; i < rowsC; i++)
        {
            matrixCS[i] = new float[colsC];
            matrixCR[i] = new float[colsC];
        }

        for (int i = 0; i < rowsC; i++)
        {
            for (int j = 0; j < colsC; j++)
            {
                matrixCS[i][j] = 0.0;
                matrixCR[i][j] = 0.0;
            }
        }


        /****************************************************************/
        std::cout << "SEKWENCYJNIE" << std::endl;
        tbb::tick_count start, end;
        start = tbb::tick_count::now();
        for (int i = 0; i < rowsA; i++)
        {
            for (int j = 0; j < colsB; j++)
            {
                for (int k = 0; k < colsA; k++)
                {
                    matrixCS[i][j] += matrixA[i][k] * matrixB[k][j];
                }
            }
        }
        end = tbb::tick_count::now();
        printf("Sekwencyjnie time: %g\n\n", (end - start).seconds());



        std::cout << "ROWNOLEGLE" << std::endl;
        //tbb::tick_count start, end;
        start = tbb::tick_count::now();
        tbb::parallel_for(0, rowsA, [&](int i)
            {

                for (int j = 0; j < colsB; j++)
                {
                    for (int k = 0; k < colsA; k++)
                    {
                        matrixCR[i][j] += matrixA[i][k] * matrixB[k][j];
                    }
                }
            });
        end = tbb::tick_count::now();
        printf("ROWNOLEGLE time: %g\n\n", (end - start).seconds());

        /****************************************************************/
        std::cout << "\nMacierz C" << std::endl;
        //printMatrix(matrixC, rowsC, colsC);


        std::ofstream outFileS;
        std::ofstream outFileR;
        outFileS.open("macierzCS.txt");
        outFileR.open("macierzCR.txt");
        outFileS << rowsC << " " << colsC << std::endl;
        outFileR << rowsC << " " << colsC << std::endl;

        for (int i = 0; i < rowsC; i++)
        {
            for (int j = 0; j < colsC; j++)
            {
                outFileS << matrixCS[i][j] << " ";
                outFileR << matrixCR[i][j] << " ";
            }

            outFileS << std::endl;
            outFileR << std::endl;
        }

        outFileS.close();
        outFileR.close();
        clearMemory(matrixA, rowsA);
        clearMemory(matrixB, rowsB);
        clearMemory(matrixCS, rowsC);
        clearMemory(matrixCR, rowsC);
    }
    else
    {
        std::cout << "Error matrix size not correct!!!" << std::endl;
    }
}