#define _CRT_SECURE_NO_WARNINGS // Позволяет использовать функцию strcpy
#include <iostream>
#include <cstring>

//
//template <typename T, const int rows, const int cols>
//class DynamicArray {
//private:
//	T val[rows][cols];
//public:
//	DynamicArray() { }
//
//	DynamicArray(T val, int rows, int cols) : rows(rows), cols(cols) {
//		this->** val = new int* [rows];
//		for (int i = 0; i < rows; i++) {
//			val[i] = new int[cols] {}; //присвоили длину строки
//		}
//		//возвращаем указатель на него
//	}
//
//	~DynamicArray() {
//		for (int i = 0; i < rows; i++) {
//			delete[] val[i];
//		}
//		delete[] val;
//	}
//
//	void setDynamicArray(T value, int rows, int cols) {
//		val[rows][cols] = value;
//	}
//
//	T getDynamicArray(int rows, int cols) {
//		return val[rows][cols];
//	}
//
//	friend std::ostream& operator<<(std::ostream& stream, const DynamicArray& val) {
//		for (int i = 0; i < rows; i++) {
//			for (int j = 0; j < cols; j++) {
//				stream << val[i][j] << " | ";
//			}
//			std::cout << std::endl;
//		}
//	}
//};


/*template <typename T>
class Array2D {
private:
	int rows;
	int cols;
	T** val;
public:
	Array2D(T argVal, int argRows, int argCols) : rows(artRows), cols(argCols) {
		val = new T * [rows];
		for (int i = 0; i < rows; i++) {
			val[i] = new T[cols]{}; */



//
const int MAX_STRING_SIZE = 100; // Максимальная длина для элементов карточки (как расширить до неограниченного?)
class Card
{
	struct MyStruct
	{
		MyStruct* next_;
		char name[MAX_STRING_SIZE];	// инициалы
		char pos[MAX_STRING_SIZE];	// название должности
		char inn[MAX_STRING_SIZE];	// инн
		unsigned short year; // год поступления
	};
	MyStruct* first_;
	int count_;	// количество хранящихся в данный момент карточек (выводится при запуске функции PrintAll
public:
	Card();	// конструктор без параметров
	~Card();	// деструктор
	void PrintAll(std::ostream&) const; // Выводит все карточки
	void AddNewCard(char*,char*,char*,unsigned short); // Добавляет новую карточку (без проверки)
	void Sort(); // Сортировка методом простых вставок		  ?
	void Find(unsigned short) const; // Поиск по году (зачисления) на работу
	void DeleteAll(); // Удаляет все карточки
	void minElement(std::ostream& stream); // Поиск минимального элемента (по году)
	void maxElement(std::ostream& stream); // Поиск максимального элемента (по году)

	// конструктор копирования и оператор присваивания запрещены к использованию
	Card(const Card&) = delete;
	Card& operator=(const Card&) = delete;
};

Card::Card() : // конструктор
	first_(nullptr),
	count_(0)
{}

Card::~Card() // деструтор
{
	MyStruct* current = first_;
	while (first_)
	{
		first_ = first_->next_;
		delete current;
		current = first_;
	}
}



void Card::PrintAll(std::ostream& stream) const
{
	MyStruct* current = first_;
	while (current)
	{
		stream << "name: " << current->name <<"\t pos: " << current->pos << "\t inn:"
			<< current->inn << "\t year: " << current->year << '\n';
		current = current->next_;
	}
	stream << "positions count: " << count_ << '\n';
}

void Card::AddNewCard(char* name, char* pos, char* inn, unsigned short year)
{
	// будем добавлять новые карточки в начало списка
	MyStruct* newCard = new MyStruct;
	// strcpy - функция из файла <cstring>;
	// копирует второй аргумент в первый
	std::strcpy(newCard->name, name);
	std::strcpy(newCard->pos, pos);
	std::strcpy(newCard->inn, inn);
	newCard->year = year;
	newCard->next_ = first_;
	first_ = newCard;
	count_++;
}

