#include "Olt.h"

class Olt;

Olt::Olt() {};
Olt::Olt(int _dbaAlgoritmus, uint16_t pocetOnu, uint16_t _pocetAllocId) {
	dbaAlgoritmus = _dbaAlgoritmus;
	pocetAllocId = _pocetAllocId;
	std::map<double, uint16_t> statistikyGrantu;
	if (dbaAlgoritmus == dbaHyra)
		hyra = Hyra(pocetOnu, pocetAllocId);
	else if (dbaAlgoritmus == dbaMaxMin)
		MaxMin = Maxmin(pocetOnu, pocetAllocId);
	else if (dbaAlgoritmus == dbaGiant)
		giant = Giant(pocetOnu, pocetAllocId);

	for (int i = 0; i < pocetOnu*pocetAllocId; i++)
	{
		std::vector<Sdu> fronta;
		BufferUp.push_back(fronta);

			obsazenostFrontOnu.push_back(0);
			dbruOdeslano.push_back(0);
			casGenerovaniGrantuStatik.push_back(statistikyGrantu);
			fragmentovaneSdu.push_back(Sdu((uint16_t)0xffffff, (uint16_t)0xffffff, (double)0, (uint16_t)0, (uint8_t)0, (uint16_t)0));
		
	}
	odesilaDXgtc = 0;
		
}

uXgtcBurst Olt::getBuffer(int index)
{
	return Buffer[index];
}

void Olt::addToBuffer(uXgtcBurst burst)
{
	Buffer.push_back(burst);
}

void Olt::vygenerujStatistikyBwMap() {
	for (uint16_t i = 0; i < casGenerovaniGrantuStatik.size(); i++) {
		std::map<double, uint16_t>::iterator it = casGenerovaniGrantuStatik[i].begin();

		std::stringstream cestaSouboru;
		cestaSouboru << "BwMapProAllocId" << i << ".txt";

		std::ofstream myfile;
		
		myfile.open(cestaSouboru.str(), std::ofstream::out);
		if (myfile.is_open())
		{
			myfile << "casOdeslani granty\n";
			while (it != casGenerovaniGrantuStatik[i].end())
			{			

				myfile << it->first << " " << it->second << "\n";
				it++;
			}
		}
		else std::cout << "Soubor nelze otevrit!";
		myfile.close();
	}


}

std::vector<AllocStruc> Olt::dbaStatikGenerateBW(double &_cas, std::vector<Onu> &onus)
{
	uint16_t nasledujiciStartTime = 0;
	size_t pocetOnu = onus.size();
	uint16_t grantSize = 9719/(pocetOnu*pocetAllocId);
	std::vector<AllocStruc> bwMap;
	if (_cas == (double)0.000) {
		for (uint16_t i = 0; i < pocetOnu; i++) {
			for (uint16_t j = 0; j < onus.at(i).getAllocIds().size(); j++) {
				uint8_t Flags = 0;	
				AllocStruc aktualneGenerovanaStruktura = AllocStruc(onus.at(i).getAllocIds().at(j).getAllocID(), Flags, nasledujiciStartTime, grantSize);
				bwMap.push_back(aktualneGenerovanaStruktura);
				nasledujiciStartTime += grantSize + 1;
				casGenerovaniGrantuStatik[(i*pocetAllocId) + j].insert(std::make_pair(_cas, grantSize));
			}
		}
	}
	else
		bwMap = bwMapa;
	return bwMap;
}

void Olt::vygenerujStatistiky() {
	if (dbaAlgoritmus == dbaHyra)
	{
		hyra.vygenerujStatistikyBwMap();
	}else if (dbaAlgoritmus == dbaMaxMin)
		MaxMin.vygenerujStatistikyBwMap();
	else if (dbaAlgoritmus == dbaStatik)
		vygenerujStatistikyBwMap();
	else if (dbaAlgoritmus == dbaGiant)
		giant.vygenerujStatistikyBwMap();
}

