//Mantvydas Pleiris IFF-5/6 laboratorinis darbas 3A
#include <iostream>
#include <fstream>
#include <iomanip>
#include <mpi.h>
#include <vector>
#include <string.h>
using namespace std;

//Picu objekto struktūra
struct Picos {
	char pica[20]; //Picos pavadinimas
	int dydis; //Picos dydis
	double kaina; //Picos kaina
};
//Pirkimų objekto struktūra
struct Pirkimai {
	char pica[20]; //Picos pavadinimas
	int kiekis; //Picų kiekis
};
void Rasymas(Pirkimai *B, int dydis);
void Rasymas1(vector<vector<Picos> > &P); //Duomenų spausdinimo metodo P masyvui antraštė
void Rasymas2(vector<vector<Pirkimai> > &V); //Duomenų spausdinimo metodo V masyvui antraštė
void Skaitymas1(vector<vector<Picos> > &P); //Duomenų skaitymo metodo P masyvui antraštė
void Skaitymas2(vector<vector<Pirkimai> > &V); //Duomenų spausdinimo metodo V masyvui antraštė
void Picu_siuntimas(Picos *picos, int dydis, int rank);
Picos *Picu_gavimas(int &dydis, int rank);
void Pirkimu_siuntimas(Pirkimai *pirkimai, int dydis, int rank);
Pirkimai *Pirkimu_gavimas(int &dydis, int rank);
bool PridetiIBMasyva(Pirkimai *B, int &dydis, Picos pica);
bool Salinti(Pirkimai *B, int &dydis, Pirkimai pirkimas);
void Valdymas();
void Skaityti();
void DetiIB();
void SalintiIsB();

