#include <stdio.h>
#include <stdlib.h>
#include <cuda_runtime.h>
#include <curand.h>
#include <curand_kernel.h>

#define K 6
#define THREADS_PER_BLOCK 256

int* allocateArray(int n)
{
    return (int*)malloc(n * sizeof(int));
}

void setValues(int *array, int n, int max)
{
    int i;
    for (i = 0; i < n; i++)
    {
        array[i] = rand() % max + 1;
    }
}

__global__ void sum(int *x, int *y, int p, int *newX, int *newY, int *outX, int *outY, int n)
{
    int index = threadIdx.x + blockIdx.x * blockDim.x;
    if (index < n)
    {
        newX[index] += (newX[index] * p);
        newY[index] += (newY[index] * 100);
        outX[index] = x[index] * newY[index] + y[index] * newX[index];
        outY[index] = y[index] * newY[index];
        int gcd = 1;
        for(int i = 1; i <= outX[index] && i <= outY[index]; ++i)
        {
            if (outX[index] % i == 0 && outY[index] % i == 0)
            gcd = i;
        }
        outX[index] = outX[index] / gcd;
        outY[index] = outY[index] / gcd;

    }
}

double calculateIncome(int *x, int *y, int *resX, int *resY, int n)
{
    int i;
    double sum = 0;
    for (i = 0; i < n; i++)
    {
        sum += ((y[i] * resX[i] * 1.0) - (x[i] * resY[i])) / (y[i] * resY[i]);
    }
    return sum;
}

void printArraySum(int *a, int *b, int *c, int *x, int *y, int *z, int n)
{
    for (int i = 0; i < n; i++)
    {
        printf("%d/%d + %d/%d = %d/%d\n", a[i], x[i], b[i], y[i], c[i], z[i]);
    }
}

int main(int argc, char **argv)
{
    // razlomak
    int *x, *y, p;

    x = allocateArray(K);
    setValues(x, K, 10);

    y = allocateArray(K);
    setValues(y, K, 10);

    p = 2;

    // novo sredstvo
    int *newX = allocateArray(K);
    setValues(newX, K, 10);
    int *newY = allocateArray(K);
    setValues(newY, K, 10);

    // output
    int *resX, *resY;
    resX = allocateArray(K);
    resY = allocateArray(K);

    int *outX, *outY;
    outX = allocateArray(K);
    outY = allocateArray(K);

    // Cuda mem prepare
    int size = K * sizeof(int);
    cudaMalloc((void **)&outX, size);
    cudaMalloc((void **)&outY, size);

    // FALI
    int *d_x, *d_y, *d_newX, *d_newY;
    cudaMalloc((void **)&d_x, size);
    cudaMalloc((void **)&d_y, size);
    cudaMalloc((void **)&d_newX, size);
    cudaMalloc((void **)&d_newY, size);

    cudaMemcpy(d_x, x, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_y, y, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_newX, newX, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_newY, newY, size, cudaMemcpyHostToDevice);

    sum<<<(K + THREADS_PER_BLOCK) / THREADS_PER_BLOCK,THREADS_PER_BLOCK>>>(d_x, d_y, p, d_newX, d_newY, outX, outY, K);

    cudaMemcpy(resX, outX, size, cudaMemcpyDeviceToHost);
    cudaMemcpy(resY, outY, size, cudaMemcpyDeviceToHost);

    printArraySum(x, newX, resX, y, newY, resY, K);

    printf("\n\n%lf", calculateIncome(x, y, resX, resY, K));

    return 0;
}