#include <stdio.h>  /* printf-nek */
#include <stdlib.h> /* Memóriakezelésnek */
#include <limits.h> /* Az INT_MAX-nak */


struct stack
{
	int elements;
	char* pData;
};
/* Általános megállapodások.
1. Ha a stack üres, a pData NULL, az elements 0.
2. Az pData mutat az elemek tömbjére, dinamikus memóriafoglalással.
3. Az elements jelzi az stackben lévo aktuális elemek számát.
4. A függvények karbantartják a dinamikus memóriaterületet
5. A stack használata elott a meg kell hívni a void stack_init(struct stack* s)-et.
6. A stack használata után meg kell hívni a void stack_cleanUp(struct stack* s)-t.
7. A függvények visszatérése hiba esetén nem nulla
*/

//3. feladat fv-e(fv túlterhelés)
void stack_init(struct stack &s, struct stack &theOther);

void stack_init(struct stack &s)
{
	/* Mivel alapértelmezésben a stack két változójának értékei véletlenszámok,
	   inicializálni kell oket. Üres stackkel indulunk.
	*/

	// 1. Az s.elements beállítása
	s.elements=0;
	
	// 2. Az s.pData beállítása
	s.pData=NULL;
	
}

void stack_init(struct stack &s, struct stack &theOther)
{
	char *ptrTemp;
	int i;

	ptrTemp=(char*)malloc(theOther.elements*sizeof(char));

	for(i=0;i<theOther.elements;i++)
	{
		ptrTemp[i]=theOther.pData[i];
	}

	s.elements=theOther.elements;
	s.pData=ptrTemp;
}

void stack_cleanUp(struct stack &s)
{
	/* Mivel dinamikus adatterülete foglalunk le, a stack használata után
	   fel kell szabadítani ezeket*/

	// 1. Az s.elements beállítása
	s.elements=0;
	

	// 2. Az s.pData felszabadítása, ha nem NULL
	if (s.pData) free(s.pData);
	

	// 3. Az s.pData értékének beállítása
	s.pData=NULL;
	
}

int stack_push(struct stack &s, char newElement)
{
	/* Itt új elemet fuzünk az s.pData végére. Ehhez lefoglalunk
	   eggyel nagyobb méretu helyet egy ideiglenes mutatóval, majd
	   átmásoljuk bele a s.pData eddigi tartalmát, hozzáfuzzük az
	   új elemet, és felszabadítjuk az eredeti s.pData területét.
	   Utána s.pDatat átirányítjuk az ideiglenes pointer által
	   mutatott területre.
   */

	// Az ideiglenes mutató
	char *ptrTemp;
	// Ciklusváltozó a másoláshoz
	int i;

	// 1. Ha az s.elements értéke INT_MAX, a stack betelt (különben túlcsordulás lenne)
	// Ilyenkor -1 hibával térünk vissza
	if (s.elements==INT_MAX) return -1;
	
	// 2. Eggyel nagyobb helyet foglalunk az ideiglenes pointer (ptrTemp) segítségével
	ptrTemp=(char*)malloc(((s.elements)+1)*sizeof(char));
	
	// 3. Egy for ciklussal átmásoljuk az s.pData tartalmát a ptrTemp által mutatott
	// területre.
	for(i=0;i<s.elements;i++)
	{
		ptrTemp[i]=s.pData[i];
	}	
	
	// 4. Az újonan foglalt terület végére rakjuk az új elemet (newElement)
	
	ptrTemp[s.elements]= newElement;
	// 5. Ha mutatott valahova elozoleg a pData, felszabadítjuk 
	if (s.pData) free(s.pData);
	
	// 6. Átállítjuk az s.pData pointert az újonnan lefoglalt területre (ptrTemp)
	s.pData=ptrTemp;

	// 7. Beállítjuk az elemszám (s.elements) új értékét
	s.elements++;

	return 0;
}

