#include <iostream>
using namespace std;
#include <time.h>

// доделал класс студента, спасибо за подсказку

/*Реализовать класс Group, который работает с разреженным массивом
студентов (Student**). Обязательные поля: указатель на массив
студентов, количество человек в группе, название группы,
специализация группы, номер курса. Обязательные методы:
конструктор по умолчанию (пустая группа), конструктор с одним
параметром типа unsigned int (задаётся произвольное количество
студентов - предусмотреть автоматическую генерацию фамилий, имён,
возрастов и других данных), конструктор с параметром типа Group
(создаётся точная копия группы). Реализовать следующие методы:
показ всех студентов группы (сначала - название и специализация
группы, затем - порядковые номера, фамилии в алфавитном порядке и
имена студентов). Сделать методы добавления студента в группу,
редактирования данных о студенте и группе, слияния двух групп,
перевода студента из одной группы в другую, отчисления всех не
сдавших сессию студентов, отчисления одного самого неуспевающего
студента.*/

class Student
{
	char* name;
	char* surname;
	char* patronymic;
	char* adress;
	char* phone;
	int* marks = nullptr;
	int totalMarks = 0;
	int* coursework = nullptr;
	int totalCoursework = 0;
	int* exam = nullptr;
	int totalExam = 0;
	int rating = 0;
	int age;
public:
	Student(char* name, char* surname, char* patronymic)
	{
		SetAll(name, surname, patronymic);
	}
	Student(char* name, char* surname, char* patronymic, int age)
	{
		SetAll(name, surname, patronymic, age);
	}
	Student(char* name, char* surname, char* patronymic, int age, char* adress)
	{
		SetAll(name, surname, patronymic, age, adress);
	}
	Student(char* name, char* surname, char* patronymic, int age, char* adress, char* phone)
	{
		SetAll(name, surname, patronymic, age, adress, phone);
	}
	~Student()
	{
		delete[]name;
		delete[]surname;
		delete[]patronymic;
		delete[]adress;
		delete[]phone;
		delete[]marks;
		delete[]coursework;
		delete[]exam;

	}
	Student(const Student& original)
	{
		SetAll(original.name, original.surname, original.patronymic, original.age, original.adress, original.phone);
		delete[]marks;
		marks=CopyMarks(original.marks, original.totalMarks);
		delete[]coursework;
		coursework=CopyMarks(original.coursework, original.totalCoursework);
		delete[]exam;
		exam=CopyMarks(original.exam, original.totalExam);

		totalMarks = original.totalMarks;
		totalCoursework = original.totalCoursework;
		totalExam = original.totalExam;
		rating = original.rating;

	}

