#include <stdio.h>
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdint.h>
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

#define MASTER 0

int min = -2, max = 3;

typedef struct {
    int blue;
    int green;
    int czerw;
}Pixel;

int main(int argc, char** argv) {
    /***** NASZ KOD*****/
    int numtasks, taskid;
    int source;
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    MPI_Status status;
    printf("MPI task %d has started...  ", taskid);

    int width, height, channels;
    unsigned char* img = stbi_load("aa.jpg", &width, &height, &channels, 0);

    int blur_channels = channels == 4 ? 2 : 1;
    int licznik = 0;
    size_t img_size = width * channels * height;

    int h = height / 3;

    Pixel* piksele = malloc(sizeof(Pixel) * width * height);

    //Pixel* tab1 = malloc(sizeof(Pixel) * width * h);
    //Pixel* tab2 = malloc(sizeof(Pixel) * width * h);
    //Pixel* tab3 = malloc(sizeof(Pixel) * width * h);

    int rozmiar = h * width;

    if (taskid == MASTER) {

        for (uint8_t* p = img; p != img + img_size; p += channels) {
            piksele[licznik].czerw = (uint8_t)(*p);
            piksele[licznik].green = (uint8_t)(*(p + 1));
            piksele[licznik].blue = (uint8_t)(*(p + 2));
            licznik++;
        }
        int tmp = 0;
        //for (int i = 0; i < h; i++) {
        //    for (int j = 0; j < width; j++) {
        //        tab1[i * width + j] = piksele[i * width + j];
        //        tab2[i * width + j] = piksele[(i + h) * width + j];
        //        tab3[i * width + j] = piksele[(i + 2 * h) * width + j];

        //        tmp++;
        //    }
        //}

        //MPI_Send(&rozmiar, 1, MPI_INT, 1, 0, MPI_COMM_WORLD);
        //MPI_Send(&piksele[rozmiar], h, MPI_CHAR, 1, 0, MPI_COMM_WORLD);

        for (int i = 1; i < 4; i++) {
            MPI_Send(&rozmiar, 1, MPI_INT, i, 1, MPI_COMM_WORLD);
            MPI_Send(&piksele[rozmiar], h*width, MPI_INT, i, 1, MPI_COMM_WORLD);
            rozmiar = rozmiar + h;
        }


        for (int i = 1; i < 4; i++) {
            source = i;
            MPI_Recv(&rozmiar, 1, MPI_INT, source, 1, MPI_COMM_WORLD, &status);
            MPI_Recv(&piksele[rozmiar], h*width, MPI_INT, source, 1, MPI_COMM_WORLD, &status);
        }
    }

    if (taskid > MASTER) {
        MPI_Recv(&rozmiar, 1, MPI_INT, MASTER, 0, MPI_COMM_WORLD, &status);
        MPI_Recv(&piksele[rozmiar], h, MPI_CHAR, MASTER, 0, MPI_COMM_WORLD, &status);
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < width; j++) {
                piksele[i * width + j].blue = 100;
                piksele[i * width + j].green = 150;
                piksele[i * width + j].czerw = 200;
            }
        }
        MPI_Send(&rozmiar, 1, MPI_INT, MASTER, 0, MPI_COMM_WORLD);
        MPI_Send(&piksele[rozmiar], h, MPI_CHAR, MASTER, 0, MPI_COMM_WORLD);
    }

    MPI_Finalize();
    ///////////////////////////////////////////////////////////
    /////////////////////
    /*
    int width, height, channels;
    unsigned char *img = stbi_load("potezny.jpg", &width, &height, &channels, 0);
    if (img == NULL) {
        printf("Error in loading the image\n");
        exit(1);
    }
    printf("Loaded image with a width of %dpx, a height of %dpx and %d channels\n", width, height, channels);

    int blur_channels = channels == 4 ? 2 : 1;
    int licznik = 0;
    size_t img_size = width * channels * height;

    Pixel* piksele = malloc(sizeof(Pixel) * width * height);
    Pixel* blur = malloc(sizeof(Pixel) * width * height);

    //Ta pentla daje kolorki do tablicy piksele gdzie wygodnie da sie ich uzywac

    for (unsigned char* p = img; p != img + img_size; p += channels) {
        piksele[licznik].czerw = (uint8_t)(*p);
        piksele[licznik].green = (uint8_t)(*(p + 1));
        piksele[licznik].blue = (uint8_t)(*(p + 2));
        licznik++;
    }
    int rank, n_ranks;

    int srednia_czerw = 0, srednia_g = 0, srednia_b = 0;
    int ile_r = 0;
    int ile_g = 0;
    int ile_b = 0;

    // First call MPI_Init

    MPI_Init(&argc, &argv);
    // Check that there are two ranks
    MPI_Comm_size(MPI_COMM_WORLD, &n_ranks);
    if (n_ranks != 3) {
        printf("This example requires exactly three ranks\n");
        MPI_Finalize();
        return(1);
    }



    // Get my rank
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    double start = MPI_Wtime();

    if (rank == 0) {
        for (int y = 0; y < height; y++){
            for (int x = 0; x < width; x++){
                for (int i = min; i < max; i++){ // przesuwanie w poziomie
                    for (int j = min; j < max; j++){ // przesuwanie w pionie
                        if ((y + i < height && y + i >= 0) && (x + j < width && x + j >= 0)){
                            srednia_czerw += piksele[(y + i) * width + x + j].czerw;
                            ile_r++;
                        }
                    }
                }
                blur[y * width + x].czerw = srednia_czerw / ile_r;
                ile_r = 0;
                srednia_czerw = 0;
            }
        }
        //MPI_Send(blur->czerw, 16, MPI_CHAR, 3, 0, MPI_COMM_WORLD);
    }

    if (rank == 1) {
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {

                for (int i = min; i < max; i++) { // dla y
                    for (int j = min; j < max; j++) { // dla x
                        if ((y + i < height && y + i >= 0) && (x + j < width && x + j >= 0)) {
                            srednia_g += piksele[(y + i) * width + x + j].green;
                            ile_g++;
                        }
                    }
                }
                blur[y * width + x].green = srednia_g / ile_g;
                ile_g = 0;
                srednia_g = 0;
            }
        }
        MPI_Send(blur->green, 16, MPI_CHAR, 3, 0, MPI_COMM_WORLD);
    }

    if (rank == 2) {
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {

                for (int i = min; i < max; i++) { // dla y
                    for (int j = min; j < max; j++) { // dla x
                        if ((y + i < height && y + i >= 0) && (x + j < width && x + j >= 0)) {
                            srednia_b += piksele[(y + i) * width + x + j].blue;
                            ile_b++;
                        }
                    }
                }
                blur[y * width + x].blue = srednia_b / ile_b;
                ile_b = 0;
                srednia_b = 0;
            }
        }
    }



    double end = MPI_Wtime();
    MPI_Finalize();

    double czas = end-start;
    printf("Blur Zrobiony!\n");
    printf("Zadanie trwalo: %f [s]\n\n", czas);

    unsigned char* wynik = malloc(width * height * 3);

    int index = 0;

    for (int j = 0; j < height; j++)
    {
        for (int i = 0; i < width; i++)
        {
            wynik[index++] = (unsigned char)blur[j * width + i].czerw;
            wynik[index++] = (unsigned char)blur[j * width + i].green;
            wynik[index++] = (unsigned char)blur[j * width + i].blue;

        }
    }

    stbi_write_jpg("potezny_blur_oddzielnie2.jpg", width, height, 3, wynik, 100);
    stbi_image_free(img);
    free(piksele);
    free(wynik);
    free(blur);

    */

}