float Olt::simuluj(double _cas, int16_t aktualniStartTime, std::vector<Onu> *onus, uXgtcBurst PonUp[], DXgtcFrame &PonDown) {
	//vyrizeni prijmu XGTCFrameu
	
	uXgtcBurst pravePrijaty = PonUp[aktualniStartTime];	
	if (pravePrijaty.getHeader().getOnuId() >= 0)
	{
		for (uint32_t j = 0; j < pravePrijaty.getAlokacniInterval().size(); j++)
		{
			AlokacniInterval zpracovavanyAlokacniInterval = pravePrijaty.getAlokacniInterval()[j];
			if (zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId() != 0xFFFF)
			{
				if (zpracovavanyAlokacniInterval.getXgtcNaklad().getLf() == 1 && fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()].getVelikost() == 0 && zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemNaklad().getVelikost()>0)
				{
					BufferDown.push_back(zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemNaklad());
				}else if (zpracovavanyAlokacniInterval.getXgtcNaklad().getLf() == 0 && fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()].getVelikost() == 0)	
				{
					fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()] = zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemNaklad();
				}
				else if (zpracovavanyAlokacniInterval.getXgtcNaklad().getLf() == 1 && fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()].getVelikost() != 0 && zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemNaklad().getVelikost())
				{
					BufferDown.push_back(zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemNaklad().deFragmentuj(fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()]));
					fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()] = Sdu((uint16_t)0xffffff, (uint16_t)0xffffff, (double)0, (uint16_t)0, (uint8_t)0, (uint16_t)0);
				}
				else if (zpracovavanyAlokacniInterval.getXgtcNaklad().getLf() == 0 && fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()].getVelikost() != 0)
				{
					fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()] = zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemNaklad().deFragmentuj(fragmentovaneSdu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()]);
				}
				if (dbruOdeslano[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()] == 1)
				{
					obsazenostFrontOnu[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()] = zpracovavanyAlokacniInterval.getDbrU().getBuffOcc();
					dbruOdeslano[zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId()] = 0;
				}
					if (dbaAlgoritmus == dbaHyra && hyra.getT1(pravePrijaty.getHeader().getOnuId()) != 0 && zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemNaklad().getVelikost()>0)
					{
						double dobaIzolace = (_cas - hyra.getT1(pravePrijaty.getHeader().getOnuId())) / 0.000125;
						if (dobaIzolace > 400)
							dobaIzolace = 400;
						double nejvetsiPravdepodobnost = 0;
						int nejpravdepodobnejsi = 0;
						hyra.setT1(pravePrijaty.getHeader().getOnuId(), 0);
						for (int i = 0; i < 400; i++) {
							if (hyra.getP(pravePrijaty.getHeader().getOnuId(), i) > nejvetsiPravdepodobnost)
							{
								nejvetsiPravdepodobnost = hyra.getP(pravePrijaty.getHeader().getOnuId(), i);
								nejpravdepodobnejsi = i;
							}
						}
						hyra.setA(hyra.getT1(pravePrijaty.getHeader().getOnuId()), nejpravdepodobnejsi);
						hyra.aktualizace(pravePrijaty.getHeader().getOnuId(), (uint16_t)dobaIzolace);
					}
				
			}else if (dbaAlgoritmus == dbaHyra && hyra.getT1(pravePrijaty.getHeader().getOnuId() && zpracovavanyAlokacniInterval.getXgtcNaklad().getXgemPortId() == 65535) == 0)
			{
				hyra.setT1(pravePrijaty.getHeader().getOnuId(), _cas);
			}				
		}
		PonUp[aktualniStartTime] = uXgtcBurst();
	}

	//zpracovani bufferu prijatych dat
	while (!BufferDown.empty())
	{
		if (BufferDown.front().getCilovaAdresa() == 1024)
		{
			if (BufferDown.front().getTyp() == 0) {
				Sdu kZpracovani = BufferDown.front();
				BufferDown.erase(BufferDown.begin());
				int16_t cilovaAdresa = kZpracovani.getCilovaAdresa();
				int16_t zdrojovaAdresa = kZpracovani.getZdrojovaAdresa();
				kZpracovani.setTyp(1);
				kZpracovani.setZdrojovaAdresa(cilovaAdresa);
				kZpracovani.setCilovaAdresa(zdrojovaAdresa);				
				BufferUp.at(kZpracovani.getCilovaAdresa()).push_back(kZpracovani);
			}
			else if (BufferDown.front().getTyp() == 1) {
				double casOdeslani = BufferDown.front().getcasOdeslani();
				BufferDown.erase(BufferDown.begin());
				casOdpovediSdu.push_back(casOdeslani);
				zpozdeniOdpovediSdu.push_back(_cas - casOdeslani);
			}
		}
		else {
			casZahozeni.push_back(_cas);
			BufferDown.erase(BufferDown.begin());
		}
	}

	//generovani dXGTC ramce
	if (odesilaDXgtc == 0)
	{
		if (dbaAlgoritmus == 0) {
			bwMapa = dbaStatikGenerateBW(_cas, *onus);
		}
		else if (dbaAlgoritmus == 1) {
			bwMapa = hyra.generujBwmapu(_cas, obsazenostFrontOnu, &dbruOdeslano);
		}
		else if (dbaAlgoritmus == dbaMaxMin)
			bwMapa = MaxMin.generujBwmapu(_cas, obsazenostFrontOnu, &dbruOdeslano);
		else if (dbaAlgoritmus == dbaGiant)
			bwMapa = giant.generujBwmapu(_cas, obsazenostFrontOnu, &dbruOdeslano);

		uint16_t pocetBwMap = bwMapa.size();
		uint16_t volneBajty = 135432 - 4 - (8 * pocetBwMap);	
		PonDown = DXgtcFrame();			

			std::vector<Xgem> naklad;
			DXgtcHeader dXgtcHlavicka = DXgtcHeader(HLend(pocetBwMap), bwMapa);
			bwMapa.clear();
			uint16_t frontyObsahujiData = BufferUp.size();
			while (frontyObsahujiData > 0)
			{
				frontyObsahujiData = BufferUp.size();
				for (uint16_t i = 0; i < BufferUp.size(); i++) {
					if (!BufferUp.at(i).empty() && volneBajty > ((BufferUp.at(i).front().getVelikost() / 8) + 6))
					{
							Xgem castNakladu = Xgem(BufferUp.at(i).front().getVelikost(), BufferUp.at(i).front().getCilovaAdresa(), 1, BufferUp.at(i).front());
							naklad.push_back(castNakladu);
							volneBajty -= (BufferUp.at(i).front().getVelikost())/8 + 6;
							BufferUp.at(i).erase(BufferUp.at(i).begin());
							i--;
					}
					else
					{
						frontyObsahujiData--;
					}
				}
			}

			odesilanyDXgtcRamec = DXgtcFrame(dXgtcHlavicka, naklad);	
			odesilaDXgtc++;		
		
	}else if (odesilaDXgtc == 8464)
		{
			PonDown = odesilanyDXgtcRamec;
			odesilaDXgtc = 0;
		}else
		{
			odesilaDXgtc++;
		}
	return 1;
}