	void SetAdress(char* adress)
	{

		if (strlen(adress) < 3) return;

		delete[]this->adress;

		this->adress = new char[strlen(adress) + 1];
		strcpy_s(this->adress, strlen(adress) + 1, adress);
	}
	void SetPhone(char* phone)
	{

		if (strlen(phone) != 12) return;

		delete[] this->phone;
		this->phone = new char[strlen(phone) + 1];
		strcpy_s(this->phone, strlen(phone) + 1, phone);
	}
	void SetMark(int value)
	{
		SetMARK(this->marks, value, totalMarks);
	}
	void SetCoursework(int value)
	{
		SetMARK(this->coursework, value, totalCoursework);
	}
	void SetExam(int value)
	{
		SetMARK(this->exam, value, totalExam);
	}
	void ReSetMark(int value, int pos)
	{
		if (pos<0 || pos>totalMarks || value < 1 || value>12) return;
		this->marks[pos] = value;
		ResetRating();
	}
	void ReSetCoursework(int value, int pos)
	{
		if (pos<0 || pos>totalCoursework || value < 1 || value>12) return;
		this->coursework[pos] = value;
		ResetRating();
	}
	void ReSetExam(int value, int pos)
	{
		if (pos<0 || pos>totalExam || value < 1 || value>12) return;
		this->exam[pos] = value;
		ResetRating();
	}
	void PrintState()
	{
		cout << "Name: " << name << endl
			<< "Surname: " << surname << endl
			<< "Patronymic: " << patronymic << endl
			<< "Adress: " << adress << endl
			<< "Phone: " << phone << endl
			<< "Marks: ";

		if (totalMarks > 0)
		{
			for (int i = 0; i < totalMarks; i++)
			{
				cout.width(3);
				cout << marks[i];
			}
		}
		cout << endl
			<< "Courseworks: ";

		if (totalCoursework > 0)
		{
			for (int i = 0; i < totalCoursework; i++)
			{
				cout.width(3);
				cout << coursework[i];
			}
		}
		cout << endl
			<< "Exams: ";
		if (totalExam > 0)
		{
			for (int i = 0; i < totalExam; i++)
			{
				cout.width(3);
				cout << exam[i];
			}
		}
		cout << endl
			<< "Rating: " << rating << endl;
	}
	void BirthDay()
	{
		this->age++;
	}
	const char* const GetName() const
	{
		return name;
	}
	const char* const GetSurname() const
	{
		return surname;
	}
	const char* const GetPatronymic() const
	{
		return patronymic;
	}
	const int const GetAge()const
	{
		return age;
	}
	const char* const GetAdress() const
	{
		return adress;
	}
	const char* const GetPhone() const
	{
		return phone;
	}
	 int* GetMarksList()
	{
		int* temp;
		temp = CopyMarks(coursework, totalCoursework);
		return temp;

	}
	 int*  GetCourseworkList()
	{
		int* temp;
		temp = CopyMarks(coursework, totalCoursework);
		return temp;

	}
	 int* GetExamList()
	{
		int* temp;
		temp = CopyMarks(exam, totalExam);
		return temp;
	}
	const int const GetRating()const
	{
		return rating;
	}
	const int const GetTotalMarks()const
	{
		return totalMarks;
	}
	const int const GetTotalCoursework()const
	{
		return totalCoursework;
	}
	const int const GetTotalExams()const
	{
		return totalExam;
	}


private:
	//+1 :)
 	void SetField(char*& field, char* value)
	{
		if (strlen(value) < 3) throw "error";

		field = new char[strlen(value) + 1];
		strcpy_s(field, strlen(value) + 1, value);
	}

 	void SetAll(char*name, char*surname, char*patronymic, int age = 18, char*adress = "Unknown", char*phone = "Unknown")
	{
		SetField(this->name, name);
		SetField(this->surname, surname);
		SetField(this->patronymic, patronymic);
		SetField(this->adress, adress);
		SetField(this->phone, phone);

		SetAge(age);


	}
	int* CopyMarks( const int* OriginalField, const int totalMarks)
	{
		int* field = new int[totalMarks];
		for (int i = 0; i < totalMarks; i++)
			field[i] = OriginalField[i];
		return field;
	}
	void SetMARK(int*& originalField, int value, int& totalmrks)
	{
		if (value < 1 || value>12) return;

		int*temp = new int[totalmrks + 1];
		for (int i = 0; i < totalmrks; i++)
			temp[i] = originalField[i];
		temp[totalmrks] = value;
		totalmrks++;
		delete[]originalField;
		originalField = temp;
		ResetRating();

	}
	void ResetRating()
	{
		int midmark = 0;
		int midcourseworks = 0;
		int midexams = 0;

		if (totalMarks != 0)
		{
			for (int i = 0; i < totalMarks; i++)
				midmark += marks[i];
			midmark = midmark / totalMarks;
		}

		if (totalCoursework != 0)
		{
			for (int i = 0; i < totalCoursework; i++)
				midcourseworks += coursework[i];
			midcourseworks = midcourseworks / totalCoursework;
		}

		if (totalExam != 0)
		{
			for (int i = 0; i < totalExam; i++)
				midexams += exam[i];
			midexams = midexams / totalExam;
		}
		rating = ((midmark*0.2 + midcourseworks*0.3 + midexams*0.5) * 100) / 12;

	}
	void SetAge(int age)
	{
		if (age < 15 || age>55) this->age = 18;
		else this->age = age;
	}
};

