#include "pch.h"
#include <iostream>

// zad1
// zapoznaj się z implementacją klasy info (klasa raportuje operacje na niej wykonywane, obiekty są automatycznie numerowane)
// dokończ implementację klasy schowek
// klasa schowek przechowuje (za pomocą wskaźnika) daną typu info, lub nic (np. po konstrukji bezargumentowej)

// klasa schowek winna posiadać zwykłe i przenoszące warianty konstruktora (kopiującego) i operatora przypisania oraz konstruktor
// z argumentem &info, konstruktor bezargumentowy i destruktor, metody te powinny na wyjście raportować wykonywane operacje;

// wywołanie metody przenoszącej schowka nie powinno powodować konstrukcji obiektu info, ani błędów przy poźniejszej destrukcji
// przeanalizuj efekty wywołania funkcji zad1 - wykonując ją krokowo oraz śledząc komunikaty wyprowadzanie na konsolę
// rozbuduj funkcję zad1, by ten sposób sprawdzić:
// -w jakich sytuacjach wywoływane są metody zwykłe, a kiedy przenoszące (w razie potrzeby dopisz nowe metody/operatory do schowka)?
// -co jest wywoływane przy konstrukcji/przypisaniu do schowka z wyrażenia zwracającego tymczasowy nienazwany schowek?
// -co jest wywoływane przy konstrukcji/przypisaniu do schowka ze zmiennej zwracanej z funkcji przez wartość?
// -wypróbuj działanie move(), co się stanie gdy użyjemy move(), a w klasie nie ma metod przenoszących(zakomentuj je chwilowo)?
// -czy kompilator poprawnie rozpoznał wszystkie sytuacje kiedy można użyć metody przenoszącej?
// -czy metody przenoszące poprawiają wydajność kodu? Odpowiedź uzasadnij.

// zad2
// zapoznaj się za strukturą osoba i funkcją zad2
// dokończ funkcję zad2 posługując się algorytmami stl (sort for_each) i funkcjami lambda tak, aby
// - posortować listę liste osob los wg wieku osób
// - wyświetlić posortowane osoby (tylko imie i wiek każdej osoby)
// - zwiększyć wiek każdej z osób o 1 i ponownie wyświetlić listę
// - wyznaczyć średni wiek osoby, wyświetlić go i wyświetlić osoby starsze niż średnia
// uwaga: w capture list funkcji lambda należy przekazywać wyłącznie faktycznie potrzebne zmienne, nie używać [&] ani tym bardziej [=]




#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <tuple>
using namespace std;


class info
{
	static int serial,	// ++ przy konstrukcji
		cntr;	// ++ przy konstrukcji, -- przy destrukcji, zwracany przez getcntr
	const int  nr;		// =++serial przy konstrukcji
public:
	static int getcntr() { return cntr; };
	info() :nr(++serial) { cntr++; cout << "\ninfo() nr: " << nr; }
	info(const info &cri) :nr(++serial) { cntr++; cout << "\ninfo(const info &cri) nr: " << nr << " cri.nr: " << cri.nr; }
	~info() { cntr--; cout << "\n~info() nr: " << nr; }
	info & operator=(const info &cri) { cout << "\ninfo & operator=(const info &cri) nr: " << nr << " cri.nr: " << cri.nr; return *this; }
	friend ostream& operator<<(ostream &os, const info& cri) { return os << " info nr: " << cri.nr; }
};
int info::serial = 0,		// static w klasie
info::cntr = 0;		// static w klasie


struct osoba
{
	string imie, nazwisko;
	int wiek;
	//	osoba():wiek(-1){}
	osoba(const string & imie, const string & nazwisko, const int wiek) :imie(imie), nazwisko(nazwisko), wiek(wiek) {}
	friend ostream& operator<<(ostream &os, const osoba& cro) { return os << endl << cro.imie << ' ' << cro.nazwisko << ' ' << cro.wiek; }
};

struct Sum
{
	Sum() : sum{ 0 } { }
	void operator()(int n) { sum += n; ++iter; }
	int sum;
	int iter;
};


