#include "stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "STOS.h"
#include "DANE.h"

#pragma warning (disable : 4996)

extern int StringSize;
static STOS *ostatni = NULL;  //wskaznik do pierwszego elementu w kolejce
FreeData wsk_free_dane;           //Deklaracja wskaznika do funkcji typu FreeData

int licznik = 0;

Zwolnij ptrZwolnij;
Push ptrPush;
Druk ptrDruk;
Spr ptrSpr;
Zap ptrZap;
Czyt ptrCzyt;


void STOS_Init(FreeData pFreeDat, Zwolnij pZwolnij, Push pPush, Druk pDruk, Spr pSpr, Zap pZap, Czyt pCzyt) {
	ostatni = NULL;

	wsk_free_dane = pFreeDat;
	ptrZwolnij = pZwolnij;
	ptrPush = pPush;
	ptrDruk = pDruk;
	ptrSpr = pSpr;
	ptrZap = pZap;
	ptrCzyt = pCzyt;
}

void STOS_Free() {
	//Zwalniamy caly stos
	//Ustaliamy wskaznik p do ostatni
	STOS *p = ostatni, *ptempo = NULL;

	//pobieramy obiekty
	while (p) {
		//Zwalniamy dane dla biezacego elementu stosu, do ktorego wskazuje wskaznik p
		(*wsk_free_dane)(p->pData);

		//Przypisujemy adres biezacego elementu do pomocniczej zmiennej ptempo
		ptempo = p;

		//przestawiamy wskaznik p do nastepnego elementu stosu
		p = p->poprzedni;

		//zwalniamy biezacy element stosu
		free(ptempo);
	}

	ostatni = NULL;
}

STOS * STOS_Push(void *pdat) {
	//alokujemy pamiec dla nowego elementu stosu
	STOS *aktualny = (STOS *)malloc(sizeof(STOS));
	if (aktualny == NULL)
		return NULL;

	if (!ostatni)
		aktualny->poprzedni = NULL;
	//jeśli nie istnieje ostatni to aktualny jest jedynym elementem
	//czyli nie istnieje poprzedni element
	else
		aktualny->poprzedni = ostatni;
	//jeśli istnieje ostatni, to aktualny nie jest jedynym elementem
	//czyli przypisujemy do aktualny->poprzedni adres poprzedniego elementu

	//Ustawiamy pData
	aktualny->pData = pdat;

	ostatni = aktualny;
	licznik = licznik + 1;

	return ostatni;
}

STOS STOS_Pop() {
	STOS tempo;
	if (!ostatni) {
		//stos jest pusty
		tempo.pData = NULL;
		tempo.poprzedni = NULL;
	}
	else {
		//Pobieramy pierwszy element
		//poprzedni element powinien byc ostatni. Pobieramy jego adres.
		STOS *poprzedni = ostatni->poprzedni;

		//Pobieramy dane dla elementu ostatni.
		tempo.pData = ostatni->pData;

		//Nie jest to obowjazkowe
		tempo.poprzedni = NULL;

		//zwalniamy pamiec dla elementu ostatni
		free(ostatni);

		//przestawiamy ostatni do nastepnego elementu
		ostatni = poprzedni;
	}
	licznik = licznik - 1;

	return tempo;
}

void STOS_Search(void *pSearchDat, int krt) {

	static STOS *p;

	for (p = ostatni; p != NULL;) {
		//SF zadnego STUDENT_SPR w KONTENERZE byc nie powinno! Moga byc tylko wskazniki do funkcji, przez ktrore wywolamy
		//funkcji z obslugi danych
		if ((*ptrSpr)(p->pData, pSearchDat, krt) == 1) {
			(*ptrDruk)((STUDENT*)p->pData);  //SFD a to najlepiej wywolac z obslugi DANYCH lub z interfejsu.
		}
		p = p->poprzedni;
	}

}

FILE * OTWIERANIE_PLIKU_DO_ZAPISU(char *NAZWA_PLIKU) {
	return fopen(NAZWA_PLIKU, "wb");
}

FILE * OTWIERANIE_PLIKU_DO_ODCZYTU(char *NAZWA_PLIKU) {
	return fopen(NAZWA_PLIKU, "rb");
}

void STOS_ZAPIS_DO_PLIKU(char *NAZWA_PLIKU) {


	STOS *tempo = ostatni;
	FILE *PLIK = OTWIERANIE_PLIKU_DO_ZAPISU(NAZWA_PLIKU);
	fwrite(&licznik, sizeof(int), 1, PLIK);

	while (tempo != NULL) {
		//SF to samo
		(*ptrZap)((STUDENT*)tempo->pData, PLIK);
		tempo = tempo->poprzedni;
	}
	fclose(PLIK);
}



void *STOS_ODCZYT_Z_PLIKU(char *NAZWA_PLIKU) {
	int LicznikPozycji = sizeof(int);
	int it = 0;

	FILE *PLIK = OTWIERANIE_PLIKU_DO_ODCZYTU(NAZWA_PLIKU);
	fread(&it, sizeof(int), 1, PLIK);
	void *ptr = NULL;
	for (int i = 0; i < it; i++)
		STOS_Push(ptr);


	STOS *tmpWSK = ostatni;


	const int STALA = sizeof(int) + sizeof(KIERUNEK_STUDIOW);
	//SF to samo
	while (STUDENT *WSK = (STUDENT*)(*ptrCzyt)(PLIK, LicznikPozycji)) {
		if (WSK != NULL) {
			tmpWSK->pData = WSK;
			tmpWSK = tmpWSK->poprzedni;
			LicznikPozycji += (StringSize + STALA);
		}
	}

	fclose(PLIK);

	if (LicznikPozycji)
		return ostatni;
	else
		return NULL;
}