#include	<iostream>
#include	<fstream>
#include	<vector>
#include	<boost/mpi/communicator.hpp>
#include	<boost/mpi/collectives.hpp>
#include	"scatterv.hpp"
#include	"gatherv.hpp"

using std::vector;
using std::ifstream;
using std::cout;
using std::cin;
using std::endl;

void print( vector<int>* M, int m, int n ) {

	for ( int i = 0; i < m; ++ i ) {
		for ( int j = 0; j < n; ++j ) {
			cout << M[i][j] << " ";
		} cout << endl;
	}
} // ---------- end of function print ----------

int main ( int argc, char *argv[] )
{
	boost::mpi::environment env( argc, argv );
	boost::mpi::communicator world;

	const int nprocs = world.size();
	const int myRank = world.rank();
	const int root = 0;
	const int dim = 5;

	int ninputs;
	ifstream file;
	if ( myRank == root ) {
		
		file.open( "input.txt", ifstream::in );
		file >> ninputs;
		file.close();
	}
	boost::mpi::broadcast( world, ninputs, root );

	int remainder = ninputs % nprocs;
	vector<int> pieceFor( nprocs, ninputs/nprocs );
	for ( int rank = 0; rank < remainder; rank++ ) ++pieceFor[rank];

	int myPiece = pieceFor[myRank];

	vector<int> displs(nprocs);
	for ( int i = 0, aux = 0; i < nprocs; i++ ) {
		displs[i] = aux;
		aux += pieceFor[i];
	}

	//----------------------------------------------------------------------
	//  C-like data to be scattered
	//----------------------------------------------------------------------
	vector<int>* PTR = new vector<int>[ninputs];
	for ( int i = 0; i < ninputs; ++i ) PTR[i].resize(dim);

	for ( int i = 0; i < ninputs; ++i ) {
		for ( int j = 0; j < dim; ++j ) {
			PTR[i][j] = i+1;
		}
	}

	//----------------------------------------------------------------------
	//  C++-like data to be scattered
	//----------------------------------------------------------------------
	vector< vector<int> > V( ninputs, vector<int>(dim) );
	for ( int i = 0; i < ninputs; ++i ) {
		for ( int j = 0; j < dim; ++j ) {
			V[i][j] = i+1;
		}
	}

	//----------------------------------------------------------------------
	//  BOOST::MPI::SCATTERV
	//----------------------------------------------------------------------
	vector<int>* ptr = new vector<int>[myPiece];

	cout << "***** Scatterv - Prototype 1 *****" << endl;
	boost::mpi::scatterv( world, PTR, pieceFor, displs, ptr, myPiece, root );
	print( ptr, myPiece, dim );

//	cout << "***** Scatterv - Prototype 2 *****" << endl;
//	boost::mpi::scatterv( world, V, pieceFor, displs, ptr, myPiece, root );
//	print( ptr, myPiece, dim );

//	cout << "***** Scatterv - Prototype 3 *****" << endl;
//	if ( myRank == root )
//		boost::mpi::scatterv( world, PTR, pieceFor, displs, ptr, myPiece, root );
//	else
//		boost::mpi::scatterv( world, ptr, myPiece, root );
//	print( ptr, myPiece, dim );

//	cout << "***** Scatterv - Prototype 4 *****" << endl;
//	boost::mpi::scatterv( world, PTR, pieceFor, ptr, root );
//	print( ptr, myPiece, dim );

//	cout << "***** Scatterv - Prototype 5 *****" << endl;
//	boost::mpi::scatterv( world, V, pieceFor, ptr, root );
//	print( ptr, myPiece, dim );

	//----------------------------------------------------------------------
	//  C-like data to be gathered
	//----------------------------------------------------------------------
	// ptr will be gathered

	//----------------------------------------------------------------------
	//  C++-like data to be gathered
	//----------------------------------------------------------------------
	vector< vector<int> > v( myPiece );
	for ( int i = 0; i < myPiece; ++i ) v[i] = ptr[i];

	//----------------------------------------------------------------------
	//  BOOST::MPI::GATHERV
	//----------------------------------------------------------------------
	for ( int i = 0; i < ninputs; ++i ) {
		for ( int j = 0; j < dim; ++j ) {
			PTR[i][j] = 0;
		}
	}

	if ( myRank == root ) cout << "***** Gatherv - Prototype 1 *****" << endl;
	boost::mpi::gatherv( world, ptr, myPiece, PTR, pieceFor, displs, root );
	if ( myRank == root ) print( PTR, ninputs, dim );

//	if ( myRank == root ) cout << "***** Gatherv - Prototype 2 *****" << endl;
//	boost::mpi::gatherv( world, v, PTR, pieceFor, displs, root );
//	if ( myRank == root ) print( PTR, ninputs, dim );

//	if ( myRank == root ) cout << "***** Gatherv - Prototype 3 *****" << endl;
//	if ( myRank == root )
//		boost::mpi::gatherv( world, ptr, myPiece, PTR, pieceFor, displs, root );
//	else
//		boost::mpi::gatherv( world, ptr, myPiece, root );
//	if ( myRank == root ) print( PTR, ninputs, dim );

//	if ( myRank == root ) cout << "***** Gatherv - Prototype 4 *****" << endl;
//	if ( myRank == root )
//		boost::mpi::gatherv( world, v, PTR, pieceFor, displs, root );
//	else
//		boost::mpi::gatherv( world, v, root );
//	if ( myRank == root ) print( PTR, ninputs, dim );

//	if ( myRank == root ) cout << "***** Gatherv - Prototype 5 *****" << endl;
//	boost::mpi::gatherv( world, ptr, myPiece, PTR, root );
//	if ( myRank == root ) print( PTR, ninputs, dim );

//	if ( myRank == root ) cout << "***** Gatherv - Prototype 6 *****" << endl;
//	boost::mpi::gatherv( world, v, PTR, root );
//	if ( myRank == root ) print( PTR, ninputs, dim );

	// ---------------------------------------------------------------------

	delete[] PTR;
	delete[] ptr;
	V.clear();
	v.clear();

	cout << "----- PROCESS " << myRank << " -----" << endl;
	cout << myPiece << " of " << ninputs << endl;
	cin.get();
	return 0;
}  // ----------  end of function main  ----------