int stack_pop(struct stack &s)
{
	/* Ha nem üres a stack, kivesszük az utolsóként berakott elemet
	   a tömb végérol. Lefoglalunk eggyel kisebb tárhelyet, átmásoljuk
	   az adatokat, felszabadítjuk az eredetit. Ha kiürül a stack, 
	   a megállapodásnak megfeleloen állítjuk be az s truktúra adattagjait.*/
	
	// Az ideiglenes mutató és a visszatérési érték
	char *ptrTemp, value;
	// Ciklusváltozó a másoláshoz
	int i;

	// 1. Ha a stack üres -1-gyel visszatérünk
	if (s.elements==0) return -1;
	

	// 2. A value értéke az utolsóként betett elem, a tömb vége
	value=(s.pData[(s.elements)-1]);
	
	// 3. Az s.elements értékét beállítjuk az új szituációnak megfeleloen
	s.elements--;

	if(s.elements) // 4a. Ha a tömb ezzel nem lesz üres
	{
		// 4a1. Az ideiglenes pointer segítségével az új méretnek megfelelo
		// helyet foglalunk
		ptrTemp=(char*)malloc((s.elements)*sizeof(char));
	

		// 4a2. Átmásoljuk az ideiglenes területre a stackben maradt adatokat
		for (i=0;i<s.elements;i++)
		{
			ptrTemp[i]=s.pData[i];
		}
	

		// 4a3. Felszabadítjuk a régi memóriaterületet (s.pData)
		free(s.pData);
	
		// 4a4. Átállítjuk az s.pData pointert az újonnan lefoglalt területre (ptrTemp)
		s.pData=ptrTemp;
	
	}
	else // 4b. Ha a tömb ezzel üres lett
	{
		// 4b1. Felszabadítjuk az eddigi elemet
		free(s.pData);
	
		// 4b2. Beállítjuk az s.pData értékét (az elements már be lett állítva) 
		s.pData=NULL;
	}

	// 5. Visszatérünk a kivett elemmel (value)
	return value;
	
}

int stack_isEmpty(struct stack &s)
{
	/* Ha üres a stack, nullával tér vissza, egyébként nem. */
	if (s.elements==0) return 0;
	else return 1;
	
}

int main(void)
{
	struct stack s;
	struct stack theOther; //a másik verem
	int be; //getchar()-hoz (menü) kell
	char i;

	printf("STACK\n");
	printf("=====\n\n\n");
	printf("MENU\n");
	printf("----\n\n");
	printf("1. Stack inicializalasa(ures stack)\n");
	printf("2. Stack inicializalasa(masolas a theOther verembol)\n");
	printf("0. Kilepes a programbol\n\n");
	printf("A valasztasa: ");
	while ((be=getchar()) != 10)
	{
		if (be==48) return 0;
		else if (be==49)
		{
			printf("\nInitializing stack...\n");
			stack_init(s);
		}
		else if (be==50)
		{
	//////////////////////////////
	//theOther feltöltése az ABC betuivel foraditva//
	printf("\nInitializing stack(with 'theOther')...\n");
	int ellenoriz;
	for (i='Z';i>='A';i--)
	{
		printf("push: %c\n",i);
		ellenoriz=stack_push(theOther,i);
	}

	//Ellenöriznünk kell, hogy a stach_push rendben lezajlott-e.
	//Ha 0-t kapunk vissza, igen, különben nem, tehát kilépünk.
	if (ellenoriz!=0) 
	{printf("\n\nHiba tortent! A program futasa megszakad.");exit(-1);}
	//Ellenörzés vége
	printf("\nInitialization completed.\n\n");
	//theOther feltöltve//
	//////////////////////////////

	stack_init(s,theOther); //meghívjuk a túlterhelt init fv-t
		}
	else 
	{
		printf("\n\nHelytelen valsztas! A program futasa megszakad.\n");
		return 0;
	}

	} //Menü vége	

	for(i='A';i<='Z';i++)
	{		
		printf("push: %c\n",i);
		// Itt nézzük a s.pData változót debuggerbol, lépjünk bele a függvénybe
		stack_push(s,i);		
	}

	while(stack_isEmpty(s))
	{
		// Itt nézzük a s.pData változót debuggerbol, lépjünk bele a függvénybe
		printf("pop: %c\n",(char)stack_pop(s));
	}

	// Üres stackbol kivétel: hiba (-1)
	printf("pop: %d\n",stack_pop(s));
	
	printf("Cleaning up stack...\n");
	stack_cleanUp(s);
	return 0;
}