class Ailment
{
protected:
	std::string name;
	int sev;
	int time;
	int cont;
public:
	Ailment() = default;
	Ailment(const std::string& name, const int sev, const int time, const int cont);

	bool operator==(const Ailment& rhs) const;

	std::string get_name() const;

	int get_severity() const;

	int get_time_sensitivity() const;

	int get_contagiousness() const;
};

#include "Ailment.h"
#include "LinkedList.h"
#include <string>
#include <iostream>

class Patient
{
	std::string name_;
	LinkedList<Ailment> ailments_;

public:

	Patient(std::string name) : name_(std::move(name)) {}

	std::string get_name() const;

	void add_ailment(const Ailment& ailment);

	LinkedList<Ailment>& get_ailments();

	int get_score() const;

};

template <typename T>
class LinkedList
{
public:
	struct Node
	{
		Node* previous;
		Node* next;

		T data;
	};

protected:
	Node* begin_;
	Node* end_;

public:
	LinkedList() : begin_(nullptr), end_(nullptr) {}
	~LinkedList()
	{
		Node* node = begin();
		while(node)
		{
			Node* next = node->next;
			delete node;
			node = next;
		}
	}

	Node* begin() { return begin_; }
	Node const* cbegin() const { return begin_; }
	Node* end() { return end_; }

	void push_front(const T& item)
	{
		Node* node_front = new Node();
		node_front->data = item;

		//check if there is a node to link in-front of
		if (begin_ != nullptr)
		{
			begin_->previous = node_front;
			node_front->next = begin_;
		}
		else
		{
			end_ = node_front;
		}

		begin_ = node_front;
	}

	void push_back(const T& item)
	{
		Node* node_back = new Node();
		node_back->data = item;

		if (begin_ == nullptr && end_ == nullptr)
		{
			begin_ = node_back;
			end_ = node_back;
			return;
		}

		node_back->previous = end_;
		end_->next = node_back;

		end_ = node_back;
	}

	T pop_front()
	{
		if (begin_ == nullptr)
		{
			//todo: throw
			throw "";
		}

		Node* node = begin_;
		const T value = node->data;
		begin_ = node->next;

		return value;
	}

	T pop_back()
	{
		if (end_ == nullptr)
		{
			//todo: throw
			throw "";
		}

		Node* node = end_;
		const T value = node->data;
		end_ = node->previous;

		return value;
	}

	bool empty() const
	{
		return begin_ == nullptr;
	}

	size_t size() const
	{
		size_t counter = 0;

		Node* node = begin_;
		while (node != nullptr)
		{
			++counter;
			node = node->next;
		}

		return counter;
	}
};

template <typename T>
class PriorityQueue
{
	LinkedList<T> patients_;


	typename LinkedList<T>::Node* ptr;

public:
	PriorityQueue(): ptr(nullptr)
	{
	}

	int size();
	bool empty();

	void enqueue(const T& item)
	{
		typename LinkedList<T>::Node* node = new typename LinkedList<T>::Node();
		node->data = item;

		if(patients_.empty())
		{
			
		}

		typename LinkedList<T>::Node* left_node = patients_.begin();
		while(left_node && item < left_node->data)
		{
			left_node = left_node->next;
		}

		typename LinkedList<T>::Node* right_node = left_node->next;
		if(right_node)
		{
			right_node->previous = node;
		}
	}

	void dequeue(const T& item)
	{
		typename LinkedList<T>::Node* node = new typename LinkedList<T>::Node();

	}
};

template <typename T>
int PriorityQueue<T>::size()
{
	int counter = 0;

	typename LinkedList<T>::Node* node = new typename LinkedList<T>::Node();
	node = patients_.begin_;
	while (node != nullptr)
	{
		++counter;
		node = node->next;
	}

	return counter;
}

template <typename T>
bool PriorityQueue<T>::empty()
{
	return patients_.begin_ == nullptr;
}

#include "Patient.h"
#include "PriorityQueue.h"

#include<iostream>
#include<string>

PriorityQueue<Patient> queue;


void flush_buffer()
{
	while (getchar() != '\n');
}

int main(int argc, char* argv[])
{
	int user_selection;
	std::string name;
	std::string ailment;
	int severity = 0;
	int time_criticality = 0;
	int contagiousness = 0;

	while (user_selection != 0)
	{
		std::cout << "\nPlease Make A Selection:" << std::endl;

		std::cout << "1 - Add Patient" << std::endl;
		std::cout << "2 - Process Next Patient In Queue" << std::endl;
		std::cout << "3 - Display Queue" << std::endl;
		std::cout << "4 - View Processed Patients History" << std::endl;
		std::cout << "5 - Load Queue" << std::endl;
		std::cout << "6 - Save Queue" << std::endl;
		std::cout << "0 - Exit" << std::endl;
		std::cout << "\nSelection: ";
		std::cin >> user_selection;

		flush_buffer();

		switch(user_selection)
		{
		case 1:
			std::cout << "Enter patient name: ";
			std::getline(std::cin, name);

			do
			{
				std::cout << "\tEnter ailment (leave blank when done): ";
				std::getline(std::cin, ailment);
				if (ailment.empty())
				{
					break;
				}

				std::cout << "\tEnter severity: ";
				std::cin >> severity;

				std::cout << "\tEnter time criticality: ";
				std::cin >> time_criticality;

				std::cout << "\tEnter contagiousness: ";
				std::cin >> contagiousness;

				flush_buffer();


			} while (!ailment.empty());

			break;

		case 2:
			std::cout << " moved to patient room!" << std::endl;
			// Process patient with highest priority
			break;

		case 3:
			std::cout << "Patients In Queue:" << std::endl;
			// Display patient queue
			break;

		case 4:
			std::cout << "History:" << std::endl;
			// Display history of processed patients
			break;
	
		case 5:
			std::cout << "Enter path to file: ";
			// Load a .csv file
			break;

		case 6:
			std::cout << "Enter path to file: ";
			// Save to .csv file
			break;

		default: 
			std::cout<<"Invalid input. Please choose from the list provided.";
			break;
		}
	}
}