/************************** ONU *********************************/
Onu::Onu(int16_t _onuId, uint16_t pocetAllocId, uint16_t _bitovaRychlost) {
	OnuId = _onuId;
	std::map<double, uint16_t> statistikyIdle;
	for (int i = 0; i < pocetAllocId; i++) {
		allocId.push_back(AllocId((OnuId*pocetAllocId)+i));
		casGenerovaniIdle.push_back(statistikyIdle);
	}
	int nasobeniToku = 1;
	while ((_bitovaRychlost / nasobeniToku) >= 77760000) {
		nasobeniToku++;
	}
	generujTokZa = 0;
	casGenerovaniToku = ((double)1 / _bitovaRychlost) * ((double)1 / (double)0.00000001286008230452670);	//neboli pocet startimu do odeslani SDU o velikosti 1024;
	velikostSDUProGenerovani = 1024 * nasobeniToku;
	bitovaRychlost = nasobeniToku;

	poradiPoslednihoSdu = 0;
	velikostBufferu = 1000;		
}

AlokacniInterval Onu::generujIdleXgem(uint16_t velikost, DbrU _dbru) {
	AlokacniInterval alokacniInterval = AlokacniInterval(_dbru, Xgem(velikost, 65535, 1, Sdu()));	
	return alokacniInterval;
}

