#include <iostream>
#include <string>
#include <ppl.h>
#include <vector>
#include <chrono>

class Matrix
{
public:

    int rows = 32;
    int cols = 32;

    std::vector<std::vector<double>> mat;


    double drand(double fMin, double fMax)
    {
        double f = (double)rand() / RAND_MAX;
        return fMin + f * (fMax - fMin);
    }

    Matrix(int iRows, int iCols) : rows(iRows), cols(iCols)
    {
        mat.resize(rows);
        for (int i = 0; i < rows; i++)
            mat[i].resize(cols);
    }


    Matrix RandomMatrix(double dispersion)
    {
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                mat[i][j] = drand(-dispersion, dispersion);

        return *this;
    }

    ~Matrix()
    {
    }

    void CalcMulRow(Matrix result, Matrix m1, Matrix m2, int index)
    {
        auto iRowA = m1.mat[index];
        auto iRowC = result.mat[index];
        for (int k = 0; k < m1.cols; k++)
        {
            auto kRowB = m2.mat[k];
            auto ikA = iRowA[k];
            for (int j = 0; j < result.cols; j++)
                iRowC[j] += ikA * kRowB[j];
        }
    }

    Matrix operator *(const Matrix &m)
    {
        if (this->cols != m.rows)
            throw ("Wrong dimensions of matrix, m1.cols (" + std::to_string(this->cols) + ") != m2.rows (" + std::to_string(m.rows) + ")!");

        Matrix rs(this->cols, m.rows);

        Concurrency::parallel_for(size_t(0), size_t(rows), [&](size_t i)
        {
            for (size_t j = 0; j < cols; j++)
            {
                double temp = 0;
                for (int k = 0; k < cols; k++)
                {
                    temp += this->mat[i][k] * m.mat[k][j];
                }

                rs.mat[i][j] = temp;
            }
        });

        return rs;
    }

};
typedef std::chrono::high_resolution_clock Clock;

int main()
{
    const int TRIALS = 10;

    Matrix A(1000, 1000);
    Matrix B(1000, 1000);

    A.RandomMatrix(1.0);
    B.RandomMatrix(1.0);

    std::vector<Matrix> mList;

    printf("Warming up, wait...\n");
    printf("Starting trials!\n");

    //actual trials
    std::chrono::time_point<std::chrono::steady_clock> before, after;

    before = Clock::now();

    for (int i = 0; i < TRIALS; i++)
    {
        mList.push_back(A * B);
    }

    after = Clock::now();

    std::chrono::duration<double, std::milli> fp_ms = after - before;

    printf("Milliseconds: %f\n", fp_ms);
    getchar();

    return 0;
}