ifstream fileDuom("IFF5-6_PleirisM_L3_dat1.txt"); //Duomenu failas
//ifstream fileDuom("IFF5-6_PleirisM_L3_dat2.txt"); //Duomenu failas
//ifstream fileDuom("IFF5-6_PleirisM_L3_dat3.txt"); //Duomenu failas
ofstream fileRez("IFF5-6_PleirisM_L3_rez.txt"); //Rezultatu failas


	void Picu_siuntimas(Picos *picos, int dydis, int rank)
	{
		int byteSk = sizeof(Picos) * dydis;

		MPI::COMM_WORLD.Send(&byteSk, 1, MPI::INT, rank, 1);
		MPI::COMM_WORLD.Send(picos, byteSk, MPI::CHAR, rank, 2);
	}

	Picos *Picu_gavimas(int &dydis, int rank)
	{
	int byteSk;
	MPI_Recv(&byteSk, 1, MPI::INT, rank, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

	char *bytes = new char[byteSk];
	MPI::COMM_WORLD.Recv(bytes, byteSk, MPI::CHAR, rank, 2);

	Picos *picos = (Picos *)bytes;
	dydis = byteSk / sizeof(Picos);

	return picos;
	}
	void Pirkimu_siuntimas(Pirkimai *pirkimai, int dydis, int rank)
	{
		int byteSk = sizeof(Pirkimai) * dydis;

		MPI::COMM_WORLD.Send(&byteSk, 1, MPI::INT, rank, 1);
		MPI::COMM_WORLD.Send(pirkimai, byteSk, MPI::CHAR, rank, 2);
	}

	Pirkimai *Pirkimu_gavimas(int &dydis, int rank)
	{
	int byteSk;
	MPI_Recv(&byteSk, 1, MPI::INT, rank, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

	char *bytes = new char[byteSk];
	MPI::COMM_WORLD.Recv(bytes, byteSk, MPI::CHAR, rank, 2);

	Pirkimai *pirkimai = (Pirkimai *)bytes;
	dydis = byteSk / sizeof(Pirkimai);

	return pirkimai;
	}
	//Metodas, kuris deda P masyvo elementus į bendrą masyvą B
	bool PridetiIBMasyva(Pirkimai *B, int &dydis, Picos pica)
	{
		for (int b = 0; b < dydis; b++)
		{

				if (dydis == 0) //Jei masyvas tuščias
				{
					strcpy(B[b].pica,pica.pica);
					B[b].kiekis = 1;
					dydis++;
					return true;
				}
				else if (B[b].pica == pica.pica)
				{
					B[b].kiekis++;
					return true;
				}
				else if (B[b].pica > pica.pica) //Jei dedamas į galą
				{
					for (int i = dydis; i > b; i--)
					{
					B[i] = B[i - 1];
					}
					strcpy(B[b].pica,pica.pica);
					B[b].kiekis = 1;
					dydis++;
					return true;
				}
		}
		return true;
	}
	//Metodas skirtas šalinti elementus iš B masyvo, kurie sutampa su V masyvo elementais.
	bool Salinti(Pirkimai *B, int &dydis, Pirkimai pirkimas)
	{
			for (int i = 0; i < dydis; i++)
			{
				if (B[i].pica == pirkimas.pica)
				{
					if (pirkimas.kiekis >= B[i].kiekis)
					{
						for (int j = i; j < dydis - 1; j++)
						{
							B[j] = B[j + 1]; //Perstumiamas masyvas per vieną vietą nuo elemento iki galo.
						}
						dydis--; //Minusuojamas elementų kiekio skaitliukas
						strcpy (B[dydis].pica,0);
						B[dydis].kiekis = 0;
					}
					else //Jei picų kiekis didesnis nei pirkimo masyvo picų kiekis
						B[i].kiekis = B[i].kiekis - pirkimas.kiekis;
					return true;
				}
			}
			return false;
	}

void Valdymas()
{
	Pirkimai B[20];
	int dydis = 0;
	int baigtiP = 0;
	int baigtiV = 0;

	while (baigtiP + baigtiV < 18)
	{
		int a; //baitu skaicius
		MPI::Status status;
		MPI::COMM_WORLD.Send(&a, 1, MPI::INT, 1, 1);
		if(a == 0)
		{
			if(status.Get_source() < 10)
			baigtiP++;
			else
			baigtiV++;
		}
		else
		{
			char r[a];
			MPI::COMM_WORLD.Recv(r, a, MPI::CHAR, status.Get_source(), 2);
			if(a  = sizeof(Picos))
			{
				Picos pica = *(Picos *)r;
				PridetiIBMasyva(B, dydis, pica);
			}
			else
			{
				bool pavyko = Salinti(B, dydis, *(Pirkimai *)r);
				int reiksme;
				if (pavyko == true)
				{
					reiksme = 1;
				}
				else if(baigtiP < 9)
				{
					reiksme = 0;
				}
				else
				{
					reiksme = 0;
				}
				MPI::COMM_WORLD.Send(&reiksme, 1, MPI::INT, status.Get_source(), 4);
			}
		}
	}
	Pirkimu_siuntimas(B, dydis, 0);
}

int main()
{
	MPI::Init();
	cout << "Pradzia" << endl;
	int rank = MPI::COMM_WORLD.Get_rank();
	if (rank == 0)
	{
	Skaityti();
	}
	else if (rank < 10)
	{
	DetiIB();
	}
	else if (rank < 19)
	{
	SalintiIsB();
	}
	else if (rank == 19)
	{
	Valdymas();
	}
	MPI::Finalize();
	return 0;
}

void Skaityti()
{
	vector< vector<Picos> > P;
	vector< vector<Pirkimai> > V;
	Skaitymas1(P);
	Skaitymas2(V);
	int i = 0;
	int j = 0;
	while(i < P.size())
	{
		vector<Picos> picos = P[i];
		Picu_siuntimas(&picos[0], picos.size(), i + 1);
		i++;
	}
		while(j < V.size())
	{
		vector<Pirkimai> pirkimai = V[j];
		Pirkimu_siuntimas(&pirkimai[0], pirkimai.size(), j + 10);
		j++;
	}
	int dydis;
	Pirkimai *B = Pirkimu_gavimas(dydis, 19);
	Rasymas1(P);
	Rasymas2(V);
	Rasymas(B, dydis);
	fileDuom.close(); //Uždaromas duomenų failas
	fileRez.close(); //Uždaromas rezultatų failas
}

void DetiIB(){
	int dydis;
	Picos *picos = Picu_gavimas(dydis, 0);
	int bytes = sizeof(Picos);
	for(int i = 0; i < dydis; i++)
	{
		MPI::COMM_WORLD.Send(&bytes, 1, MPI::INT, 19, 1);
		MPI::COMM_WORLD.Send(&picos[i], bytes, MPI::CHAR, 19, 2);
	}
	bytes = 0;
	MPI::COMM_WORLD.Send(&bytes, 1, MPI::INT, 19, 1);
}
//Metodas skirtas iš duomenų failo pildyti P masyva picomis
void SalintiIsB(){
	int dydis;
	Pirkimai *pirkimai = Pirkimu_gavimas(dydis,0);

	bool pavyko[dydis];
	bool nepasalinti = true;
	int bytes = sizeof(Pirkimai);
	while(nepasalinti)
	{
		nepasalinti = false;
		for (int i = 0; i < dydis; i++)
		{
			if(!pavyko[i])
			{
				MPI::COMM_WORLD.Send(&bytes, 1, MPI::INT, 19, 1);
				MPI::COMM_WORLD.Send(&pirkimai[i], bytes, MPI::CHAR, 19, 2);
				int reiksme;
				MPI::COMM_WORLD.Recv(&reiksme, 1, MPI::INT, 19, 4);

				if(reiksme == 1)
				{
					pavyko[i] = true;
				}
				else if(reiksme == 0)
				{
					nepasalinti = true;
				}
			}
		}
	}
	bytes = 0;
	MPI::COMM_WORLD.Send(&bytes, 1, MPI::INT, 19, 1);
}
void Skaitymas1(vector<vector<Picos> > &P) {
	int kiekis; //Picerijų kiekis
	string picerija; //Picerijos pavadinimas
	int picuKiekis; //Picų kiekis

		fileDuom >> kiekis;
		for (int i = 0; i < kiekis; i++)
		{
			Picos pica; //Picos elementas
			vector<Picos> picos; //Picų masyvas
			fileDuom >> picerija >> picuKiekis;
			for (int j = 0; j < picuKiekis; j++)
			{
				fileDuom >> pica.pica >> pica.dydis >> pica.kaina;
				picos.push_back(pica);
			}
			P.push_back(picos);
		}
}
//Metodas skirtas iš duomenų failą pildyti masyva V pirkimo elementais
void Skaitymas2(vector<vector<Pirkimai> > &V) {
	int kiekis; //Pirkėjų kiekis
	string pirkejas; //Pirkėjo pavadinimas
	int picuKiekis; //Picų kiekis
		fileDuom >> kiekis;
		for (int i = 0; i < kiekis; i++)
		{
			Pirkimai pirkimas; //Pirkimų elementas
			vector<Pirkimai> pirkimai; //Pirkimų masyvas
			fileDuom >> pirkejas >> picuKiekis;
			for (int j = 0; j < picuKiekis; j++)
			{
				fileDuom >> pirkimas.pica >> pirkimas.kiekis;
				pirkimai.push_back(pirkimas);
			}
			V.push_back(pirkimai);
		}
}
//Metodas skirtas spausdinimui P masyvo duomenų
void Rasymas1(vector<vector<Picos> > &P) {

		for (int i = 0; i < P.size(); i++)
		{
			fileRez << "P masyvas: " << i + 1 << endl;
			fileRez << setw(3) << "Nr." << setw(20) << "Pica" << setw(8) << "Dydis" << setw(10) << "Kaina" << endl;
			for (int j = 0; j < P[i].size(); j++)
			{
				fileRez << setw(2) << j + 1 << ")" << setw(20) << P[i][j].pica << setw(8) << P[i][j].dydis << setw(10) << P[i][j].kaina << endl;
			}
		}
		fileRez << setfill('-') << setw(41) << "-" << setfill(' ') << endl;

}
//Metodas skirtas spausdinimui V masyvo duomenų
void Rasymas2(vector<vector<Pirkimai> > &V) {
	if (fileRez.is_open())
	{

		for (int i = 0; i < V.size(); i++)
		{
			fileRez << "V masyvas: " << i + 1 << endl;
			fileRez << setw(3) << "Nr." << setw(20) << "Pica" << setw(8) << "Kiekis" << endl;
			for (int j = 0; j < V[i].size(); j++)
			{
				fileRez << setw(2) << j + 1 << ")" << setw(20) << V[i][j].pica << setw(8) << V[i][j].kiekis << endl;
			}
		}
		fileRez << setfill('-') << setw(30) << "-" << setfill(' ') << endl;
	}
	else cout << "Nepavyko atidaryti failo";
}
//B masyvo spausdinimo metodas
void Rasymas(Pirkimai *B, int dydis){

		if (dydis != 0) //Jei egzistuoja elementai masyve
		{
			fileRez << "Masyvas B:" << endl;
			fileRez << setw(3) << "Nr." << setw(20) << "Pica" << setw(8) << "Kiekis" << endl;
			for (int j = 0; j < dydis; j++)
			{
				fileRez << setw(2) << j + 1 << ")" << setw(20) << B[j].pica << setw(8) << B[j].kiekis << endl;
			}
		}
		else //Jei masyvas tuščias
		{
			fileRez << "Masyvas B yra tuscias" << endl;
		}
	}