#ifndef SINGLY_LINKED_LIST_HPP
#define SINGLY_LINKED_LIST_HPP
#include <iostream>
#include "Node.hpp"
template<typename T>
	struct ListNode
	{
		T _data{0};
		ListNode* _next {nullptr};
	};

template<typename T>
struct SinglyLinkedList
{
	size_t _size {0};

	ListNode<T>* _head{ nullptr };

};

template<typename T>
inline bool Append(SinglyLinkedList<T>* list, ListNode<T>* node)
{
	if (list->_size == 0)
	{
		list->_head = node;
		list->_size++;
		return true;
	}
	ListNode<T>* TraverseNode = nullptr;
		for (TraverseNode = list->_head; TraverseNode->_next != nullptr;)
		{
			TraverseNode = TraverseNode->_next;
		}

	TraverseNode->_next = node;
	list->_size++;
	return true;
}

template<typename T>
inline bool Prepend(SinglyLinkedList<T>* list, ListNode<T>* node)
{
	if (list->_size == 0)
	{
		list->_head = node;
		list->_size++;
		return true;
	}
	node->_next = list->_head;
	list->_head = node;
	list->_size++;
	return true;
}

template<typename T>
inline bool RemoveFirst(SinglyLinkedList<T>* list)
{
	if (list->_size == 0)
	{
		std::cout << "Empty list... there is nothing to delete!" << std::endl;
		return true;
	}
	if (list->_size == 1)
	{
		list->_head =nullptr;
		list->_size--;
	}
	else 
	{
		ListNode<T>* Temp = list->_head;
		list->_head = list->_head->_next;
		Temp->_next = nullptr;
		list->_size--;
	}
	
	return true;
}

template<typename T>
inline bool RemoveLast(SinglyLinkedList<T>* list)
{
	if (list->_size == 0)
	{
		std::cout << "Empty list... there is nothing to delete!" << std::endl;
		return true;
	}
	if (list->_size == 1)
	{
		list->_head = nullptr;
		list->_size--;
		return true;
	}
	ListNode<T>* TraverseNode = list->_head;
	while (TraverseNode->_next->_next != nullptr)
	{
		TraverseNode = TraverseNode->_next;
	}
	TraverseNode->_next = nullptr;
	list->_size--;
	return true;
}

template <typename T>
inline bool InsertAfter(SinglyLinkedList<T>* List, const int Data, ListNode<T>* node)
{
	if (List->_head == nullptr)
	{
		Append(List, node);
		return true;
	}
	ListNode<T>* Traverse = List->_head;
	for (auto i = 1; i < Data && Traverse != nullptr; i++)
	{
		Traverse = Traverse->_next;
	}
	node->_next = Traverse->_next;
	
	Traverse->_next = node;
	List->_size++;
	
	return true;
}

template <typename T>
inline bool InsertBefore(SinglyLinkedList<T>* List, const int Data, ListNode<T>* node)
{
	if (List->_head == nullptr)
	{
		Append(List, node);
		return true;
	}
	ListNode<T>* Traverse = List->_head;
	ListNode<T>* Follower = nullptr;
	for (auto i = 1; i < Data && Traverse != nullptr; i++)
	{
		Follower = Traverse;
		Traverse = Traverse->_next;
	}
	node->_next = Follower->_next;
	Follower->_next = node;
	List->_size++;
	return true;
}

template <typename T>
inline bool Clear(SinglyLinkedList<T>* List)
{
	if (List->_size == 0)
	{
		return true;
	}
	if (List->_size == 1)
	{
		List->_head = nullptr;
		List->_size--;
		return true;
	}
	ListNode<T>* Traverse = List->_head;
	ListNode<T>* TempNode = Traverse;

	do
	{
		TempNode = Traverse;
		Traverse = Traverse->_next;
		TempNode->_data = 0;
		TempNode->_next = nullptr;
	} while (Traverse->_next != nullptr);
	
	List->_size = 0;
	List->_head = nullptr;
	return true;
}

template <typename T>
inline bool Empty(SinglyLinkedList<T>* List)
{
	return (List->_size == 0 && List->_head == nullptr);
}

template <typename T>
inline bool Remove(SinglyLinkedList<T>* List, ListNode<T>* node)
{

	ListNode<T>* Traverse = List->_head;
	ListNode<T>* Previous = nullptr;
	while (Traverse != node)
	{
		Previous = Traverse;
		Traverse = Traverse->_next;
	}
	if (Traverse == List->_head)
	{
		return RemoveFirst(List);
	}
	if (Traverse->_next == nullptr)
	{
		return RemoveLast(List);
	}

	Previous->_next = Traverse->_next;

	Traverse->_next = nullptr;
	Traverse->_data = 0;
	List->_size--;

	return true;
}


template <typename T>
inline ListNode<T>* Extract(SinglyLinkedList<T>* List, const int Data)
{
	ListNode<T>* Temp = new ListNode<T>{ 0, nullptr };

	ListNode<T>* Travel = nullptr;

	if (Empty(List))
	{
		std::cout << "Empty list, nothing to extract!" << std::endl;
		return Temp;

	}
	for (Travel = List->_head; Travel->_data != Data && Travel->_next != nullptr;)
	{
		Travel = Travel->_next;
	}
	Temp->_data = Travel->_data;

	if (Remove<T>(List, Travel))
	{
		return Temp;
	}

	return nullptr;
}


#endif