#include "liste.h"



void hinten_anfuegen(TListenKnoten*& anker, const int wert)
{
	TListenKnoten* neuer_eintrag = new TListenKnoten;
	neuer_eintrag->data = wert;
	neuer_eintrag->next = nullptr;
	neuer_eintrag->prev = nullptr;

	if (anker == nullptr)
		anker = neuer_eintrag;
	else
	{
		TListenKnoten* ptr = anker;
		while (ptr->next != nullptr)
		{
			ptr = ptr->next;
		}
		neuer_eintrag->prev = ptr;
		ptr->next = neuer_eintrag;
	}
}

string liste_als_string(TListenKnoten* anker)
{
	string resultat = "";
	if (anker == nullptr)
		return "Leere Liste.";
	else
	{
		resultat += "[ ";
		TListenKnoten* ptr = anker;
		do
		{
			resultat += std::to_string(ptr->data);
			if (ptr->next != nullptr) resultat += " , ";
			else resultat += " ";
			ptr = ptr->next;
		} while (ptr != nullptr);
		resultat += "]";
	}
	return resultat;
}

void liste_ausgeben(TListenKnoten* anker)
{
	cout << liste_als_string(anker) << endl;
}

void liste_ausgeben_rueckwaerts(TListenKnoten* anker)
{
	if (anker == nullptr)
	{
		cout << "Leere Liste" << endl;
	}
	else
	{
		/// greifen auf das letzte Block
		TListenKnoten* ptr = anker;
		do
		{
			if (ptr->next != nullptr)
			{
				ptr = ptr->next;
			}
		} while (ptr->next != nullptr);

		cout << "[ ";
		do
		{
			cout << ptr->data;
			if (ptr->prev != nullptr)
			{
				cout << " , ";
			}
			else
			{
				cout << " ";
			}
			ptr = ptr->prev;
		} while (ptr != nullptr);

		cout << "]" << endl;
	}
}

void in_liste_einfuegen(TListenKnoten*& anker, int wert_neu, int vor_wert)
{
	TListenKnoten* neuerEintrag = new TListenKnoten;
	TListenKnoten* zweiDavor = nullptr;

	neuerEintrag->data = wert_neu;
	neuerEintrag->next = nullptr;
	neuerEintrag->prev = nullptr;

	if (anker == nullptr)
	{
		anker = neuerEintrag;
	}
	else if (anker->data == vor_wert)
	{
		anker->prev = neuerEintrag;
		neuerEintrag->next = anker;
		anker = neuerEintrag;
	}
	else   ///durch die Liste laufen lassen
	{
		TListenKnoten* ptr = anker;
		int schonErsetz = 0;
		while (ptr->next != nullptr)
		{
			if (ptr->data == vor_wert)
			{
				zweiDavor = ptr->prev;
				neuerEintrag->prev = zweiDavor;
				neuerEintrag->next = ptr;
				ptr->prev = neuerEintrag;
				zweiDavor->next = neuerEintrag;
				schonErsetz++;
				break;
			}
			ptr = ptr->next;
		}

		if (ptr->next == nullptr && ptr->data == vor_wert)   // fuer das letzte Block
		{
			zweiDavor = ptr->prev;
			neuerEintrag->prev = zweiDavor;
			neuerEintrag->next = ptr;
			ptr->prev = neuerEintrag;
			zweiDavor->next = neuerEintrag;
			schonErsetz++;
		}

		if (ptr->next == nullptr && schonErsetz == 0)
		{
			ptr->next = neuerEintrag;
			neuerEintrag->prev = ptr;
		}
	}
}

void aus_liste_loeschen(TListenKnoten*& anker, int wert)
{
	TListenKnoten* bridge = nullptr;
	if (anker == nullptr)
	{

	}
	else if (anker->data == wert)
	{
		bridge = anker;
		anker = anker->next;
		delete bridge;
	}
	else
	{
		TListenKnoten* ptr = anker;
		TListenKnoten* davor = nullptr;
		TListenKnoten* danach = nullptr;

		while (ptr->next != nullptr)
		{
			if (ptr->data == wert)
			{
				davor = ptr->prev;
				danach = ptr->next;
				danach->prev = davor;
				davor->next = danach;
				delete ptr;
				ptr = nullptr;
				break;
			}
			ptr = ptr->next;
		}
	}
}

void liste_loeschen(TListenKnoten*& anker)
{
	TListenKnoten* ptr = anker;

	if (anker == nullptr)
	{

	}
	else
	{
		while (ptr->next != nullptr)
		{
			ptr = ptr->next;
		}

		while (anker != nullptr)
		{
			if (ptr->prev != nullptr)
			{
				if (ptr->prev == anker)
				{
					anker->next = nullptr;
				}
				TListenKnoten* wirdgeloescht = nullptr;
				wirdgeloescht = ptr;
				ptr = ptr->prev;
				delete wirdgeloescht;
			}
			else
			{
				anker = nullptr;
				delete ptr;
				ptr = nullptr;
			}
		}
	}
}