DPS.h

#pragma once

#include <iostream>
#include <vector>
#include <list>
using namespace std;

class DPSDataBase // áûâøåå äåðåâî, êîòîðîå ñòàëî áàçîé äàííûõ ïðàâîíàðóøåíèé ïî âñåì âîäèòåëÿì
{
public:

	// îïèñàíèå íàðóøåíèÿ ïðàâèë äîðîæíîãî äâèæåíèÿ
	class Violation 
	{
	public: // âîîáùå-òî ïî õîðîøåìó çäåñü äîëæíà áûòü ñåêöèÿ private!
		string article; // ñòàòüÿ ïðàâîíàðóøåíèÿ
		string name; // êîðîòêîå íàçâàíèå ïðàâîíàðóøåíèÿ
		string description; // ïîäðîáíîå îïèñàíèå ïðàâîíàðóøåíèÿ
		double penalty; // øòðàô â ãðí.
	public:
		// çäåñü áóäóò ãåòòåðû-ñåòòåðû, êîíñòðóêòîðû, äåñòðóêòîð

	};

	// êëàññ-àäàïòåð (îáîëî÷êà íàä ñòàíäàðòíûì STL-åâñêèì ñïèñêîì
	class ViolationList
	{
	public: // çäåñü äîëæåí áûòü ïðèâàò!
		//Violation first;
		//Violation second;
		//Violation third;

		//Violation* ar;
		//int violation_count;

		//Vector<Violation> list; // òàê ìîæíî ñäåëàòü, åñëè ãîòîâ êëàññ øàáëîííîãî âåêòîðà
		
		//ViolationVector list; // ýòî ñðàáîòàåò åñëè ïåðåäåëàòü âåêòîð èíòîâ â âåêòîð íàðóøåíèé

		//vector<Violation> list; // èñïîëüçóåì ñòàíäàðòíûé STL-âñêèé âåêòîð! ïî÷åìó áû è íåò, åñëè íàðóøåíèé áóäåò ìíîãî, è ê íèì íóæåí áûñòðûé ïðîèñçîëüíûé äîñòóï
	
		//SLL<Violation> list; // åñëè íàïèñàòü êàñòîìíûé øàáëîííûé êëàññ ñïèñîê
		
		//ViolationSLL list;

		list<Violation> list;

	public:
		void AddViolation(const Violation& v)
		{
			list.push_back(v);
		}

		void Print() const
		{
			for (auto v : list)
			{
				cout << v.name << "\n";
			}
		}
	};

	// êëàññ, êîòîðûé îïèñûâàåò ïàðó "êëþ÷-çíà÷åíèå"
	// îäèí îáúåêò òàêîãî òèïà - ýòî îäèí óçåë äåðåâà (à äåðåâî áóäåò ñàìîé áàçîé äàííûõ)
	class KeyValuePair
	{
	public: // äîëæåí áûòü private!!
		string car_number; // key
		ViolationList list; // value
	public:
		// ãåòòåðû ñåòòåðû êîíñòðóêòîðû äåñòðóêòîð - âñ¸ ýòî ìîæíî ñîçäàòü ðåøàðïåðîì èëè âèæóàë àññèñòîì íà 2 ìèíóòû!
	};

	// îïöèîíàëüíûé êëàññ (ìîæíî íå äåëàòü, åñëè ëåíü)
	class Person
	{
	public: // äîëæåí áûòü private!!
		string name;
		string surname;
	};

	class CarInfo
	{
	public: // äîëæåí áûòü private!!
		KeyValuePair info;
		Person driver;
		// îïöèîíàëüíî:
		// ïîëå, êîòîðîå îòâå÷àåò çà íîìåð ñòðàõîâîãî ïîëèñà
		// èíôîðìàöèÿ î ïðàâàõ âîäèòåëÿ (íîìåð ñåðèÿ ñðîê ãîäíîñòè)
		// èíôîðìàöèÿ î äîêóìåíòàõ íà àâòîìîáèëü
	};

	struct Node // one element of the DPSDataBase
	{
		CarInfo* value; // useful data

		Node* parent;
		Node* right;
		Node* left;

		void ShowNode()
		{
			cout << value->info.car_number << "\n";
			cout << value->driver.name << "\n";
			cout << value->driver.surname << "\n";
			value->info.list.Print();
			
		}
	};

	///////////////////////////////////

private:
	Node* root;
	// int count;

public:
	DPSDataBase()
	{
		root = nullptr;
	}

	bool IsEmpty()
	{
		return root == nullptr;
	}

	~DPSDataBase()
	{
		Clear();
	}

private:
	void ShowDPSDataBase(Node* elem)
	{
		if (elem != nullptr)
		{
			ShowDPSDataBase(elem->left);
			elem->ShowNode();
			ShowDPSDataBase(elem->right);
		}
	}

public:
	void ShowDPSDataBase()
	{
		cout << "\n";
		ShowDPSDataBase(root);
		cout << "\n";
	}

private:
	Node* GetRoot()
	{
		return root;
	}

