#include <iostream>

class platnosc {
private:
	char * nazwa;
	double kwota;
	int dzien;
	int miesiac;
	int rok;
public:
	platnosc(char * nazwa, double kwota, int dzien, int miesiac, int rok) : nazwa(nazwa), kwota(kwota), dzien(dzien), miesiac(miesiac), rok(rok){}
	~platnosc(){
		delete[] nazwa;
	}
	//operator mniejszości potrzebny do sortowania platności w ostatniej kolejce
	bool operator< (const platnosc & plat) const{
		if (rok < plat.rok) return true;
		if (rok > plat.rok) return false;
		if (miesiac < plat.miesiac) return true;
		if (miesiac > plat.miesiac) return false;
		if (dzien < plat.dzien) return true;
		if (dzien > plat.dzien) return false;
		//równe
		return false;
	}
};

class stos_platnosci {
protected:
	platnosc ** tab;
	int rozmiar;
	int pozycja;

public:
	//kontruktor z parametrem rozmiaru
	//ustawia początkową pozycję kolejki na -1 i tworzy dynamiczną tablicę wskaźników na platnosc
	stos_platnosci(int rozmiar){
		this->rozmiar = rozmiar;
		this->pozycja = -1;
		this->tab = new platnosc*[rozmiar];
	}
	//operator -=. Ten parametr int jest w zasadzie gówno potrzebny, na dobrą sprawę operator -= jest tutaj logicznie zbędny, ale polecenie to polecenie -.-
	//najpierw sprawdzam czy kolejka nie jest pusta. Jeśli nie to pobiera ostatnią płatność, usuwa ją z kolejki i zwraca jako wskaźnik
	platnosc * operator-=(int temp){
		if (this->pozycja == -1) return nullptr;
		platnosc *  plat = this->tab[this->pozycja];
		delete this->tab[this->pozycja];
		this->pozycja--;
		return plat;
	}
	//dodaje platnosc na górze kolejki. Najpierw sprawdzam czy kolejka nie jest pełna. Funkcja zwraca true jeśli poprawnie doda element na górze kolejki
	//virtual bo funkcja ta jest nadpisywana przez kolejkę
	virtual bool put(platnosc * plat){
		if ((this->rozmiar - this->pozycja) == 1) return false;
		this->pozycja++;
		this->tab[this->pozycja] = plat;
		return true;
	}

	//3 funkcje pomocnicze potrzebne przy przeciążaniu operatora = w kolejce
	int pobierzPozycje(){
		return this->pozycja;
	}

	platnosc ** pobierzTablice(){
		return this->tab;
	}

	int pobierzRozmiar(){
		return this->rozmiar;
	}
};

class kolejka_wydatkow : public stos_platnosci {
private:
	//funkcja do czyszczenia pamięci. Nie jest w destruktorze, bo ten kod wykorzystuję też przy operatorze =
	void czysc(){
		if (this->pozycja > -1)
			for (int i = 0; i <= this->pozycja; i++)
				delete this->tab[i];
			this->pozycja = -1;
			delete[] this->tab;
	}
public:
	//destruktor. Przechodzi całą tablicę i zwalnia wszystkie płatności, po czym usuwa tablicę z pamięci
	~kolejka_wydatkow(){
		this->czysc();
	}

	//dodawanie platnosci na szczyt kolejki
	bool put(platnosc * plat){
		if ((this->rozmiar - this->pozycja) == 1) return false;
		this->pozycja++;
		//jeżeli tablica była pusta to nie trzeba nic sortować
		if (this->pozycja == 0){
			this->tab[this->pozycja] = plat;
			return true;
		}
		for (int i = this->pozycja - 1; i > 0; i--){
			if (this->tab[i] < plat){
				//jeżeli element jest mniejszy od dodawanego to przesuń go w prawo
				this->tab[i + 1] = this->tab[i];
			}else{
				//jeżeli element jest równy bądź większy od dodawanego to dodaj element w to miejsce i przerwij funkcję
				this->tab[i + 1] = plat;
				return true;
			}
		}
		//jeżeli program dotarł aż tutaj to znaczy że dodawany przez nas element jest największy w zbiorze
		this->tab[0] = plat;
		return true;
	}

	bool operator=(stos_platnosci &stos){
		if (stos.pobierzPozycje() == -1) return false;
		//najpierw czyszczę całą aktualną kolejkę
		this->czysc();
		//na nowo tworzę tablicę i przypisuję rozmiar
		this->tab = new platnosc*[stos.pobierzRozmiar()];
		this->rozmiar = stos.pobierzRozmiar();
		platnosc ** tablica = stos.pobierzTablice();
		//krok po kroku przepisuję kolejkę używają funkcji put, która automatycznie sortuje elementy
		for (int i = 0; i <= stos.pobierzPozycje(); i++)
			this->put(tablica[i]);
		return true;
	}
};

//co do operatora >> to szczerze mówiąc nie mam zielonego pojęcia jak się do tego w ogóle zabrać i jak ma to wyglądać

int _tmain(int argc, _TCHAR* argv[])
{
	return 0;
}