#include "mpi.h"
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include "EasyBMP.h"
#include <windows.h>
#include <math.h>

//#define INPUT_IMAGE  "Vit.bmp"
#define INPUT_IMAGE  "Velka_fotka2.bmp"
#define MEASURES_COUNT 100
#define THREADS 2

using namespace std;

void flipBMP(BMP& bmp, int actualProcess, int maxProcesses, int threads);
void flip_column(BMP& bmp, int column,int height);

/******************************************************************************/
/**
 * MAIN
 */
int main(int argc, char** argv)
{
      int o;
      double sum;

      //Count overhead
      LARGE_INTEGER start, stop, frequency;
      long overhead;
      QueryPerformanceFrequency(&frequency);
      QueryPerformanceCounter(&start);
      QueryPerformanceCounter(&stop);
      overhead = stop.QuadPart-start.QuadPart;

      /* LOAD IMAGE */
      cout << "\r\n"
           << " Cteni zdrojoveho souboru...\r\n";

      BMP image;
      image.ReadFromFile(INPUT_IMAGE);

      cout << "Probiha mereni: \r\n" ;

      /* INIT MPI */
      int numprocs, rank, namelen;
      char processor_name[MPI_MAX_PROCESSOR_NAME];

      MPI_Init(&argc, &argv);
      MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
      MPI_Comm_rank(MPI_COMM_WORLD, &rank);
      MPI_Get_processor_name(processor_name, &namelen);

      /* THREADS */
      omp_set_num_threads (THREADS);
      cout << "Pocet vlaken: " << THREADS << " \r\n" ;

      /* MPI PART */
      /*   --  MEASUREMENT */      

      //Retry the same measurement on instance
      sum = 0;
      for( o = 1; o<=MEASURES_COUNT; o++ )
      {
              //Time diff
              QueryPerformanceCounter(&start);
              flipBMP(image, rank, numprocs, THREADS); //flip image
              QueryPerformanceCounter(&stop);

              sum+=1000*(stop.QuadPart - start.QuadPart - overhead)/(double)frequency.QuadPart;
      }

      /*   --  RESULTS */
      cout << "Process "<<rank<<": " << sum/MEASURES_COUNT << "\r\n";

      /*   --  MPI CLOSE */
      MPI_Finalize();

      /* SAVE IMAGE */
      cout << " Zapis prevraceneho obrazku do souboru . . .";
      image.WriteToFile(INPUT_IMAGE);
      cout << " dokonceno." << endl;

      return 0;
}

/******************************************************************************/
/**
 * Flip column
 * @param {BMP& } bmp - reference of loaded image
 * @param {int} column which columnt will be flipped
 * @param {int} height number of pixels in columnt
 */
void flip_column(BMP& bmp, int column,int height)
{
   RGBApixel pix1;
   RGBApixel pix2;

   int x = height>>1; //height / 2

   for(int i =0;i<x;i++)
   {
      pix1= bmp.GetPixel(column,i);
      pix2= bmp.GetPixel(column,height-i-1);

      bmp.SetPixel(column,i,pix2);
      bmp.SetPixel(column,height-i-1,pix1);
   }
}

/******************************************************************************/
/**
 * Flip BMP
 * @param {BMP& } bmp - reference of loaded image
 * @param {int} actualProcess which columnt will be flipped
 * @param {int} maxProcesses number of pixels in columnt
 * @param {int} threads
 */
void flipBMP(BMP& bmp, int actualProcess, int maxProcesses, int threads)
{
      int iam =0 , np = 1;  

      //maximum of parallel parts
      int max = maxProcesses * threads;

      //image size
      int width = bmp.TellWidth();
      int height = bmp.TellHeight();
      
      //step - number of columns for each thread
      int step = (int) ceil(width/max);

      //#pragma omp parallel private(iam, np) num_threads(thread_count)
      #pragma omp parallel private(iam, np)
      {
            np = omp_get_num_threads();
            iam = omp_get_thread_num();

            //interval of columns to be flipped by this thread
            int offset = actualProcess * threads * step;
            int from = offset + step * iam;
            int to = offset + step*(iam+1)-1;

            //check out-of-bounds of image
            if( to>=width || (np-1)==iam )to = width-1;

            //flip columns
            for(int i=from; i<=to; i++)
            {
                flip_column(bmp,i,height);
            }
      }
}