class Group
{
	Student** students = nullptr;
	unsigned int GroupSize = 0;
	char* GroupName = nullptr;
	char* Specialization = nullptr;
	int course;

public:
	Group()
	{
		SetGroupName("Unnamed");
		SetSpecialization("Unnamed");
		this->course = 0;

	}
	Group(unsigned int size)
	{

		SetGroupName("Test");
		SetSpecialization("Programmers");
		this->course = 1;
		RandomizeStudents(size);
	}
	Group(const Group& original)
	{
	    SetGroupName(original.GroupName);
		SetSpecialization(original.Specialization);
		GroupSize = original.GroupSize;
		course = original.course;
		students = new Student*[original.GroupSize];
		for (int i = 0; i < original.GroupSize; i++)
		{
			 students[i] = new Student(*original.students[i]);

		}
	}
	~Group()
	{
	 	delete[]GroupName;
	 	delete[]Specialization;
	  	for (int i = 0; i < GroupSize; i++)
	  	{
			//  this->students[i]->~Student();
			  delete students[i];
 		}
	   	 delete[] students;

	}
	void AddStudent(char* name, char* surname, int age)
	{
		AddStudent(name, surname, "Unknown", age, "Unknown", "Unknown");
	}
	void AddStudent(char* name, char* surname, char* patronymic)
	{
		AddStudent(name, surname, patronymic, 18, "nullptr", "nullptr");
	}
	void AddStudent(char* name, char* surname, char* patronymic, int age)
	{
		AddStudent(name, surname, patronymic, age, "nullptr", "nullptr");
	}
	void AddStudent(char* name, char* surname, char* patronymic, int age, char* adress)
	{
		AddStudent(name, surname, patronymic, age, adress, "nullptr");
	}
	void AddStudent(char* name, char* surname, char* patronymic, int age, char* adress, char* phone)
	{
		Student** temp = new Student*[this->GroupSize + 1];

		for (int i = 0; i < this->GroupSize; i++)
			temp[i] = this->students[i];
		temp[this->GroupSize] = new Student(name, surname, patronymic, age, adress, phone);

		delete[]this->students;
		this->students = temp;
		this->GroupSize++;
		RestructGroup();
	}

	void DeleteStudent(int pos)
	{
		pos = pos - 1;
		Student** temp = new Student*[this->GroupSize + 1];
		for (int i = 0; i < pos; i++)
			temp[i] = this->students[i];
		for (int i = pos+1; i < this->GroupSize; i++)
		{
			temp[i-1] = this->students[i];
		}
		delete[]this->students;
		this->students = temp;
		this->GroupSize--;

	}
	void SetGroupName(char* GroupName)
	{
		if (strlen(GroupName) < 2) return;
		delete[]this->GroupName;
		this->GroupName = new char[strlen(GroupName) + 1];
		strcpy_s(this->GroupName, strlen(GroupName) + 1, GroupName);

	}
	void SetSpecialization(char* Specialization)
	{
		if (strlen(Specialization) < 2) return;
		delete[]this->Specialization;
		this->Specialization = new char[strlen(Specialization) + 1];
		strcpy_s(this->Specialization, strlen(Specialization) + 1, Specialization);
	}
	void SetCourse(int course)
	{
		if (course < 1 || course>6) return;
		this->course = course;
	}
	const char* const GetGroupName() const
	{
		return this->GroupName;
	}
	const char* const GetSpecialization() const
	{
		return this->Specialization;
	}
	const int const GetCourse() const
	{
		return this->course;
	}
	const int const GetGroupSize() const
	{
		return this->GroupSize;
	}
	void PrintGroupState()
	{
		cout << "GroupName: " << GroupName << endl
			<< "Specialization: " << Specialization << endl
			<< "Course: " << course << endl;
		for (int i = 0; i < GroupSize; i++)
		{
			cout << i + 1 << ": " << students[i]->GetSurname() << ' '
				<< students[i]->GetName() << ' '
				<< " Rating:" << students[i]->GetRating() << endl;
		}
		cout << endl;
	}
	void SetALLMarks(bool randomize = false)
	{
		SetMARK(0, randomize);
	}
	void SetALLCoursework(bool randomize = false)
	{
		SetMARK(1, randomize);
	}
	void SetALLExam(bool randomize = false)
	{
		SetMARK(2, randomize);
	}