class schowek
{
	info *ptr; // gdy ==nullptr, to schowek jest pusty
public:
	schowek() :ptr(nullptr) {
		cout << "\nschowek()";
	}
	schowek(const info &crt) :ptr(new info(crt)) {
		cout << "\nschowek(const info &crt)";
	}
	~schowek() {
		cout << "\n~schowek()";
		delete ptr;
	}
	friend ostream& operator<<(ostream &os, const schowek& crs) {
		return crs.ptr ? os << *crs.ptr : os << " nullptr";
	}

	//TODO

	schowek(const schowek &crs) {
		cout << endl << "COPY constructor" << endl;
		ptr = crs.ptr;
	}

	schowek(schowek &&rrs) : ptr(rrs.ptr) {
		cout << endl << "Move constructor" << endl;
		rrs.ptr = nullptr;
	}

	schowek& operator=(const schowek &crs) {
		if (&crs == this)
			return *this;
		delete ptr;

 		ptr = new info;
		ptr = crs.ptr;

		return *this;
	}

	schowek& operator=(schowek &&rrs) {
		/*if (this != &rrs)
		{
			delete ptr;
			ptr = rrs.ptr;
			rrs.ptr = nullptr;
		}
		return *this;*/

		ptr = std::move(rrs.ptr);
		//std::cout << "move assigned\n";
		return *this;
	}

	//bool schowek::operator!=(const schowek& rhs) const
	//{
	//	return (ptr != rhs.ptr);
	//}
};


void zad1()
{
	info i1;
	schowek	si1(i1),
		si2,
		si3(i1),
		si4(si1),
		si5(move(si4));

	cout << endl << si1 << si2 << si3 << si4 << si5;

	cout << "\n\n zamiana s1-s2 z move(), przed " << si1 << si2 << si3;

	si3 = move(si2);
	si2 = move(si1);
	si1 = move(si3);

	cout << "\n\n zamiana s1-s2 bez move(), przed " << si1 << si2 << si3;

	si3 = si2;
	si2 = si1;
	si1 = si3;

	cout << "\n\n po zamianie " << si1 << si2 << si3;

	//TODO

}

void printVector(vector<osoba> vec) {
	for_each(vec.begin(), vec.end(), [](osoba const& o)
	{
		cout << o.imie << " " << o.wiek << endl;
	});
}

void zad2()
{
	vector<osoba> los;
	los.push_back(osoba("Jan", "Kowalski", 25));
	los.push_back(osoba("Tomek", "Kowalski", 5));
	los.push_back(osoba("Anna", "Kowalska", 20));
	los.push_back(osoba("Antoni", "Kowalski", 65));
	los.push_back(osoba("Onufry", "Kowalski", 99));
	los.push_back(osoba("Zosia", "Kowalska", 3));

	cout << "\n\n Lista osob:";
	for (auto const & p : los) cout << p;

	// odtąd bez deklarowania zmiennych typu iteratorowego (jawnie ani auto), bez for, z algorytmami i funkcjami lambda
	// użyj wartości iteratora zwracanej przez metody kontenera .begin(), .end() jako argumentów algorytmów

	cout << "\n\n Sortowanie wg wieku...";
	sort(begin(los), end(los), [](osoba a, osoba b) {return a.wiek < b.wiek; });

	cout << "\n\n Lista (imie i wiek):\n";
	printVector(los);

	cout << "\n\n Zwiekszenie wieku:";
	for_each(los.begin(), los.end(), [](osoba &o)
	{
		++o.wiek;
	});

	cout << "\n\n Lista:\n";
	printVector(los);

	cout << "\n\n Sredni wiek..."<<endl;
	int sum = 0;
	int size = los.size();
	for_each(los.begin(), los.end(), [&sum](osoba &o) {
		sum += o.wiek;
	});
	double average = sum / size;
	cout << "Sredni wiek to: " << average<<endl;

	cout << "\n\n Starsi od sredniej:"<<endl;
	for_each(los.begin(), los.end(), [&average](osoba &o) {
		if (o.wiek > average) {
			cout << o.imie + " " + o.nazwisko + " " << o.wiek<<endl;
		}
	});
}

int main()
{
	int checkleak = info::getcntr();
	zad1();
	if (checkleak != info::getcntr())
		cerr << "\n\n\tWYCIEK PAMIECI !!!\n";

	//zad2();
	return 0;
}