#include <algorithm>
#include <intrin.h>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <ctime>
#include <cstring>
#include <omp.h>
#include <xmmintrin.h>
#include <immintrin.h>
#include "lodepng.cpp"
#include "lodepng.h"


using namespace std;


//@@@@@@@@@@@@@@@@@@@@      Consistent Filter     @@@@@@@@@@@@@@@@@@@@

unsigned char getMedian(std::vector<unsigned char>& values) {
    std::sort(values.begin(), values.end());
    return values[values.size() / 2];
}

void applyMedianFilter(std::vector<unsigned char>& image, int width, int height, int channels, int filterSize) {
    std::vector<unsigned char> result(image.size());

    int radius = filterSize / 2;

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            for (int c = 0; c < channels; c++) {
                std::vector<unsigned char> values;

                for (int i = -radius; i <= radius; i++) {
                    for (int j = -radius; j <= radius; j++) {
                        int px = std::min(std::max(x + j, 0), width - 1);
                        int py = std::min(std::max(y + i, 0), height - 1);

                        values.push_back(image[(py * width + px) * channels + c]);
                    }
                }

                result[(y * width + x) * channels + c] = getMedian(values);
            }
        }
    }

    image = result;
}

void medianFilter(const char* inputFilename, const char* outputFilename, int filterSize) {
    std::vector<unsigned char> image;
    unsigned width, height;

    // Загружаем изображение
    unsigned error = lodepng::decode(image, width, height, inputFilename);

    if (error) {
        std::cerr << "Error decoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }

    // Применяем медианный фильтр
    applyMedianFilter(image, width, height, 4, filterSize);

    // Сохраняем изображение
    error = lodepng::encode(outputFilename, image, width, height);

    if (error) {
        std::cerr << "Error encoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }
}



//@@@@@@@@@@@@@@@@@@@@      OpenMP Filter     @@@@@@@@@@@@@@@@@@@@

unsigned char getMedianOMP(std::vector<unsigned char>& values) {
    std::sort(values.begin(), values.end());
    return values[values.size() / 2];
}

void applyMedianFilterOMP(std::vector<unsigned char>& image, int width, int height, int channels, int filterSize) {
    std::vector<unsigned char> result(image.size());

    int radius = filterSize / 2;
#pragma omp parallel for collapse(5)
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            for (int c = 0; c < channels; c++) {
                std::vector<unsigned char> values;

                for (int i = -radius; i <= radius; i++) {
                    for (int j = -radius; j <= radius; j++) {
                        int px = std::min(std::max(x + j, 0), width - 1);
                        int py = std::min(std::max(y + i, 0), height - 1);

                        values.push_back(image[(py * width + px) * channels + c]);
                    }
                }

                result[(y * width + x) * channels + c] = getMedianOMP(values);
            }
        }
    }

    image = result;
}

void medianFilterOMP(const char* inputFilename, const char* outputFilename, int filterSize) {
    std::vector<unsigned char> image;
    unsigned width, height;

    // Загружаем изображение
    unsigned error = lodepng::decode(image, width, height, inputFilename);

    if (error) {
        std::cerr << "Error decoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }

    // Применяем медианный фильтр
    applyMedianFilterOMP(image, width, height, 4, filterSize);

    // Сохраняем изображение
    error = lodepng::encode(outputFilename, image, width, height);

    if (error) {
        std::cerr << "Error encoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }
}


//@@@@@@@@@@@@@@@@@@@@      Vectorisation Filter     @@@@@@@@@@@@@@@@@@@@


unsigned char getVectorisationMedian(std::vector<unsigned char>& values) {
    std::sort(values.begin(), values.end());
    return values[values.size() / 2];
}

void applyVectorisationMedianFilter(std::vector<unsigned char>& image, int width, int height, int channels, int filterSize) {
    std::vector<unsigned char> result(image.size());

    int radius = filterSize / 2;
    const int vecSize = 16; // vector size in bytes

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            for (int c = 0; c < channels; c++) {
                std::vector<unsigned char> values;

                // load input values into a vector register
                __m128i inputVec = _mm_setzero_si128();

                for (int i = -radius; i <= radius; i++) {
                    for (int j = -radius; j <= radius; j += vecSize) {
                        int px = std::min(std::max(x + j, 0), width - 1);
                        int py = std::min(std::max(y + i, 0), height - 1);

                        // load vector of input values
                        __m128i curVec = _mm_loadu_si128((__m128i*) & image[(py * width + px) * channels + c]);

                        // merge vectors into a single vector
                        inputVec = _mm_or_si128(inputVec, curVec);
                    }
                }

                // extract values from the vector register
                unsigned char inputArr[vecSize];
                _mm_storeu_si128((__m128i*)inputArr, inputVec);

                // add values to the vector of values
                for (int i = 0; i < vecSize; i++) {
                    values.push_back(inputArr[i]);
                }

                // calculate median and store in result
                result[(y * width + x) * channels + c] = getMedian(values);
            }
        }
    }

    image = result;
}

