#include <iostream>
#include "tbb/task_scheduler_init.h"
#include "tbb/tick_count.h"
#include "tbb/task.h"
#include <fstream>
#include <string>


using namespace std;
using namespace tbb;

#define GRAINSIZE  40


class Matrix {
private:



public:

    int n;
    int m;

    int ** podaci;

    /**
        "desc: ova metoda mnozi deo matrica a i b i smesta ih u deo matrice C (trenutni objekat nad kojim je pozvana ova metoda)
        *pocetna kolona - odakle poceti deo sa mnozenjem
        *krajnja  kolona - dokle ici po kolonama
        *krajnja vrsta q- dokle vrsta
        *a - referenca na matricu a
        *b - referenca na matricu b
    **/
    void multiplyRegion(int pocetnaKlolona, int krajnaKolona, int pocetnaVrsta, int krajnjaVrsta,  Matrix &a,Matrix &b){


            for (int i = pocetnaKlolona; i < krajnaKolona; i ++)
            {
                for (int j = pocetnaVrsta; j < krajnjaVrsta; j++)
                {
                    for (int k = 0; k < m; k ++){
                        podaci[i][j] += a.podaci[i][k] * b.podaci[k][j];
                    }
                }
            }
    }
    int izracunaj(int i , int j , Matrix &a ,Matrix &b,Matrix &c){
        for (int k = 0; k < m; k ++) //m je unutrasnja dimenzija dva vektora koja se mnoze
    {

        }
    }



    Matrix (int n , int m ){
        this->m = m;
        this->n = n;

        podaci = new int*[n];
        for(int i = 0; i < n ; i++){
            podaci[i] =  new int[m];
            for(int j = 0; j < m; j++){
                podaci[i][j] = 0;
            }
        }

    }

};

class CetvrtinaMatrice: public tbb::task
{
public:
    int pocetnaKolona, krajnjaKolona, pocetnaVrsta, krajnjaVrsta ;


    Matrix &a , &b ,&c;


    CetvrtinaMatrice(int pocetnaKolona_, int krajnjaKolona_, int pocetnaVrsta_, int krajnjaVrsta_, Matrix &a_, Matrix &b_, Matrix &c_) :
         pocetnaKolona( pocetnaKolona_), pocetnaVrsta(pocetnaVrsta_),krajnjaKolona(krajnjaKolona_), krajnjaVrsta(krajnjaVrsta_),  a(a_), b(b_), c(c_){}
    tbb::task* execute()////// za svaku malu cetvrtinu
    {
        if ((pocetnaKolona-krajnjaKolona)* (pocetnaVrsta - krajnjaVrsta) < GRAINSIZE)
        {
            c.multiplyRegion ( pocetnaKolona, krajnjaKolona,  pocetnaVrsta,  krajnjaVrsta,   a, b);
        } else {
            CetvrtinaMatrice& l1 = *new (allocate_child()) CetvrtinaMatrice(pocetnaKolona, (pocetnaKolona +krajnjaKolona)/2, pocetnaVrsta, (pocetnaVrsta +krajnjaVrsta)/2,  a,b,c);
            CetvrtinaMatrice& l2 = *new (allocate_child()) CetvrtinaMatrice(pocetnaKolona, (pocetnaKolona + krajnjaKolona)/2, (krajnjaVrsta + pocetnaVrsta)/2, krajnjaVrsta,a,b,c);
            CetvrtinaMatrice& l3 = *new (allocate_child()) CetvrtinaMatrice((pocetnaKolona + krajnjaKolona)/2, krajnjaKolona, pocetnaVrsta, (pocetnaVrsta + krajnjaVrsta)/2, a,b,c);
            CetvrtinaMatrice& l4 = *new (allocate_child()) CetvrtinaMatrice((pocetnaKolona + krajnjaKolona)/2, krajnjaKolona, (pocetnaVrsta + krajnjaVrsta)/2, krajnjaVrsta,a,b,c);
            set_ref_count(5);
            spawn(l1);
            spawn(l2);
            spawn(l3);
            spawn_and_wait_for_all(l4);
        }
        return NULL;
    }
};

    class ParalelnoMnozenje: public tbb::task //// celu veuki na 4 dela
{
public:
    int pocetnaKolona, krajnjaKolona, pocetnaVrsta, krajnjaVrsta;
    ParalelnoMnozenje( Matrix &a_, Matrix&b_, Matrix& c_) : a(a_), b(b_), c(c_) {}
    Matrix &a , &b ,&c;