	int GetCount(Node* elem, int count)
	{
		if (elem != nullptr)
		{
			count = GetCount(elem->left, count);
			count++; // 1
			count = GetCount(elem->right, count);
		}
		return count;
	}

public:
	int GetCount()
	{
		int count = 0;
		count = GetCount(root, count);
		return count;
	}

private:
	void Clear(Node* elem)
	{
		if (elem != nullptr)
		{
			Clear(elem->left);
			Clear(elem->right);
			delete elem;

			elem = nullptr;
		}
	}

public:
	void Clear()
	{
		if (!IsEmpty())
		{
			Clear(root);
			root = nullptr;
		}
	}

	// îäèí èç ìåòîäîâ ïîèñêà! èùåì òà÷êó ïî íîìåðó àâòîìîáèëÿ!
	// ìîæíî áóäåò ñäåëàòü åù¸ ýííîå êîëè÷åñòâî òàêèõ ìåòîäîâ - ñ ïîèñêîì ïî ôàìèëèè âîäèòåëÿ, èëè ïî êîíêðåòíîìó ïðàâîíàðóøåíèþ
	// FindNodesByDriver
	// FindNodesByViolation
	Node* FindNodeByCarNumber(const string& car_number)
	{
		if (IsEmpty())
			return nullptr;

		Node* f = root;
		while (true)
		{
			if (car_number < f->value->info.car_number)
			// äëÿ ïîèñêà ïî ôàìèëèè âîäèòåëÿ
			//if (driver_surname < f->value->driver.surname)
			// äëÿ ïîèñêà ïî êîíêðåòíîìó ïðàâîíàðóøåíèþ
			//if (violation < f->value->info.list[i])
			{
				if (f->left != nullptr)
					f = f->left;
				else
					break;
			}
			else if (car_number > f->value->info.car_number)
			{
				if (f->right != nullptr)
					f = f->right;
				else
					break;
			}
			else
				return f;
		}
		return nullptr;
	}

	/*void AddNode(int value)
	{
		if (FindNode(value))
			return;
		Node* n = new Node;
		n->right = n->left = nullptr;
		n->value = value;
		Node* parent = nullptr;
		if (IsEmpty())
		{
			root = n;
			root->parent = nullptr;
		}
		else
		{
			Node* p = root;
			while (p != nullptr)
			{
				parent = p;
				if (n->value > p->value)
					p = p->right;
				else
					p = p->left;
			}

			n->parent = parent;

			if (n->value < parent->value)
				parent->left = n;
			else
				parent->right = n;

		}
	}

	DPSDataBase& operator = (const DPSDataBase& obj)
	{
		if (!IsEmpty())
			Clear();

		AddNode(obj.root->value);
		Copy(obj.root);
		return *this;
	}

	DPSDataBase(const DPSDataBase& obj)
	{
		root = nullptr;
		AddNode(obj.root->value);
		Copy(obj.root);
	}

	void Copy(Node* elem)
	{
		if (elem->left != nullptr)
			AddNode(elem->left->value);
		if (elem->right != nullptr)
			AddNode(elem->right->value);
		if (elem->left != nullptr)
			Copy(elem->left);
		if (elem->right != nullptr)
			Copy(elem->right);
	}

	void DeleteNode(int value)
	{
		Node* d = FindNode(value);
		if (d == nullptr)
			return;

		Node* parent = d->parent;
		if (d == root && GetCount() == 1)
		{
			Clear();
			return;
		}
		if (d->left == nullptr && d->right == nullptr)
		{
			if (parent->left == d)
				parent->left = nullptr;
			else
				parent->right = nullptr;
			delete d;
			return;
		}
		if (d->left == nullptr && d->right != nullptr)
		{
			if (parent->left == d)
			{
				parent->left = d->right;
			}
			else
			{
				parent->right = d->right;

			}
			d->right->parent = parent;
			delete d;
			return;
		}

		if (d->left != nullptr && d->right == nullptr)
		{
			if (parent->left == d)
			{
				parent->left = d->left;
			}
			else
			{
				parent->right = d->left;

			}
			d->left->parent = parent;
			delete d;
			return;
		}
		if (d->left != nullptr && d->right != nullptr)
		{
			Node* r = d->right;
			if (r->right == nullptr && r->left == nullptr)
			{
				d->value = r->value;
				d->right = nullptr;
				delete r;
			}
			else if (r->left != nullptr)
			{
				Node* p = r->left;
				while (p->left != nullptr)
					p = p->left;
				d->value = p->value;
				if (p->right == nullptr)
					p->parent->left = nullptr;
				else
					p->parent->left = p->right;
				delete p;
			}
			else
			{
				d->value = r->value;
				d->right = r->right;
				delete r;
			}
		}
	} */
};