//zadanie E3_MJ
#include <iostream>
using namespace std;
class Item {
private:
	int m_value; // datova hodnota prvku zoznamu
	Item *m_next; // vazobny clen prvku zoznamu
public:
	/*int value();
	void next(Item*);
	Item*next();*/
	Item(int value, Item *ItemToLinkTo = NULL); // deklaracia parametrickeho konstruktora
	int value();  //clen. funk., ktora vrati datovu hodn. prvku zoznamu 'm_value'
	void next(Item *link);  //clenska funkcia, ktora vlozi do vazobneho clena prvku
	//zoznamu 'm_next' ukazovatel 'link'
	Item* next(); //clenska funkcia, ktora vrati hodnotu vazobneho clena prvku
	//zoznamu 'm_next': čo je ukazovateľ ukazujúci na nasledujúci dátový prvok.
};
class IntList {
private:
	void bumb_up();
	void bumb_down();
	//privatna clenska funkcia, ktora
	void bump_up() { ++m_size; } //zvacsi o 1 velkost zoznamu ulozenu v clenskej premennej 'm_size'
	void bump_down() { --m_size; } //zmensi o 1 velkost zoznamu ulozenu v clen. premennej 'm_size'
	// privatna clenska premenna -
	Item *m_front; // ukazovatel na prvy prvok zoznamu
	Item *m_end; // ukazovatel na posledny prvok zoznamu
	int m_size; // pocet prvkov zoznamu (jeho velkost)

public:
	// definicia konstruktora s inicializacnym zoznamom
	IntList() : m_front(NULL), m_end(NULL), m_size(0) {}
	// definicia explicitneho destruktora
	~IntList() {}/*Destruktor je v objektovém programování metoda, která je zavolána při likvidaci instance své třídy v paměti počítače.

	Při likvidaci instance třídy(objektu) by mělo dojít k uvolnění všech zdrojů, se kterými objekt pracoval.To může programátor zajistit právě pomocí destruktoru.Podobně jako lze pomocí konstruktoru zajistit alokaci prostředků při vytváření objektu.

		Destruktor nemá návratovou hodnotu a žádné parametry.Nemá - li třída destruktor, překladač vytvoří implicitní destruktor.
	// clenska funkcia, ktora vrati ukazovatel na 1. prvok zoznamu*/
	Item* front();
	void insert_order(int value); // vlozi 1 prvok s hodnotou 'value' do zoznamu USPORIADANE
	void display(); // clenska funkcia, ktora zobrazi datove hodnoty prvkov zoznamu na konzolu
	int number_of_divisible(int z);//funkcie zisti a vrati počet prvkov zoznamu, ktorých datove časti su delitelne parametrom z
	void display_divisible(int x);//funkcie najde a zobrazi na konzolu všetky prvky zoznamu ktorych datove časti su delitlene parametrom x
	//tiež zobrazi počet takýchto prvkov ktory zisti zavolani členskej funkcie intList::number of divisibe
	void reverse();//funkcia obrati poradie prvkov v linearnom jednosmernom zozname tzn povodne prvy prvok v zozname sa stane posledným
	//povodne druhy sa stane predposlednym atd.
};


int Item::value() { return m_value; } //clen. funk., ktora vrati datovu hodn. prvku zoznamu 'm_value'
void Item::next(Item *link) { this->m_next = link; } //clenska funkcia, ktora vlozi do vazobneho clena prvku
//zoznamu 'm_next' ukazovatel 'link'Putting it all together:
/*1) When we call simple.setID(2), the compiler actually calls setID(&simple, 2).
2) Inside setID(), the “this” pointer holds the address of object simple.
3) Any member variables inside setID() are prefixed with “this->”.So when we say m_id = id, the compiler is actually executing this->m_id = id, which in this case updates simple.m_id to id.
Item* Item::next() { return m_next; } //clenska funkcia, ktora vrati hodnotu vazobneho clena prvku
//zoznamu 'm_next'*/
Item* IntList::front() { return m_front; }


