#include "Normalization.hpp"
#include<limits>
#include<iostream>
#include "KNNRow.hpp"

using namespace std;

void Normalization::normalize(int argc, char *argv[]) {
	int num_of_features = NUM_OF_FEATURES;
	int i, j, numprocs, myid;
	int  islave;

	MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
	MPI_Comm_rank(MPI_COMM_WORLD, &myid);
	MPI_Status status;


	findMinMax(argc, argv);
	vector<double> vector;

	double begin = MPI_Wtime();

	if (myid == 0) {
			for (islave = 1; islave < numprocs; islave++) {
				MPI_Send(&inDataSize, 1, MPI_INTEGER, islave, MTAG1, MPI_COMM_WORLD);
			}
		} else {
			MPI_Recv(&inDataSize, 1, MPI_INTEGER, 0, MTAG1, MPI_COMM_WORLD, &status);
		}


	for (i = myid; i < inDataSize; i+=numprocs) {
		for (j = 0; j < num_of_features; j++) {
			vector.push_back((inData[i].features[j] - min[j])
					/ (max[j] - min[j]));
		}
	}

	double end = MPI_Wtime();
	normalizationTime = end - begin;
	normalizedData = inData;
}

void Normalization::findMinMax(int argc, char *argv[]) {
	int i, j;
	int num_of_features = NUM_OF_FEATURES;
	MPI_Status status;

	for( i=0;i<num_of_features;i++){
		min[i]= numeric_limits<int>::max();
	}

	int myid, numprocs, islave;
	int world_rank;
	MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
	MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
	double begin = MPI_Wtime();

	for ( i = world_rank; i < inDataSize; i+=numprocs) {
		for (j = 0; j < num_of_features; j++) {
			//printf("PRoces %d przetwarza dane inData[%d][%d] ktore jest rowne : %f\n", world_rank
			//		, i, j, inData[i].features[j]);
			if (min[j] > inData[i].features[j]) {
				min[j] = inData[i].features[j];
			}

			if (max[j] < inData[i].features[j]) {
				max[j] = inData[i].features[j];
			}
		}
	}



	double global_min[NUM_OF_FEATURES];
	double global_max[NUM_OF_FEATURES];
	for(int i = 0 ; i < NUM_OF_FEATURES; i++)
	{
		MPI_Reduce(&min[i], &global_min[i], 1, MPI_DOUBLE, MPI_MIN, 0,
			             MPI_COMM_WORLD);
		MPI_Reduce(&max[i], &global_max[i], 1, MPI_DOUBLE, MPI_MAX, 0,
					             MPI_COMM_WORLD);



		printf("Local min for process %d - %f \n",
				 world_rank, min[i]);

		printf("Local max for process %d - %f \n",
				 world_rank, max[i]);

		if (world_rank == 0) {
					printf("Total min = %f, max = %f\n\n", global_min[i],
						   global_max[i] );
				 }
		MPI_Barrier(MPI_COMM_WORLD);
	}
	double end = MPI_Wtime();
	minMaxTime = end - begin;
	if (world_rank == 0) {
		cout << numprocs;
	}
}

double Normalization::getNormalizationTime() {
	return normalizationTime;
}

double Normalization::getMinMaxTime(){
	return minMaxTime;
}

vector<Row> Normalization::getNormalizedData(){
	return normalizedData;

}