#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
#include <ctime>
using namespace std;


template <typename T>

		// KLASA ELEMENT (WYKORZYSTUJE DO WPISANIA ELEMENTU)

class element{
public:

	T zmienna;
	element<T>*nast;
	element(T arg){
		zmienna=arg;
		nast=NULL;
	}
	element<T>(){
		nast=NULL;
	}
	~element(){
		delete nast;
		cout<<"Usunieto element"<<endl;
	}
	void operator+=(const element<T>&arg){
		zmienna += arg.zmienna;
	}
};

template <typename T>

class zbior{
public:
	element<T>*glowa;
	zbior(){
		glowa=NULL;
	}
	~zbior(){
		delete glowa;
		cout<<"Usunieto zbior"<<endl;
	}

						// UMIESZCZANIE NOWYCH ELEMENTOW
	void insert(T zmienna){

		element<T>*nowy;
		nowy = new element<T>(zmienna);
		element<T>*wsk = glowa;
		bool check = false;
		if (glowa == NULL){
			glowa = nowy;
		}/*
		else if(nowy->zmienna == glowa->zmienna){
		delete nowy;
		check = true;

		}
		else if(nowy->zmienna < glowa->zmienna){

		nowy->nast=glowa;
		glowa=nowy;
		}

		else{

		while(wsk->nast!=NULL && wsk->nast->zmienna <=zmienna){

		wsk=wsk->nast;
		}
		if(wsk->zmienna!=zmienna){
		nowy->nast=wsk->nast;
		wsk->nast=nowy;
		}

		}
		}

	*/

		else{
			if (nowy->zmienna == wsk->zmienna){
				delete nowy;
				check = true;
			}
			while (wsk->nast != NULL){
				if (check == false && nowy->zmienna == wsk->zmienna){
					delete nowy;
					check = true;
				}
				wsk = wsk->nast;
			}
			if (check == false)
				wsk->nast = nowy;
		}
	}


					// USUWANIE KOLEJNYCH WYBRANYCH ELEMENTOW
	void remove(T arg){
		/*
	element<T>*wsk=glowa;
	if(zmienna == glowa->zmienna){
	glowa=glowa->nast;
	wsk->nast=NULL;
	delete wsk;
	}
	else{
	while(wsk->nast!=NULL && wsk->nast->zmienna < zmienna && wsk->nast->zmienna!=zmienna){
	wsk=wsk->nast;
	}
	if(wsk->nast->zmienna == zmienna){
	element<T>*usun=wsk->nast;
	wsk->nast=wsk->nast->nast;
	usun->nast=NULL;
	delete usun;
	}
	}

	}
	// WYPISYWANIE KOLEJNYCH ELEMENTOW TABLICY
	void wypisz(){
	element<T>*wsk=glowa;
	while(wsk!=NULL){
	cout <<wsk-> zmienna;
	wsk=wsk->nast;
	}
	cout<<'\n';
	}
	*/
		element<T> * current = glowa;
		if (current != NULL && arg == current->zmienna){
			glowa = glowa->nast;
			current->nast = NULL;
			delete current;
		}
		else if (current != NULL){
			while (current->nast != NULL && arg != current->nast->zmienna){
				current = current->nast;
			}

			if (current->nast != NULL && arg == current->nast->zmienna && current->nast != NULL){
				element<T> * todele = current->nast;
				current->nast = current->nast->nast;
				todele->nast = NULL;
				delete todele;
			}
			else if (current->nast != NULL && arg == current->nast->zmienna && current->nast == NULL){
				element<T> * todele = current->nast;
				current->nast = NULL;
				todele->nast = NULL;
				delete todele;
			}
		}
	}
	template<typename T>
	friend ostream& operator <<(ostream & out, zbior<T>*pom);


	void plik(){
		cout << "Witaj, podaj nazwe pliku, do ktorego chcesz zapisac dane: ";
		string name;
		cin >> name;
		ofstream PLIK(name);
		if (PLIK.is_open()){

			element<T> temp;
			time_t czas;
			struct tm* timeinfo;
			char buffer[80];
			time(&czas);
			timeinfo = localtime(&czas);
			strftime(buffer, 80, "Warszawa,%d.%m.%Y", timeinfo);
			PLIK.setf(ios_base::right);
			PLIK.width(66);
			PLIK.fill(' ');
			PLIK << buffer << endl;
			PLIK.unsetf(ios_base::right);
			PLIK.setf(ios_base::internal);
			PLIK.width(35);
			PLIK << "RAPORT O STANIE GRY" << endl;
			PLIK.unsetf(ios_base::internal);
			PLIK << naglowki<T>();
			PLIK << linia<T>();
			element<T>*wsk = glowa;
			while (wsk != NULL){
				temp += wsk->zmienna;
				PLIK << efektor<T>(wsk);
				//temp += wsk->zmienna;
				wsk = wsk->nast;
			}
			PLIK << linia<T>();
			PLIK << stopka<T>(temp);

			PLIK.close();
		}
		else
			cout << "Nie znaleziono pliku" << endl;
	}

};