float Onu::simuluj(double _cas, int16_t aktualniStartTime, uXgtcBurst PonUp[], DXgtcFrame* PonDown) {

	if (aktualniStartTime == 0)
	{
		for (uint16_t i = 0; i < allocId.size(); i++)
		{
			allocId[i].setStartTime(allocId[i].getStartTimeNew());
			allocId[i].setGrantSize(allocId[i].getGrantSizeNew());
		}
	}

	if (generujTokZa <= 0)
	{
		generujTokZa = (uint32_t)casGenerovaniToku;
		for (int16_t i = 0; i < bitovaRychlost; i++)
		{
		Sdu sdu = Sdu(allocId[1].getAllocID(), 1024, _cas, poradiPoslednihoSdu, 0, velikostSDUProGenerovani);
		if(allocId[1].getBufferUp()->size()<100000)
			allocId[1].getBufferUp()->push_back(sdu);
		poradiPoslednihoSdu++;
		}
	}
	else
		generujTokZa--;

	//vyrizeni prijmu dXGTCFrameu
	if (PonDown->getdXgtcHeader().getHLend().getBWmapLength() > 0 || PonDown->getNaklad().size() > 0)
	{
		DXgtcFrame pravePrijaty = *PonDown;

		DXgtcHeader pravePrijataHlavicka = pravePrijaty.getdXgtcHeader();

		if (pravePrijataHlavicka.getHLend().getBWmapLength() > 0)
		{
			std::vector<AllocStruc> aktualniBwMapa = pravePrijataHlavicka.getBwmap();
			
			for (uint16_t i=(uint16_t)0; i<aktualniBwMapa.size(); i++)
			{
				for (uint16_t j = (uint16_t)0; j<allocId.size(); j++)
				{
					if (aktualniBwMapa[i].getAllocId() == allocId[j].getAllocID())
					{
						if (aktualniBwMapa[i].getStartTime() == 9696)
							int z = 0;
						if(aktualniBwMapa[i].getFlags()==1)
							allocId[j].setdbruByloNastaveno(1);
						allocId[j].setStartTimeNew(aktualniBwMapa[i].getStartTime());
						allocId[j].setGrantSizeNew(aktualniBwMapa[i].getGrantSize());
					}
				}
			}
		}

		for (uint16_t i = 0; i < PonDown->getNaklad().size(); i++)
		{
			for (auto zpracovavaneAllocId : allocId)
			{
				if (pravePrijaty.getNaklad()[i].getXgemPortId() == zpracovavaneAllocId.getAllocID())
				{
					BufferDown.push_back(pravePrijaty.getNaklad()[i].getXgemNaklad());					
				}
			}
		}
	}

		uint32_t volnychBajtu = 0;
		uint16_t velikostDbru = 0;
		bool grantNenastaven = false;
		for (uint16_t i = 0; i < allocId.size(); i++)
		{
			velikostDbru = 0;
			if (allocId[i].getStartTime() == aktualniStartTime) {
				if (aktualniStartTime == 6 && _cas > 0.0707) {
					int x = 0;
				}
				volnychBajtu = allocId[i].getGrantSize() * 4; 
				if (volnychBajtu == 0)
					grantNenastaven = true;

				std::vector<AlokacniInterval> alokacniIntervaly;
				//Status Reporting (SR) metoda
				DbrU dbrU = DbrU(0xFFFFFF);				
				Sdu zpracovavaneSdu = Sdu((uint16_t)0xffffff, (uint16_t)0xffffff, (double)0, (uint16_t)0, (uint8_t)0, (uint16_t)0);
				if (allocId[i].getdbruByloNastaveno() == 1)
				{
					allocId[i].setdbruByloNastaveno(0);
					uint32_t obsazenostVsechFront = 0;
					std::vector<Sdu> *zpracovavanyBuffer = allocId[i].getBufferUp();
					for (uint16_t j = 0; j < zpracovavanyBuffer->size(); j++) {
						if (zpracovavanyBuffer->at(j).getVelikost() > 8)
							obsazenostVsechFront += (zpracovavanyBuffer->at(j).getVelikost() / 4);
						else
							obsazenostVsechFront += 2;
					}
					velikostDbru = 4;	
					dbrU = DbrU(obsazenostVsechFront);
					if (allocId[i].getGrantSize() == 1)		
					{
						AlokacniInterval alokacniInterval = AlokacniInterval(dbrU, Xgem(zpracovavaneSdu.getVelikost() + velikostDbru, allocId[i].getAllocID(), 1, zpracovavaneSdu));
						alokacniIntervaly.push_back(alokacniInterval);
						volnychBajtu -= 4;
					}
				}
				if (allocId[i].getFragmentovaneSdu().getVelikost() != 0 && volnychBajtu>16) {
					zpracovavaneSdu = allocId[i].getFragmentovaneSdu();
					AlokacniInterval alokacniInterval;
					if (allocId[i].getFragmentovaneSdu().getVelikost() + velikostDbru + (uint16_t)6 > volnychBajtu)
					{
						allocId[i].setFragmentovaneSdu(zpracovavaneSdu.fragmentuj(volnychBajtu-(6 + velikostDbru)));
						alokacniInterval = AlokacniInterval(dbrU, Xgem(zpracovavaneSdu.getVelikost() + velikostDbru, allocId[i].getAllocID(), 0, zpracovavaneSdu));
						volnychBajtu -= zpracovavaneSdu.getVelikost() + velikostDbru + 6;
					}
					else
					{
						zpracovavaneSdu = allocId[i].getFragmentovaneSdu();
						alokacniInterval = AlokacniInterval(dbrU, Xgem(zpracovavaneSdu.getVelikost() + velikostDbru, allocId[i].getAllocID(), 1, zpracovavaneSdu));
						allocId[i].setFragmentovaneSdu(Sdu((uint16_t)0xffffff, (uint16_t)0xffffff, (double)0, (uint16_t)0, (uint8_t)0, (uint16_t)0));
						volnychBajtu -= (uint16_t)zpracovavaneSdu.getVelikost() + velikostDbru + 6;
					}						
					alokacniIntervaly.push_back(alokacniInterval);
					zpracovavaneSdu = Sdu((uint16_t)0xffffff, (uint16_t)0xffffff, (double)0, (uint16_t)0, (uint8_t)0, (uint16_t)0);
					allocId[i].setOdesilani(true);
				}

				if (allocId[i].getBufferUp()->size() > 0) {
					if ((allocId[i].getBufferUp()->front().getVelikost()+(uint16_t) 6) <= volnychBajtu ) {
						allocId[i].setOdesilani(true);

						while (!allocId[i].getBufferUp()->empty() && (allocId[i].getBufferUp()->front().getVelikost() + (uint16_t)6 + velikostDbru) <= volnychBajtu) {	//14b+2b+16b+18b+1b+13 = 64b = 6B = hlavicka XGEM
							zpracovavaneSdu = allocId[i].getBufferUp()->front();
							AlokacniInterval alokacniInterval = AlokacniInterval(dbrU, Xgem(zpracovavaneSdu.getVelikost() + velikostDbru, allocId[i].getAllocID(), 1, zpracovavaneSdu));
							alokacniIntervaly.push_back(alokacniInterval);
							volnychBajtu -= allocId[i].getBufferUp()->front().getVelikost() + 6 + velikostDbru;
							allocId[i].getBufferUp()->erase(allocId[i].getBufferUp()->begin());
							zpracovavaneSdu = Sdu((uint16_t)0xffffff, (uint16_t)0xffffff, (double)0, (uint16_t)0, (uint8_t)0, (uint16_t)0);
						}
					}
					else if ((!allocId[i].getBufferUp()->empty()) && (volnychBajtu > 15))
					{
						allocId[i].setFragmentovaneSdu(allocId[i].getBufferUp()->front().fragmentuj(volnychBajtu-(6+velikostDbru)));
						zpracovavaneSdu = allocId[i].getBufferUp()->front();
						AlokacniInterval alokacniInterval = AlokacniInterval(dbrU, Xgem(zpracovavaneSdu.getVelikost() + velikostDbru, allocId[i].getAllocID(), 0, zpracovavaneSdu));
						alokacniIntervaly.push_back(alokacniInterval);
						volnychBajtu -= zpracovavaneSdu.getVelikost() + 6 + velikostDbru;
						allocId[i].getBufferUp()->erase(allocId[i].getBufferUp()->begin());
					}
				}
					while (volnychBajtu >= 6) {
						uint16_t velikostIdleXgem = volnychBajtu - (6);
						alokacniIntervaly.push_back(generujIdleXgem(velikostIdleXgem, dbrU));	
						volnychBajtu -= velikostIdleXgem + 6;
						casGenerovaniIdle[i].insert(std::make_pair(_cas, velikostIdleXgem));
					}				
				uXgtcBurst UxgtcBurst = uXgtcBurst(OnuId, alokacniIntervaly);
				if(!grantNenastaven)
					PonUp[allocId[i].getGrantSize() + allocId[i].getStartTime()] = UxgtcBurst;
			}			
		}	
	
	//zracovani prijatych dat
	while (!BufferDown.empty())
	{
			if (BufferDown.front().getTyp() == 0) {
				Sdu kZpracovani = BufferDown.front();
				BufferDown.erase(BufferDown.begin());
				int16_t cilovaAdresa = kZpracovani.getCilovaAdresa();
				int16_t zdrojovaAdresa = kZpracovani.getZdrojovaAdresa();
				kZpracovani.setZdrojovaAdresa(cilovaAdresa);
				kZpracovani.setCilovaAdresa(zdrojovaAdresa);

				allocId[0].getBufferUp()->push_back(kZpracovani);
			}
			else if (BufferDown.front().getTyp() == 1) {
				double casOdeslani = BufferDown.front().getcasOdeslani();
				casOdpovediSdu.push_back(casOdeslani);
				zpozdeniOdpovediSdu.push_back(_cas - casOdeslani);
				BufferDown.erase(BufferDown.begin());
			}
	}
	return 1;
}