void medianVectorisationFilter(const char* inputFilename, const char* outputFilename, int filterSize) {
    std::vector<unsigned char> image;
    unsigned width, height;

    // Загружаем изображение
    unsigned error = lodepng::decode(image, width, height, inputFilename);

    if (error) {
        std::cerr << "Error decoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }

    // Применяем медианный фильтр
    applyVectorisationMedianFilter(image, width, height, 4, filterSize);

    // Сохраняем изображение
    error = lodepng::encode(outputFilename, image, width, height);

    if (error) {
        std::cerr << "Error encoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }
}


//@@@@@@@@@@@@@@@@@@@@      OpenMP Vectorisation Filter     @@@@@@@@@@@@@@@@@@@@


unsigned char getMedianOMPVectorisation(std::vector<unsigned char>& values) {
    // Use SIMD to sort the pixel values
    __m128i xmm_data;
    unsigned char* data_ptr = values.data();
    int size = values.size();
    for (int i = 0; i < size; i += 16) {
        xmm_data = _mm_load_si128((__m128i*)(data_ptr + i));
        _mm_store_si128((__m128i*)(data_ptr + i), _mm_shuffle_epi8(xmm_data, _mm_set_epi8(
            15, 14, 13, 12, 11, 10, 9, 8,
            7, 6, 5, 4, 3, 2, 1, 0)));
    }
    std::sort(values.begin(), values.end());
    return values[values.size() / 2];
}

void applyMedianFilterOMPVectorisation(std::vector<unsigned char>& image, int width, int height, int channels, int filterSize) {
    std::vector<unsigned char> result(image.size());

    int radius = filterSize / 2;

#pragma omp parallel for collapse(5)
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            for (int c = 0; c < channels; c++) {
                std::vector<unsigned char> values;

                for (int i = -radius; i <= radius; i++) {
                    for (int j = -radius; j <= radius; j++) {
                        int px = std::min(std::max(x + j, 0), width - 1);
                        int py = std::min(std::max(y + i, 0), height - 1);

                        values.push_back(image[(py * width + px) * channels + c]);
                    }
                }

                result[(y * width + x) * channels + c] = getMedianOMPVectorisation(values);
            }
        }
    }

    image = result;
}

void medianFilterOMPVectorisation(const char* inputFilename, const char* outputFilename, int filterSize) {
    std::vector<unsigned char> image;
    unsigned width, height;

    // Загружаем изображение
    unsigned error = lodepng::decode(image, width, height, inputFilename);

    if (error) {
        std::cerr << "Error decoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }

    // Применяем медианный фильтр
    applyMedianFilterOMPVectorisation(image, width, height, 4, filterSize);

    // Сохраняем изображение
    error = lodepng::encode(outputFilename, image, width, height);

    if (error) {
        std::cerr << "Error encoding image: " << lodepng_error_text(error) << std::endl;
        return;
    }
}


//# # # # # # # # # # #      Consistent Call     # # # # # # # # # # #
void userConsistentMedianFilter() {
    clock_t start = clock();
    medianFilter("input.png", "outputMedian.png", 10);
    clock_t end = clock();
    double elapsed_time = double(end - start) / CLOCKS_PER_SEC;
    std::cout << "Время выполнения функции медианного фильтра: " << elapsed_time << " секунд." << std::endl;
}
void userConsistentFilters() {
    userConsistentMedianFilter();

}

//# # # # # # # # # # #      OpenMP Call     # # # # # # # # # # #
void userOMPMedianFilter() {
    clock_t start = clock();
    medianFilterOMP("input.png", "outputMedianOMP.png", 10);
    clock_t end = clock();
    double elapsed_time = double(end - start) / CLOCKS_PER_SEC;
    std::cout << "Время выполнения функции медианного фильтра: " << elapsed_time << " секунд." << std::endl;
}
void userOPMFilters() {
    userOMPMedianFilter();

}

//# # # # # # # # # # #      Vectorization Call     # # # # # # # # # # #
void userVectorizationMedianFilter() {
    clock_t start = clock();
    medianVectorisationFilter("input.png", "outputMedianVec.png", 10);
    clock_t end = clock();
    double elapsed_time = double(end - start) / CLOCKS_PER_SEC;
    std::cout << "Время выполнения функции медианного фильтра: " << elapsed_time << " секунд." << std::endl;
}
void userVectorizationFilters() {
    userVectorizationMedianFilter();

}

//# # # # # # # # # # #      OpenMP Vectorization Call     # # # # # # # # # # #
void userOMPVectorizationMedianFilter() {
    clock_t start = clock();
    medianFilterOMPVectorisation("input.png", "outputMedianOpenMPVec.png", 10);
    clock_t end = clock();
    double elapsed_time = double(end - start) / CLOCKS_PER_SEC;
    std::cout << "Время выполнения функции медианного фильтра: " << elapsed_time << " секунд." << std::endl;
}
void userOMPVectorizationFilters() {
    userOMPVectorizationMedianFilter();

}


int main() {
    setlocale(LC_ALL, "Russian");
    std::cout << "Последовательный метод:\n";
    userConsistentFilters();
    std::cout << "\n\n";

    std::cout << "OpenMP:\n";
    userOPMFilters();
    std::cout << "\n\n";

    std::cout << "Vectorization:\n";
    userVectorizationFilters();
    std::cout << "\n\n";
    std::cout << "OpenMP Vectorization:\n";
    userOMPVectorizationFilters();
    std::cout << "\n";
    return 0;
}