void Card::DeleteAll()
{
	MyStruct* current = first_;
	while (first_)
	{
		first_ = first_->next_;
		delete current;
		current = first_;
	}
	count_ = 0;
}

void Card::Sort()
{
	MyStruct* current_1 = first_;


	while(current_1)
	//for (MyStruct* current_1 = first_; current_1 < nullptr; current_1->next_)
	{
		MyStruct* current_2 = current_1->next_;
		while (current_2)
		//for (MyStruct* current_2 = current_1->next_; current_2 < nullptr; current_2->next_)
		{
			if (current_1->year > current_2->year)
			{
				std::swap(current_1->year, current_2->year);
				std::swap(current_1->pos, current_2->pos);
				std::swap(current_1->inn, current_2->inn);
				std::swap(current_1->name, current_2->name);
				break;
			}
			current_2 = current_2->next_;
		}
		current_1 = current_1->next_;
	}
}

			/*while (current_2)
			{
				if (current_2->year < current_1->year)
				{
					temp = current_2->year;
					*current_2->year = *current_1->year;
					*current_1->year = *temp;

				}
				current_2 = current_2->next_;
			}
			current_1 = current_1->next_;
			current_2 = current_1;*/


//char* Card::CheckElements(char* name, char* pos, char* inn, char* year)
//{
//	int i;
//	std::cout << name;
//	MyStruct* current = first_;
//	if (name[0] > 'A' and name[0] < 'Z') {}
//	else {return name;}
//	for (i=1; i<sizeof(name);i++)
//		if (name[i] > 'a' and name[i] < 'z') {}
//		else {return name;}
//	if (name[i + 1] != ' ') { return name; }
//	if (name[i + 2] < 'A' and 'Z' < name[i + 2]) { return name; }
//	if (name[i + 3] != '.') { return name; }
//	if (name[i + 4] < 'A' and 'Z' < name[i + 4]) { return name; }
//	if (name[i + 5] != '.') { return name; }
//	i = 0;
//	if (pos[i] < 'A' and pos[i] > 'Z') { return pos; }
//	for(i=1; i<sizeof(pos);i++)
//		if (name[i] < 'a' and name[i] > 'z') { return pos; }
//	int count_inn = 0;
//	for (i = 0; i < sizeof(inn); i++)
//	{
//		if (inn[i] > '9' and inn[i] < '0') { return inn; }
//		count_inn += 1;
//	}
//	if (sizeof(count_inn) != 10) { return inn; }
//	count_inn = 0;
//	for (i = 0; i < sizeof(year); i++)
//	{
//		if (inn[i] > '9' and inn[i] < '0') { return inn; }
//		count_inn += 1;
//	}
//	if (count_inn > 2020 and sizeof(count_inn) != 4) { return year; }
//
//}

void Card::Find(unsigned short year) const
{
	MyStruct* current = first_;
	while (current)
	{
		if (year == current->year)
		{
			std::cout << "name: \"" << current->name << "\", pos: " << current->pos << "\", inn: "
				<< current->inn << "\" year: " << current->year << '\n';
			break;
		}
		current = current->next_;
	}
}

void Card::minElement(std::ostream& stream)
{
	MyStruct* current = first_;
	unsigned short minYear = first_->year;
	char* minINN = first_->inn;
	char* minName = first_->name;
	char* minPOS = first_->pos;
	while (current)
	{
		if (current->year < minYear)
		{
			minYear = current->year;
			minINN = current->inn;
			minName = current->name;
			minPOS = current->pos;
		}
		current = current->next_;
	}
	stream << "Name: " << minName << "\t pos: " << minPOS << "\t inn:" << minINN << "\t year: " << minYear <<'\n';
}