	void PrintStudent(int pos)
	{
		this->students[pos-1]->PrintState();
		cout << endl;
	}

	static Group* IntegrationGroups(const Group* first, const Group* second)
	{
		if (first->GroupSize < 1 || second->GroupSize < 1)throw "Error :)";
		Group* temp = new Group;

		// думал через конструктор копирования полностью скопировать первую группу,
		// но по механике получается, что я скопирую всех студентов с первой группы
		// а потом буду либо добавлять по 1-му со второй или заново целиком пересоздавать
		// массив(с большим обьемом) и еще раз копировать... Пришел к выводу, что это
		// лишнии затраты вычислительной мощности(не стоит привыкать к расточительности)
		//temp = first;

		temp->SetGroupName(first->GroupName);
		temp->SetCourse(first->course);
		temp->SetSpecialization(first->Specialization);
		temp->GroupSize = first->GroupSize + second->GroupSize;
		temp->students = new Student*[temp->GroupSize];
		// копирование студентов первой группы
		for (int i = 0; i < first->GroupSize; i++)
			{
				temp->students[i] = new Student(*first->students[i]);

			}
		// копирование студентов второй группы
		for (int i = 0; i < second->GroupSize; i++)
		{
			temp->students[i + first->GroupSize] = new Student(*second->students[i]);
		}
		temp->RestructGroup();
	}

	void TransferStudent(Group* out, int PosStudent)
	{
		// решил сделать void и с 3 параметрами т.к. если сделать возвратное значние Group придется
		// пересоздавать группу, если Student то пользователь должен будет помнить какой параметр
		// возврящает функция и ее вписывать.
		// а так просто нужно из группы вызвать метод и вписать откуда
		/*
		AddStudent(out->students[PosStudent]->GetName(), out->students[PosStudent]->GetSurname(), out->students[PosStudent]->GetPatronymic(),
			out->students[PosStudent]->GetAge(), out->students[PosStudent]->GetAdress(), out->students[PosStudent]->GetPhone());
		//и еще несколько функций копирования оценок, но код ниже мне нравится больше
		*/

		Student** temp = new Student*[this->GroupSize + 1];
		for (int i = 0; i < this->GroupSize; i++)
			temp[i] = this->students[i];
		temp[this->GroupSize] = new Student(*out->students[PosStudent-1]);

		delete[]this->students;
		this->students = temp;
		this->GroupSize++;
		RestructGroup();
		out->DeleteStudent(PosStudent);

	}

	void DeductionIsNotPassedSession(int MinPassValue) // отсчет производится по экзаминационному листу
	{
		if (MinPassValue > 12 || MinPassValue < 1) throw "Error";

		for (int i = 0; i < GroupSize; i++)
		{
			cout << "Enter "<< i<<endl;

			if (students[i]->GetTotalExams() == 0)
			{
				DeleteStudent(i + 1);
				i--;
			}
			else
			{
				int * ExamList = students[i]->GetExamList();
				int AverageValue = 0;
				for (int j = 0; j < students[i]->GetTotalExams(); j++)
					AverageValue += ExamList[j];
				AverageValue = AverageValue / students[i]->GetTotalExams();
				if (AverageValue < MinPassValue)
				{
					DeleteStudent(i+1);
					i--;
				}
				delete[]ExamList;
			}

			this->PrintGroupState();
		}
	}
	void DeleteLaggingBehind()// расчет по рейтингу
	{
		int min=0;
		int tempvalue;
		for (int i = 0; i < GroupSize; i++)
		{
			tempvalue = students[i]->GetRating();
			if (students[min]->GetRating()>students[i]->GetRating())
				min = i;
		}
		DeleteStudent(min+1);
	}
private:

	void SetMARK(int choose, bool random)
	{
		int value;
		 	for (int i = 0; i < GroupSize; i++)
			{
				value = 0;
				if (random)
				{
					value = value = rand() % 11 + 1;
				}
				else
				{
					while (value < 1 || value>12);
					{
						cout << students[i]->GetSurname() << ' ' << students[i]->GetName() << " get: ";
						cin >> value;
					}
				}
				switch (choose)
				{
				case 0: students[i]->SetMark(value);
					break;
				case 1: students[i]->SetCoursework(value);
					break;
				case 2: students[i]->SetExam(value);
					break;

				}
			}
	}
	void RandomizeStudents(unsigned int size)
	{
		for (int i = 0; i < size; i++)
		{
			int age = rand() % 41 + 15;
			AddStudent(GetName(), GetSurname(), age);

		}
		SetALLMarks(true);
		SetALLMarks(true);
		 	}
	char* GetName()
	{

		int temp = rand() % 19;
		switch (temp)
		{
		case 0: return "Вася";
		case 1: return "Петя";
		case 2: return "Антон";
		case 3: return "Серега";
		case 4: return "Боря";
		case 5: return "Славик";
		case 6: return "НеЗнамаКто";
		case 7: return "Люда";
		case 8: return "Катя";
		case 9: return "Маша";
		case 10: return "Лариса";
		case 11: return "Юля";
		case 12: return "Марина";
		case 13: return "Василиса";
		case 14: return "Вишенко";
		case 15: return "КтоТО";
		case 16: return "Чип";
		case 17: return "Дейл";
		case 18: return "Незнайка";

		}
	}
	char* GetSurname()
	{
		int temp = rand() % 20;
		switch (temp)
		{
		case 0: return "Головастиков";
		case 1: return "Трюфель";
		case 2: return "Какашкинд";
		case 3: return "ХтоТУТ";
		case 4: return "Билайнер";
		case 5: return "Тампак";
		case 6: return "Абияк";
		case 7: return "Жижа";
		case 8: return "Жуйков";
		case 9: return "Бобрик";
		case 10: return "Голодняк";
		case 11: return "Заморило";
		case 12: return "Зябля";
		case 13: return "Лихобаба";
		case 14: return "Колотило";
		case 15: return "Кошмарик";
		case 16: return "Кукало";
		case 17: return "Недобой";
		case 18: return "Накидайло";
		case 19: return "Наливайка";
		}
	}
	void RestructGroup()
	{
		Student* temp;
		int value;
		int min;
		for (int i = 0; i < GroupSize; i++)
		{
			min = i;
			for (int j = i + 1; j < GroupSize; j++)
			{
				value = strcmp(students[min]->GetSurname(), students[j]->GetSurname());
				if (value > 0) min = j;
				if (value == 0)
				{
					value = strcmp(students[min]->GetName(), students[j]->GetName());
					if (value > 0) min = j;
				}

			}
			// косвенная проверка чтобы лишний раз не делать замену
			if (min != i)
			{
				temp = students[i];
				students[i] = students[min];
				students[min] = temp;
			}
		}

	}


};


void main()
{
	setlocale(0, "RU");
	srand(time(NULL));

 /*	Student* a = new Student("vasya", "surname", "patronymic");

	a->SetMark(12);
	a->SetCoursework(12);
	a->SetMark(12);
	a->PrintState();
	cout << endl;
	{
		cout << "Copy ctr\n";
		Student* B;
		B = a;
		B->PrintState();
	}
	cout << endl;
	a->PrintState();
	*/

	cout << "First:\n";
	 Group* a = new Group(10);

	 a->SetALLExam(true);
	 a->SetALLExam(true);
	 a->PrintGroupState();

	 /*
	 a->PrintStudent(1);
	  {
		  cout << "Copy ctr\n";
 		 Group* b = a;
		 b->PrintGroupState();
  	  }
	  cout << "original group \n";
	  a->PrintGroupState();
	  */

	 /*
	 cout << "Second:\n";
	 Group*b = new Group(3);
	 b->PrintGroupState();
	 cout << "Integration:\n";
	 {
		 Group* temp = new Group;
		 temp=Group::IntegrationGroups(a, b);
		 temp->PrintGroupState();
	 }
	 cout << "Original first:\n";
	 a->PrintGroupState();
	 a->TransferStudent(b, 2);
	 a->PrintGroupState();
	 b->PrintGroupState();
	 */



//	 a->DeductionIsNotPassedSession(6);
//	 a->PrintGroupState();

	 a->DeleteLaggingBehind();
	 a->PrintGroupState();

}