    tbb::task* execute()
    {
        if (a.m * b.n < GRAINSIZE)
        {
            c.multiplyRegion ( pocetnaKolona, krajnjaKolona,  pocetnaVrsta,  krajnjaVrsta,   a, b);
        } else
        {
            CetvrtinaMatrice& l1 = *new (allocate_child()) CetvrtinaMatrice(0, a.m/2, 0,  b.n/2, a,b,c);
            CetvrtinaMatrice& l2 = *new (allocate_child()) CetvrtinaMatrice(0, a.m/2,  b.n/2, b.n,a,b,c);
            CetvrtinaMatrice& l3 = *new (allocate_child()) CetvrtinaMatrice(a.m/2, a.m, 0, b.n/2,  a,b,c);
            CetvrtinaMatrice& l4 = *new (allocate_child()) CetvrtinaMatrice(a.m/2, a.m,  b.n/2,  b.n,  a,b,c);
            set_ref_count(5);
            spawn(l1);
            spawn(l2);
            spawn(l3);
            spawn_and_wait_for_all(l4);
        }
        return NULL;







    }
};
    // poziva root task
    /**
     *desc:
     */
    void izracunajParalelno(Matrix &a, Matrix &b ,Matrix &c ){
        if ( a.n != b.m){

            cout <<"Neodgovarajuce mnozenje matrica"<<endl;

        }else{
            ParalelnoMnozenje& parMno = *new (tbb::task::allocate_root()) ParalelnoMnozenje(a,b,c);
            tbb::task::spawn_root_and_wait(parMno);


        }
    }

    void proveraIspravnosti(Matrix &cser,Matrix &cpar){

        for (int i = 0 ; i < cser.n; i++){

            for (int j =0 ; j< cser.m; j++){

                if (cser.podaci[i][j] != cpar.podaci[i][j]){
                    cout << "jkgjhki  " << endl;
                    system("pause");
                    exit(EXIT_FAILURE);
                }
            }

        }

        cout<<"matrice se podudaraju"<<endl;


    }

int main(){


    ///////////////////////////////////////////////
    ifstream myfile;
    string imePrvogFala;
    string imeDrugogFala;
    int nPrvog;
    int nDrugog;
    /*
    myfile.open("MatricaDim.txt");

    myfile >> imePrvogFala;
    myfile >> nPrvog;
    myfile >> imeDrugogFala;
    myfile >> nDrugog;

    myfile.close();
    */
    nPrvog = 4000;
    nDrugog = 4000;

    Matrix a(nPrvog, nPrvog);
    Matrix b(nDrugog, nDrugog);
    Matrix cser(nDrugog, nDrugog);
    Matrix cpar(nDrugog,nDrugog);

/*

    ifstream prviFajl(imePrvogFala);
    for(int i  = 0; i < nPrvog; i++){
        for(int j = 0; j < nPrvog; j++){
            prviFajl >> a.podaci[i][j];
        }
    }

    prviFajl.close();

    ifstream drugiFajl(imeDrugogFala);
    for(int i  = 0; i < nDrugog; i++){
        for(int j = 0; j < nDrugog; j++){
            drugiFajl >> b.podaci[i][j];
        }
    }

    drugiFajl.close();

    */

    //izracunajParalelno(a,b,c);
    tbb::tick_count t0 = tbb::tick_count::now();
    cser.multiplyRegion(0,a.m, 0, b.m, a,b);
    tbb::tick_count t1 = tbb::tick_count::now();
    double serTime = (t1 - t0).seconds();
    cout << "C serijski: " << "potrebno vreme: " << serTime* 1000 << " ms " << endl << "=========================================" << endl;
    t0 = tbb::tick_count::now();
    izracunajParalelno(a,b,cpar);
    t1 = tbb::tick_count::now();
    double parTime = (t1 - t0).seconds();
    cout << "C paralelno: " << "potrebno vreme: " << (t1-t0).seconds()*1000 << " ms" << endl << "=========================================" << endl;

    cout << "S : " << '\t' << serTime*1000 << '\t' << "P : " << '\t' << parTime* 1000 << endl;
    proveraIspravnosti( cser, cpar);


    ofstream cSerijsko("Serijski_ti_izadjem.txt");
    for(int i  = 0; i < nDrugog; i++){
        for(int j = 0; j < nDrugog; j++){
            cSerijsko << cser.podaci[i][j] << " ";
        }
        cSerijsko << endl;
    }

    cSerijsko.close();

    ofstream cParalelno("Paralelno_ti_izadjem.txt");
    for(int i  = 0; i < nDrugog; i++){
        for(int j = 0; j < nDrugog; j++){
            cParalelno << cpar.podaci[i][j] << " ";
        }
        cParalelno << endl;
    }
    cParalelno.close();

    system("pause");
}