#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>


/*
Kiekvienos programos failo pradþioje paraðykite atsakymus á tokius klausimus:
1. Kokia tvarka startuoja procesai? Galimi atsakymo variantai:                                  atsitiktine.
2. Kokia tvarka vykdomi procesai? Galimi atsakymo variantai:                                    atsitiktine.
3. Kiek iteracijø ið eilës padaro vienas procesas? Galimi atsakymo variantai:                   visas.
4. Kokia tvarka atspausdinami to paties masyvo duomenys? Galimi atsakymo variantai:             tokia, kokia suraðyti.
*/

//Sukuriam skaitiklá skaitymo veiksmams
int count = 0;
//Failo vardas
const char fileName[] = "AmosejevasH.txt";

//Struktûra laikanti duomenis apie studentà
struct Item {
    char ItemName[50];
    int  ItemCount;
    double ItemPrice;
};

//Struktûra skirta tiekëjui apraðyti
struct Producer {
    int ProducerNr;
    int HowManyItems;
    struct Item Items[50];
    int totalNrOfItems;
};



//Uþduotyje naudojamas kiekis fakultetø
struct Producer Producers[5];
struct Item resultArray[5];
//Funkcija, naudojamas nuskaityti ir priskirti duomenis fakultetams/studentams
void readData() {
    int i, j;
    FILE *fp;
    int howManyItems;

    // 1 - keletà //2 - nieko  // 3-visus
    fp = fopen("AmosejevasH.txt", "r");
    for (i = 0; i < 5; i++)
    {
        fscanf(fp, "%d", &howManyItems);
        for (j = 0; j < howManyItems; j++)
        {
            fscanf(fp, "%s", Producers[i].Items[j].ItemName);
            fscanf(fp, "%d", &Producers[i].Items[j].ItemCount);
            fscanf(fp, "%lf", &Producers[i].Items[j].ItemPrice);
            Producers[i].HowManyItems++;
            Producers[i].totalNrOfItems += Producers[i].Items[j].ItemCount;
        }
    }
}


//Funkcija, kuri atspausdina visà turimà informacijà
void printNicely(){

        int j = 0;
        printf("%-2s  %-10s %5s %s \n", "Nr.", "Vardas", "Kursas", "Vidurkis");
        for ( j = 0; j< 5; j++){
            printf("%-2d)  %-8s %5d %9.2f \n", j+1, resultArray[j].ItemName , resultArray[j].ItemCount, resultArray[j].ItemPrice);
        }
}
__device__ void print_parallel(){

    printf("Procesas_%d\n", threadIdx.x);

}

//funkcija kuri tarpininkauja su CPU dalimi, ir paleidþia spausdinimo funkcijà vaizdo plokðtëje
__global__ void executeOnGPUThread(struct Producer *f1, struct Producer *f2, struct Producer *f3, struct Producer *f4, struct Producer *f5, struct Item *it){
            //Graþina gijos numerá threadIdx.x
    int i = threadIdx.x;
    it[i].ItemCount += f1->Items[i].ItemCount + f2->Items[i].ItemCount + f3->Items[i].ItemCount + f4->Items[i].ItemCount + f4->Items[i].ItemCount;
    it[i].ItemPrice += f1->Items[i].ItemPrice + f2->Items[i].ItemPrice + f3->Items[i].ItemPrice + f4->Items[i].ItemPrice + f4->Items[i].ItemPrice;
}



void main(){
    //Nuskaitome Informacijà
    readData();
    //Graþiai atspausdiname viskà
    printNicely();
    //Iðskiriame rodykles á masyvo elementus
    struct Producer *dev_f1, *dev_f2, *dev_f3, *dev_f4, *dev_f5;
    struct Item *dev_item;
    //Randame vieno fakulteto max dydá
    int size = sizeof(struct Producer);
    int itemSize = sizeof(struct Item);
    //Iðskiriame tam tikrà atmnties kieká GPU.
    cudaMalloc((void**)&dev_f1, size);
    cudaMalloc((void**)&dev_f2, size);
    cudaMalloc((void**)&dev_f3, size);
    cudaMalloc((void**)&dev_f4, size);
    cudaMalloc((void**)&dev_f5, size);
    cudaMalloc((void**)&dev_item, itemSize *5);
    //Kopijuojame fakultetus á GPU atmintá
    cudaMemcpy(dev_f1, &Producers[0], size, cudaMemcpyHostToDevice);
    cudaMemcpy(dev_f2, &Producers[1], size, cudaMemcpyHostToDevice);
    cudaMemcpy(dev_f3, &Producers[2], size, cudaMemcpyHostToDevice);
    cudaMemcpy(dev_f4, &Producers[3], size, cudaMemcpyHostToDevice);
    cudaMemcpy(dev_f5, &Producers[4], size, cudaMemcpyHostToDevice);
    cudaMemcpy(dev_item, resultArray, itemSize*5, cudaMemcpyHostToDevice);
    //Paleidþiame funkcijà
    executeOnGPUThread<<<1,5>>>( dev_f1, dev_f2, dev_f3, dev_f4, dev_f5, dev_item);

    //Palaukiame, kol GPU dalis baigs darbà
    cudaDeviceSynchronize();
    cudaMemcpy(resultArray, dev_item, itemSize*5, cudaMemcpyHostToDevice);
    printNicely();
    //Atlaisviname GPU atmintá
    cudaFree(dev_f1);
    cudaFree(dev_f2);
    cudaFree(dev_f3);
    cudaFree(dev_f4);
    cudaFree(dev_f5);
    cudaFree(dev_item);


    printf("Programs finished it's work\n");
    system("pause");
}