void Card::maxElement(std::ostream& stream)
{
	MyStruct* current = first_;
	unsigned short maxYear = first_->year;
	char* maxINN = first_->inn;
	char* maxName = first_->name;
	char* maxPOS = first_->pos;
	while (current)
	{
		if (current->year > maxYear)
		{
			maxYear = current->year;
			maxINN = current->inn;
			maxName = current->name;
			maxPOS = current->pos;
		}
		current = current->next_;
	}
	stream << "Name: " << maxName << "\t pos: " << maxPOS << "\t inn:" << maxINN << "\t year: " << maxYear << '\n';
}

// функция для очистки потока ввода
void clearStream(std::istream& stream)
{
	stream.ignore(stream.rdbuf()->in_avail(), '\n');
}

void main()
{
	//const int rows = 1, cols = 2;
	//DynamicArray <int, rows, cols> arr;
	//arr.setDynamicArray(10, 20, 0);
	////arr.setDynamicArray(20, 30, 0);
	//arr.getDynamicArray(10, 20);



	setlocale(LC_ALL, "rus");
	// библиотека файлов
	Card prod;
	char name1[MAX_STRING_SIZE] = "Rin A.C.";
	char name2[MAX_STRING_SIZE] = "Vil T.U.";
	char name3[MAX_STRING_SIZE] = "Olya O.P.";
	char position1[MAX_STRING_SIZE] = "Meneger";
	char position2[MAX_STRING_SIZE] = "Directory";
	char position3[MAX_STRING_SIZE] = "Secretary";
	char inn1[MAX_STRING_SIZE] = "7685940302";
	char inn2[MAX_STRING_SIZE] = "1234567890";
	char inn3[MAX_STRING_SIZE] = "3344556677";
	unsigned short year1 = 2013;
	unsigned short year2 = 2003;
	unsigned short year3 = 2017;
	prod.AddNewCard(name1, position1, inn1, year1);
	prod.AddNewCard(name2, position2, inn2, year2);
	prod.AddNewCard(name3, position3, inn3, year3);
	/*программа иллюстрирующая работу с классом Card*/
	char tname_1[MAX_STRING_SIZE];
	char tname_2[MAX_STRING_SIZE];
	char tname_3[MAX_STRING_SIZE];
	unsigned short year;
	int n;
	do
	{
		std::cout << '\n';
		std::cout << "1 - Print all\n";
		std::cout << "2 - Find by year\n";
		std::cout << "3 - Find max element\n";
		std::cout << "4 - Find min element\n";
		std::cout << "5 - Add card\n";
		std::cout << "6 - Delete All \n";
		std::cout << "7 - Sort + Print All\n";
		std::cout << "0 - Exit\n";
		std::cout << '\n';
	std::cin >> n;
	switch (n)
	{
	case 1:
	{
		prod.PrintAll(std::cout);
		break;
	}
	case 2:
	{
		std::cout << "Year: ";
		clearStream(std::cin);			// очистка потока ввода
		std::cin>>(year);	// ввод названий с пробелами
		prod.Find(year);
		break;
	}
	case 3:
	{
		prod.maxElement(std::cout);
		break;
	}
	case 4:
	{
		prod.minElement(std::cout);
		break;
	}
	case 5:
	{
		std::cout << "name: ";
		clearStream(std::cin);			// очистка потока ввода
		std::cin.get(tname_1, MAX_STRING_SIZE);	// ввод названий с пробелами

		std::cout << "Position: ";
		clearStream(std::cin);			// очистка потока ввода
		std::cin.get(tname_2, MAX_STRING_SIZE);	// ввод названий с пробелами

		std::cout << "inn: ";
		clearStream(std::cin);			// очистка потока ввода
		std::cin.get(tname_3, MAX_STRING_SIZE);	// ввод названий с пробелами

		std::cout << "Year: ";
		clearStream(std::cin); // очистка потока ввода
		std::cin>>year; // ввод названий с пробелами
		prod.AddNewCard(tname_1, tname_2, tname_3, year);
		break;
	}
	case 6:
	{
		prod.DeleteAll();
		break;
	}
	case 7:
	{
		prod.Sort();
		prod.PrintAll(std::cout);
		break;
	}
	}
} while (n!= 0);
prod.DeleteAll();
}