#include <stdio.h>
#include <stdlib.h>

// dopredna deklarace
typedef struct uzel uzel;

struct uzel
{
	// datove polozky
	float cislo1;
	float cislo2;
	// ukazatel na nasledujici prvek
	uzel* naslednik;
};

typedef struct
{
	uzel* zacatek;
	uzel* konec;
}
spojovy_seznam;

uzel* vytvor_prvek(float c1, float c2)
{
	// dynamicka alokace
	uzel* novy = malloc(sizeof(uzel));
	if (novy == NULL) {
		printf("chyba alokace\n");
		return NULL;
	}
	// zapis dat
	novy->cislo1 = c1;
	novy->cislo2 = c2;
	novy->naslednik = NULL;
	return novy;
}

void vloz_na_zacatek(spojovy_seznam* s, float c1, float c2)
{
	// napred zajistime, ze existuje specialni prvek
	if (s->zacatek == NULL) {
		// vytvorime specialni prvek
		uzel* novy = vytvor_prvek(0, 0);
		if (novy == NULL)
			return;
		// nastavime zacatek a konec
		s->zacatek = novy;
		s->konec = novy;
	}
	// pokracujeme jako pred tim...
	uzel* novy = vytvor_prvek(c1, c2);
	if (novy == NULL)
		return;
	// vlozeni do seznamu
	novy->naslednik = s->zacatek;
	s->zacatek = novy;
}

void vloz_na_konec(spojovy_seznam* s, float c1, float c2)
{
	if (s->zacatek == NULL) {
		vloz_na_zacatek(s, c1, c2);
	}
	else {
		// dynamicka alokace
		uzel* novy = vytvor_prvek(s->konec->cislo1, s->konec->cislo2);
		if (novy == NULL)
			return;
		// vlozeni do seznamu
		novy->naslednik = NULL;
		s->konec->naslednik = novy;
		// prepsat data
		s->konec->cislo1 = c1;
		s->konec->cislo2 = c2;
		// aktualizovat ukazatel na konec
		s->konec = novy;
	}
}

void vypis_seznam(spojovy_seznam s)
{
	uzel* aktualni = s.zacatek;
	while (aktualni != s.konec) {
		printf("%g, %g\n", aktualni->cislo1, aktualni->cislo2);
		aktualni = aktualni->naslednik;
	}
}

void zrus_seznam(spojovy_seznam* s)
{
	while (s->zacatek != NULL) {
		uzel* aktualni = s->zacatek;
		s->zacatek = aktualni->naslednik;
		free(aktualni);
	}
	s->konec = NULL;
}

uzel* najdi(spojovy_seznam s, float c)
{
	uzel* aktualni = s.zacatek;
	while (aktualni != s.konec) {
		if (aktualni->cislo1 == c)
			return aktualni;
			//break;
		aktualni = aktualni->naslednik;
	}
	return NULL;
	//return aktualni;
}

void vloz_za(uzel* u, float c1, float c2)
{
	// dynamicka alokace
	uzel* novy = vytvor_prvek(c1, c2);
	if (novy == NULL)
		return;
	// vlozeni do seznamu
	novy->naslednik = u->naslednik;
	u->naslednik = novy;
}

void vloz_pred(uzel* u, float c1, float c2)
{
	vloz_za(u, c1, c2);
	// vymenit hodnoty mezi u a jeho naslednikem
	u->naslednik->cislo1 = u->cislo1;
	u->naslednik->cislo2 = u->cislo2;
	u->cislo1 = c1;
	u->cislo2 = c2;
}

void smaz_uzel(spojovy_seznam* s, uzel* u)
{
	// prepsat hodnoty z naslednika do u
	u->cislo1 = u->naslednik->cislo1;
	u->cislo2 = u->naslednik->cislo2;
	// zapamatovani si prvku
	uzel* puvodni_naslednik = u->naslednik;
	// prepiseme ukazatele
	u->naslednik = u->naslednik->naslednik;
	// dealokace
	free(puvodni_naslednik);
	// aktualizace seznamu
	if (puvodni_naslednik == s->konec)
		s->konec = u;
}

int main()
{
	spojovy_seznam s;
	s.zacatek = NULL;
	s.konec = NULL;

	vloz_na_konec(&s, 3, 3);
	vloz_na_zacatek(&s, 0, 0);
	vloz_na_zacatek(&s, 1, 0);
	vloz_na_zacatek(&s, 2, 0);
	vloz_na_konec(&s, 4, 4);

	// hledani prvku
	float cislo = 2;
	uzel* u = najdi(s, cislo);
	if (u != NULL) {
		printf("nalezeno: %g, %g\n", u->cislo1, u->cislo2);
	}
	else {
		printf("V seznamu neni prvek s prvnim cislem rovnym %g.\n", cislo);
	}

	// vlozeni za nalezeny prvek
	vloz_za(u, 5, 5);
	// vlozeni pred nalezeny prvek
	vloz_pred(u, 6, 6);
	// smazani prvku
	u = najdi(s, cislo);
	smaz_uzel(&s, u);

	vypis_seznam(s);
	zrus_seznam(&s);
	vypis_seznam(s);

	return 0;
}