#include <iostream>
#include <vector>
#include <string>


struct Process
{
	int PID;
	int processState; //0=virgin, 1=running, 2=waiting, 3=ready, 4=terminated;
	std::string name;

	Process* parent; //procesy przedstawiają drzewo, gdzie rodzic jest procesem macierzystym
	std::vector<Process*> children; //a dzieci jego procesami potomnymi

	int regA;    // 4 wartości rejestrów procesora
	int regB;
	int regC;
	int regD;

	int programCounter; //wskazuje następną instrukcję do wykonania
	std::string programData; //kod programu
	//std::string programText; //kod programu
	Process* programPosition; 
	bool processBlocked;
	
	Process(int ID, Process* father, std::string processName) //konstruktor procesu;
	{
		processState = 0;
		processBlocked = false;
		PID = ID;
		parent = father;
		name = processName;
	}
};

struct Karuzela
{
	std::vector<Process*> karuzela;
	void AddProcess(Process* process)
	{
		karuzela.push_back(process);
	}
};
//struct RAM //przykładowa tablica pamięci RAM
//{
//	int Ram[128];
//	void WriteToMemory(Process* process);
//};


struct ProcessManagment
{
	Process* init = new Process(0, nullptr, "name"); //proces, który wytwarza się przy startowaniu systemu
	//RAM* Ram = new RAM; //tablica pamięci od zarządzania pamiecią
	Karuzela* Karuzela;

	ProcessManagment()
	{
		init->PID = 0; //uzupełnianie procesu inicjijącego
		init->name = "name";
		init->parent = nullptr;
	}

	Process* FindProcess(int ID, Process* init) //funkcja przeszukująca drzewo procesów 
	{
		if (init->PID == ID) //jeżeli ID procesu się zgadza z szukanym
		{
			return init; //koniec rekurencji, zwraca znaleziony proces w postaci wskaźnika
		}
		else
		{	
			int i = 0;
			while(init->children[i]) //jeżeli dzieci istnieją
			{   
				i++;
				return FindProcess(ID, init->children[i]); //wykonaj rekurencje
			}
			return nullptr;
		}
	} 

	int FindID() //znajdywanie wolnego ID
	{
		int ID=0;
		while (FindProcess(ID, init)) //sprawdzanie czy ID jest juz używane 
		{
			ID++;
		}
		return ID;
	}

	void AddProcess(std::string processName, int parentID = 0)
	{
		Process* virgin = new Process(FindID(), FindProcess(parentID, init), processName); //tworzenie procesu
		virgin->processState = 3; //status na ready
		FindProcess(parentID, init)->children.push_back(virgin); //dodawanie do listy potomków dla rodzimego procesu
		Karuzela->AddProcess(virgin); //dodawanie do kolejki dla zarządzania procesami
		//Ram->WriteToMemory(virgin); //wywoływanie pamięci, orzepisuje program
	}
	int Fork(Process* parent) //dodaj proces potomny
	{
		Process* child = new Process(FindID(), parent, parent->name);
		
		child->regA = parent->regA; //potomek, jest kopią procesu macierzystego, ale ma inny ID
		child->regB = parent->regB;
		child->regC = parent->regC;
		child->regD = parent->regD;

		child->programCounter = parent->programCounter;

		parent->children.push_back(child);
		Karuzela->AddProcess(child);
		//Ram->WriteToMemory(child);
	}
	void KillProcess(int ID)
	{
		delete FindProcess(ID, init); //usuwanie wskaźnika do procesu w drzewie
	}
	void ChangeState(int ID, int newstate)
	{
		FindProcess(ID, init)->processState = newstate; //szukanie w drzewie procesu i zmiana jego stanu
	}
	void PrintProcess(int ID)
	{
		std::cout << "Process " <<FindProcess(ID, init)->PID << ": with parent ID " << FindProcess(ID, init)->parent << std::endl;
	}
	void PrintAllProcesses(int ID)
	{
		if (init->PID == ID) //jeżeli ID procesu się zgadza z szukanym
		{
			std::cout << "Process " << FindProcess(ID, init)->PID << ": with parent ID " << FindProcess(ID, init)->parent << std::endl;
		}
		else
		{
			int i = 0;
			while (init->children[i]) //jeżeli dzieci istnieją
			{
				std::cout << "Process " << FindProcess(init->children[i]->PID, init)->PID << ": with parent ID " << FindProcess(ID, init)->parent << std::endl;
				i++;
			}
		}
		
	}
};

int main()
{
	ProcessManagment list;
	list.AddProcess("amelia", 0);
	return 0;
}