void Onu::vygenerujStatistiky() {

	double prumerneZpozdeni = 0;
	std::stringstream cestaSouboru;
	std::stringstream cestaSouboruPrumeru;

	cestaSouboru << "CasOdpovediSduOnu" << OnuId << ".txt";
	cestaSouboruPrumeru << "PrumerneZpozdeni" << OnuId << ".txt";

	std::ofstream myfile(cestaSouboru.str());
	std::ofstream myfileZpozdeni(cestaSouboruPrumeru.str());

	if (myfile.is_open())
	{
		myfile << "casOdeslani zpozdeni\n";
		for (uint16_t i=0; i< casOdpovediSdu.size(); i++)
		{
			myfile << casOdpovediSdu[i] << " " << zpozdeniOdpovediSdu[i] << "\n";
			prumerneZpozdeni += zpozdeniOdpovediSdu[i];
		}
	}
	else std::cout << "Soubor nelze otevrit!";
	myfile.close();

	prumerneZpozdeni /= casOdpovediSdu.size();

	if (myfileZpozdeni.is_open())
	{
		myfileZpozdeni << "Prumerne zpozdeni " << prumerneZpozdeni;
		
	}
	else std::cout << "Soubor nelze otevrit!";
	myfileZpozdeni.close();
}

void Onu::vygenerujStatistikyIdle() {
	uint32_t celkemBajtu = 0;
	for (uint16_t i = 0; i < casGenerovaniIdle.size(); i++) {
		celkemBajtu = 0;
		std::map<double, uint16_t>::iterator it = casGenerovaniIdle[i].begin();

		std::stringstream cestaSouboru;
		std::stringstream cestaSouboruCelkem;
		cestaSouboru << "CasGenerovaniIdleProOnu"  << OnuId << "AllocId"<< i << ".txt";
		cestaSouboruCelkem << "CelkovaVelikostIdleProOnu" << OnuId << "AllocId" << i << ".txt";
		
		std::ofstream myfile;
		std::ofstream myfileCelkem;
		myfile.open(cestaSouboru.str(), std::ofstream::out);
		if (myfile.is_open())
		{
			myfile << "casOdeslani velikost\n";
			while (it != casGenerovaniIdle[i].end())
			{
					

				myfile << it->first << " " << it->second << "\n";
				celkemBajtu += it->second;
				it++;
			}
		}
		else std::cout << "Soubor nelze otevrit!";
		myfile.close();

		myfileCelkem.open(cestaSouboruCelkem.str(), std::ofstream::out);
		myfileCelkem << "Celkova velikost Idle: " << celkemBajtu;		
		myfileCelkem.close();
	}
}