// OPERATOR
template<typename T>
ostream& operator << (ostream & out, zbior<T>*pom){

	element<T>*wsk=pom->glowa;
	while(wsk!=NULL){
		out<<wsk->zmienna<<' ';
		wsk=wsk->nast;
	}
	out<<'\n';
	return out;
}
					//	*****************************EFEKTORY***************************
template<typename T>
class efektor{
public:
	T pole;
	static int wskaznik;
	efektor(element<T>*arg){
		pole = arg->zmienna;
	}
};
template<typename T>
int efektor<T>::wskaznik = 1;
template<typename T>
ostream& operator <<(ostream& os, efektor<T>&fw){

	os.setf(ios_base::left);
	os.setf(ios_base::right);
	os.width(2);
	os << fw.wskaznik++;
	os.unsetf(ios_base::right);
	os.width(10);
	os << '.';
	os.setf(ios_base::right);
	//os.width(10);
	os << fw.pole;
	os.unsetf(ios_base::right);
	os.width(17);
	os.setf(ios_base::right);
	os << "1";
	os.unsetf(ios_base::right);
	return os << endl;

}
template<typename T>
class naglowki{
public:
	T pole;
	naglowki(){
	}
};
template<typename T>
ostream& operator<<(ostream&as, naglowki<T>&kl){
	as.setf(ios_base::left);
	as << "Lp.";
	as.unsetf(ios_base::left);
	as.width(9);
	as << " ";
	as.setf(ios_base::left);
	as << "nazwa";
	as.unsetf(ios_base::left);
	as.width(10);
	as << " ";
	as.setf(ios_base::left);
	as << "sztuk";
	as.unsetf(ios_base::left);
	return as << endl;
}
template<typename T>
class linia{
public:
	T pole;
	linia(){}
};
template<typename T>
ostream& operator <<(ostream&as, linia<T>&kl){
	//as.width(47);
	for (int i = 0; i < 60; i++){
		as << "=";
	}
	return as << endl;
}
template<typename T>
class stopka{
public:
	T pole;
	stopka(element<T>&arg){
		pole = arg.zmienna;
	}
};
template<typename T>
ostream& operator <<(ostream& os, stopka<T>&fw){
	os.width(15);
	os.setf(ios_base::right);
	os << fw.pole;
	return os;
}












					//**********************KLASA DLA ZESPOLONYCH******************************
class zesp{
public:
	int rz;
	int uro;
	zesp(){ rz = 0; uro = 0; }
	zesp(int a, int b){ rz = a; uro = b; }
	bool operator==(const zesp&arg){
		if (arg.rz == rz && arg.uro == uro) return true;
		return false;
	}
	bool operator!=(const zesp&arg){
		if (arg.rz == rz && arg.uro == uro) return false;
		return true;
	}
	void operator=(const zesp&arg){
		rz= arg.rz;
		uro= arg.uro;
	}
	void operator+=(const zesp&arg){
		rz += arg.rz;
		uro += arg.uro;
	}
	friend ostream& operator<<(ostream& out, zesp&arg){
		return out << arg.rz << '+' << arg.uro << "i";
	}
	friend istream& operator>>(istream& in, zesp&arg){
		return in >> arg.rz >> arg.uro;
	}
};

//**********************************MAIN*************************************
#include <iostream>
#include "unikalny_zbior.h"
#include <string>
#include <ctime>
#include <fstream>
#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
using namespace std;

int main(){

	//string pomoc;			// ZMIENNA POMOCNICZA (DO) WPROWADZANIA LITEREK

	//char wybor;				// ZMIENNA (DO) WYBORU KOMENDY PRZEZ UZYTKOWNIKA
	/*
	zbior<string>*ZB=new zbior<string>();

	cout<<"Witaj!.."<<endl<<"1.Dodaj: d"<<endl<<"2.Usun: u"<<endl<<"3.Pokaz: s"<<endl<<"4.Zakoncz: z"<<endl;

	cin>>wybor;

	while(wybor!='z'){
		if(wybor == 'd'){
			cout<<"Podaj literke, jaka chcesz dodac: ";
			cin>>pomoc;
			ZB->insert(pomoc);

		}

		else if(wybor == 'u'){
			cout<<"Podaj literke, jaka chcesz usunac: ";
			cin>>pomoc;
			ZB->remove(pomoc);
		}
		else if(wybor == 's'){

			cout<<"Oto elementy w twoim kontenerze"<<endl;
			//ZB->wypisz();
			cout<<ZB;
		}
		cin>>wybor;
	}
	ZB->plik();
	delete ZB;
	*/
	zbior<zesp>* A = new zbior<zesp>;
	char cont;
	zesp temp;
	cin >> cont;
	while (cont != 'e'){
		if (cont == 'i'){
			cin >> temp;
			A->insert(temp);
			cout << A;
		}
		 if (cont == 'r'){
			cin >> temp;
			A->remove(temp);
			cout << A;
		}
		 if (cont == 'f'){
			 A->plik();

		 }
		 cin >> cont;
	}

	delete A;
	return 0;
}