void IntList::insert_order(int value)
{
	Item *ptr = new Item(value); //vytvorenie ukazovatela 'ptr' na novy prvok zoznamu s hodnotou
	//datoveho clena 'value', ktory vkladame do tohto zoznamu USPORIADANE

	if (!m_front) //ak je zoznam prazdny,
		m_front = m_end = ptr; //tak novy prvok vkladame ako prvy do zoznamu,

	else //inak hladame vhodne miesto pre vlozenie prvku
	{
		Item *pred = NULL, *po = m_front;

		enum { HLADAJ, UKONCI } stav = HLADAJ; // premenna 'stav' je vymenovaneho typu
		//zväčší sa dátový počet prvkov o 1

		while ((stav == HLADAJ) && (po != 0))

			if (po->value() >= value)
				stav = UKONCI; // Vhodne miesto najdene!

			else // ak sa vhodne miesto pre vlozenie prvku nenaslo, tak sa presuvame dalej v zozname pri
			// jeho hladani
			{
				pred = po; // Ukazovatele "pred" a "po"

				po = po->next(); // si zapamataju miesto vlozenia.
			}
		if (pred == NULL) // Vlozenie noveho prvku na zaciatok zoznamu.
		{
			m_front = ptr;// m_front bude ukazovat nato naco ukazuje ptr
			ptr->next(po);//prvok na ktory ukazuje ptr bude ukazovat na m_dalsi prvku na ktory ukazuje po
		}
		else if (po == NULL) // Vlozenie noveho prvku na koniec zoznamu.
		{
			m_end->next(ptr);//vlozenie adresy ptr do vazobneho prvku m_next prvku na ktory ukazuje m_end, m_next(m_end ) bude ukazovat nato naco ukazuje prt

			ptr->next(NULL);//

			m_end = ptr;//
		}
		else // Vlozenie noveho prvku medzi prvky zoznamu,
		{ // na ktore teraz ukazuju ukazovatele 'pred' a 'po'
			pred->next(ptr);

			ptr->next(po);
		}
	}
	bump_up();
}



Item::Item(int value, Item *item) : m_value(value), m_next(NULL)

{
	/*if (!item) //ak je hodnota vazobn. clena prvku zoznamu (ukazovatela na nasledujuci prvok) == NULL,

			m_next = NULL; //tak potom inicializujeme instancnu premennu objektu tohto prvku zoznamu,
			//ukazovatel na nasledujuci prvok 'm_next', na NULL
		else
		{
			m_next = item->m_next;

			item->m_next = this;//tu skusime zmenu
		}
		*/
}

void IntList::display()
{
	cout << " (velkost " << m_size << ") ( ";
	Item *ptr = m_front;
	while (ptr)
	{
		cout << ptr->value() << " ";
		ptr = ptr->next();
	}
	cout << ")\n";
};

int IntList::number_of_divisible(int z)
{
	int pocet = 0;

	for (Item *ptr = front(); ptr != NULL; ptr = ptr->next())
	{
		if (ptr->value() % z == 0)
		{
			pocet++;
		}
	}
	return pocet;
};
void IntList::display_divisible(int x)
{
	cout << " (pocet " << number_of_divisible(x) << ") ( ";
	for (Item *ptr = front(); ptr != NULL; ptr = ptr->next())
	{
		if (ptr->value() % x == 0)
		{
			cout << ptr->value() << " ";
		}

	}
	cout << ")";
};
void IntList::reverse()
{
	Item *currently = m_front, *previous = NULL, *next = NULL;

	while (currently != NULL)
	{
		next = currently->next();//dalsi ukazuje nato naco ukazuje m_next prvka na ktory ukazuje aktualny

		currently->next(previous);//m_next prvku na ktory ukazuje aktualny bude ukazovat na prvok na ktory ukazuje predchadzajuci

		previous = currently; //bude ukazovat na prvok na ktory ukazuje aktualny

		currently = next; //dalsi bude ukazovat na prvok na ktory ukazuje aktualny
	}

	m_front = previous;
};

/* main_funktion
****************************************************/

int main()
{
	int m;
	int d;
	int cislo;
	int i;
	IntList list;
	cout << "Vlozte velkost zoznamu ktory chcete vytvarat:\t";
	cin >> m;
	cout << endl;
	cout << "vlozte " << m << " prvkov, ktore budu usporiadane vlozene do zoznamu" << endl;
	for (i = 0; i < m; i++)
	{
		cin >> cislo;
		list.insert_order(cislo);
	}
	cout << "Zoznam = ";
	list.display();
	cout << endl;
	cout << "akym cislom delitelne prvky chcete najst a zobrazit? " << endl;
	cout << "(ak chcete skoncit vlozte 0):";
	cin >> d;
	if (d != 0)
	{
		cout << "prvky zoznamu delitelne " << d << ":";
		list.display_divisible(d);
	}

	while (d != 0)
	{
		cout << "\nakym cislom delitelne prvky chcete najst a zobrazit? " << endl;
		cout << "(ak chcete skoncit vlozte 0):";
		cin >> d;
		if (d != 0)
		{
			cout << "prvky zoznamu delitelne " << d << ":";
			list.display_divisible(d);
		}
	}
	cout << "\n Reverzovany (otoceny zoznam Z1:)\n";
	list.reverse();
	list.display();
	return 0;








}