#include <iostream>
#include <vector>
#include <random>
#include <omp.h>

// Funkcja multiply_matrices() służy do mnożenia dwóch macierzy i zapisania wyniku w trzeciej macierzy.
void multiply_matrices(const std::vector<std::vector<double>>& matrix1,
                       const std::vector<std::vector<double>>& matrix2,
                       std::vector<std::vector<double>>& result) {
    int rows1 = matrix1.size();
    int cols1 = matrix1[0].size();
    int cols2 = matrix2[0].size();

    // Pętla for, która przechodzi przez wszystkie wiersze pierwszej macierzy i wszystkie kolumny drugiej macierzy.
    for (int i = 0; i < rows1; ++i) {
        for (int j = 0; j < cols2; ++j) {
            double sum = 0.0;
            // Pętla for, która przechodzi przez wszystkie kolumny pierwszej macierzy.
            for (int k = 0; k < cols1; ++k) {
                // Obliczenie sumy iloczynów elementów odpowiednich wierszy i kolumn obu macierzy.
                sum += matrix1[i][k] * matrix2[k][j];
            }
            // Zapisanie wyniku do odpowiedniego elementu macierzy wynikowej.
            result[i][j] = sum;
        }
    }
}

int main() {
    // Zmienna n określa liczbę macierzy, które będą mnożone.
    int n = 4;

    // Zmienna size określa rozmiar macierzy.
    int size = 3;

    // Zmienna rd jest obiektem klasy std::random_device, który służy do generowania liczb losowych.
    std::random_device rd;

    // Zmienna gen jest obiektem klasy std::mt19937, który służy do generowania liczb losowych.
    std::mt19937 gen(rd());

    // Zmienna dis jest obiektem klasy std::uniform_real_distribution, który służy do generowania liczb losowych z przedziału [0.0, 1.0].
    std::uniform_real_distribution<> dis(0.0, 1.0);

    // Tablica matrices jest tablicą macierzy o rozmiarze n x size x size.
    std::vector<std::vector<std::vector<double>>> matrices(n, std::vector<std::vector<double>>(size, std::vector<double>(size)));

    // Tablica results jest tablicą macierzy o rozmiarze n x size x size.
    std::vector<std::vector<std::vector<double>>> results(n, std::vector<std::vector<double>>(size, std::vector<double>(size)));

    // Pętla for, która przechodzi przez wszystkie macierze w tablicy matrices.
    for (int i = 0; i < n; ++i) {
        // Pętla for, która przechodzi przez wszystkie wiersze macierzy.
        for (int j = 0; j < size; ++j) {
            // Pętla for, która przechodzi przez wszystkie kolumny macierzy.
            for (int k = 0; k < size; ++k) {
                // Generowanie losowej liczby z przedziału [0.0, 1.0] i zapisanie jej do odpowiedniego elementu macierzy.
                matrices[i][j][k] = dis(gen);
            }
        }
    }

    // Dyrektywa #pragma omp parallel for num_threads(n) informuje kompilator, że pętla for poniżej powinna być wykonana równolegle z użyciem n wątków.
    #pragma omp parallel for num_threads(n)
    for (int i = 0; i < n; ++i) {
        // Wywołanie funkcji multiply_matrices() dla każdej pary macierzy w tablicy matrices.
        multiply_matrices(matrices[i], matrices[i], results[i]);
    }

    // Pętla for, która przechodzi przez wszystkie macierze w tablicy results.
    for (int i = 0; i < n; ++i) {
        // Wyświetlenie nagłówka z numerem macierzy.
        std::cout << "Wynik mnożenia macierzy " << i + 1 << ":" << std::endl;
        // Pętla for, która przechodzi przez wszystkie wiersze macierzy wynikowej.
        for (int j = 0; j < size; ++j) {
            // Pętla for, która przechodzi przez wszystkie kolumny macierzy wynikowej.
            for (int k = 0; k < size; ++k) {
                // Wyświetlenie elementu macierzy wynikowej.
                std::cout << results[i][j][k] << " ";
            }
            // Wyświetlenie nowej linii po każdym wierszu.
            std::cout << std::endl;
        }
        // Wyświetlenie nowej linii po każdej macierzy.
        std::cout << std::endl;
    }

    // Zwrócenie wartości 0, co oznacza, że program wykonał się poprawnie.
    return 0;
}