using DepartmentBusinessLogic.BindingModels;
using DepartmentBusinessLogic.Enums;
using DepartmentBusinessLogic.HelperModels;
using DepartmentBusinessLogic.Interfaces;
using DepartmentBusinessLogic.ViewModels;
using ModuleTools.BusinessLogics;
using ModuleTools.Enums;
using ModuleTools.Extensions;
using SecurityBusinessLogic.BindingModels;
using SecurityBusinessLogic.BusinessLogics;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

namespace DepartmentBusinessLogic.BusinessLogics
{
	/// <summary>
	/// Логика работы с историями синхронизации приказов
	/// </summary>
	public class OrderSyncHistoryBusinessLogic : GenericBusinessLogic<OrderSyncHistoryGetBindingModel, OrderSyncHistorySetBindingModel, OrderSyncHistoryListViewModel, OrderSyncHistoryViewModel>
	{
		private OrderSyncHistoryRecordBusinessLogic _recordLogic;

		private EnviromentSettingBusinessLogic _enviromentSettingLogic;

		private StudentGroupBusinessLogic _groupsLogic;

		private StudentBusinessLogic _studentLogic;

		private UserBusinessLogic _userLogic;

		private OrderBusinessLogic _orderLogic;

		private OrderStudentRecordBusinessLogic _orderStudentRecordLogic;

		public OrderSyncHistoryBusinessLogic(IOrderSyncHistoryService service) : base(service, "Синхронизация Приказов", AccessOperation.СинхронизацияПриказов) { }

		public async Task<bool> SyncOrders()
		{
			var history = await CreateAsync(new OrderSyncHistorySetBindingModel { SyncDate = DateTime.Now });
			if (history == null)
			{
				Errors.Add(("Ошибка создание истории", "Не удалось создать историю"));
				return false;
			}

			_recordLogic = DependencyManager.Instance.Resolve<OrderSyncHistoryRecordBusinessLogic>();
			_enviromentSettingLogic = DependencyManager.Instance.Resolve<EnviromentSettingBusinessLogic>();
			_groupsLogic = DependencyManager.Instance.Resolve<StudentGroupBusinessLogic>();
			_studentLogic = DependencyManager.Instance.Resolve<StudentBusinessLogic>();
			_orderLogic = DependencyManager.Instance.Resolve<OrderBusinessLogic>();
			_orderStudentRecordLogic = DependencyManager.Instance.Resolve<OrderStudentRecordBusinessLogic>();
			_userLogic = DependencyManager.Instance.Resolve<UserBusinessLogic>();

			var address = (await _enviromentSettingLogic.GetListAsync(new EnviromentSettingGetBindingModel { Key = "SyncStudentOrderIpAddress" }))?.List?.FirstOrDefault();
			if (address == null || address.Value.IsEmpty())
			{
				Errors = _enviromentSettingLogic.Errors;
				Errors.Add(("Ошибка получения данных", "Не удалось получить адрес серверая для получения приказов по студентам"));
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
				});
				return false;
			}

			var username = (await _enviromentSettingLogic.GetListAsync(new EnviromentSettingGetBindingModel { Key = "SyncStudentOrderUserName" }))?.List?.FirstOrDefault();
			if (username == null || username.Value.IsEmpty())
			{
				Errors = _enviromentSettingLogic.Errors;
				Errors.Add(("Ошибка получения данных", "Не удалось получить имя пользователя для получения приказов по студентам"));
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
				});
				return false;
			}

			var password = (await _enviromentSettingLogic.GetListAsync(new EnviromentSettingGetBindingModel { Key = "SyncStudentOrderPassword" }))?.List?.FirstOrDefault();
			if (password == null || password.Value.IsEmpty())
			{
				Errors = _enviromentSettingLogic.Errors;
				Errors.Add(("Ошибка получения данных", "Не удалось получить пароль для получения приказов по студентам"));
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
				});
				return false;
			}

			var client = new HttpClient
			{
				BaseAddress = new Uri(address.Value)
			};
			client.DefaultRequestHeaders.Accept.Clear();
			client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
			client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username.Value}:{password.Value}")));

			// авторизация

			// получение списка студентов
			HttpResponseMessage response = await client.GetAsync($"{address.Value}/univer_Testing/hs/Ulstu_StudentsInfo/v1/GetCurrentStudentsOfDepartment");
			if (!response.IsSuccessStatusCode)
			{
				Errors.Add(("Ошибка получения данных", "Не удалось получить список студентов с сервера"));
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
				});
				return false;
			}
			var studentFromServer = JsonSerializer.Deserialize<StudentListSyncModel>(response.Content.ReadAsStringAsync().Result);
			if (studentFromServer.CurrentStudentsList.Count == 0)
			{
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = "Полученный список студентов пустой"
				});
				return true;
			}

			var groups = await _groupsLogic.GetListAsync(new StudentGroupGetBindingModel());
			if (groups == null || groups.List == null)
			{
				Errors = _groupsLogic.Errors;
				Errors.Add(("Ошибка получения данных", "Не удалось получить список групп"));
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
				});
				return false;
			}

			var students = await _studentLogic.GetListAsync(new StudentGetBindingModel());
			if (students == null || students.List == null)
			{
				Errors = _studentLogic.Errors;
				Errors.Add(("Ошибка получения данных", "Не удалось получить список студентов"));
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
				});
				return false;
			}

			foreach (var student in students.List)
			{
				var studentSync = studentFromServer.CurrentStudentsList.FirstOrDefault(x => x.recordBookName == student.NumberOfBook);
				// студент не найден, значит он ушел с кафедры, выясняем почему
				if (studentSync == null)
				{
					await SyncStudentOrders(history, student, groups.List, client, address.Value);
				}
				// не совпадение групп
				else if (student.StudentGroupName != studentSync.groupName)
				{
					await SyncStudentOrders(history, student, groups.List, client, address.Value);
				}

				studentFromServer.CurrentStudentsList.Remove(studentSync);
			}
			// новые студенты и восстановленцы
			foreach (var student in studentFromServer.CurrentStudentsList)
			{
				var deletedStudent = await _studentLogic.GetElementAsync(new StudentGetBindingModel { NumberOfBook = student.recordBookName });
				if (deletedStudent == null && _studentLogic.Errors.FirstOrDefault(x => x.Message == "Элемент удален") != default)
				{
					// восстановленец
					deletedStudent = await _studentLogic.RestoreAsync(new StudentGetBindingModel { NumberOfBook = student.recordBookName });
					if (deletedStudent == null)
					{
						var errors = _studentLogic.Errors;
						errors.Add(("Ошибка при восстановлении студента", $"Не удалось восстановить студента {student.lastName} {student.firstName} {student.patronymicName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					var deletedUser = await _userLogic.RestoreAsync(new UserGetBindingModel { Id = deletedStudent.UserId });
					if (deletedUser == null)
					{
						var errors = _userLogic.Errors;
						errors.Add(("Ошибка при восстановлении пользователя студента", $"Не удалось восстановить пользователя студента {student.lastName} {student.firstName} {student.patronymicName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					await SyncStudentOrders(history, deletedStudent, groups.List, client, address.Value);
					continue;
				}

				var userName = $"{student.lastName}{(student.firstName.IsNotEmpty() ? $" {student.firstName[0]}." : string.Empty)}{(student.patronymicName.IsNotEmpty() ? $"{student.patronymicName[0]}." : string.Empty)}";
				var result = await _userLogic.GetListAsync(new UserGetBindingModel { UserNameForSearch = userName });

				var newuser = await _userLogic.CreateAsync(new UserSetBindingModel
				{
					Login = userName,
					Password = student.recordBookName
				});
				if (newuser == null)
				{
					var errors = _userLogic.Errors;
					errors.Add(("Ошибка создания пользователя под студента", $"Не удалось создать пользователя под студента {student.lastName} {student.firstName} {student.patronymicName}"));
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
					});
					continue;
				}

				var newStudent = await _studentLogic.CreateAsync(new StudentSetBindingModel
				{
					Iduniv = student.iduniv,
					NumberOfBook = student.recordBookName,
					UserId = newuser.Id,
					FirstName = student.firstName,
					LastName = student.lastName,
					Patronymic = student.patronymicName,
					StudentState = StudentState.Неопределен,
					Description = student.presenatationOfRecordBook
				});

				if (newStudent == null)
				{
					var errors = _studentLogic.Errors;
					errors.Add(("Ошибка добавления студента", $"Не удалось добавить студента {student.lastName} {student.firstName} {student.patronymicName}"));
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
					});
					continue;
				}

				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = $"Добавлен студент {newStudent}"
				});

				await SyncStudentOrders(history, newStudent, groups.List, client, address.Value);

				studentFromServer.CurrentStudentsList.Remove(student);
			}

			return true;
		}

		/// <summary>
		/// Синхронизация приказов по студенту
		/// </summary>
		/// <param name="history"></param>
		/// <param name="student"></param>
		/// <param name="groups"></param>
		/// <param name="client"></param>
		/// <param name="address"></param>
		/// <returns></returns>
		private async Task SyncStudentOrders(OrderSyncHistoryViewModel history, StudentViewModel student, List<StudentGroupViewModel> groups, HttpClient client, string address)
		{
			HttpResponseMessage response = await client.GetAsync($"{address}/univer_Testing/hs/Ulstu_StudentsInfo/v1/GetStudentOrdersByIdAndRecordBook?iduniv={student.Iduniv}&recordBookName={student.NumberOfBook}&allOrders=sppd");
			if (!response.IsSuccessStatusCode)
			{
				Errors.Add(("Ошибка получения данных", "Не удалось получить список приказов по студенту"));
				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
				});
				return;
			}
			var syncOrders = JsonSerializer.Deserialize<StudentOrderListSyncModel>(response.Content.ReadAsStringAsync().Result);
			foreach (var syncOrder in syncOrders.StudentOrders)
			{
				var orderType = GetOrderType(syncOrder.orderSubTypeName);

				// пропускаем приказы, которые нас не интересуют
				if (orderType == OrderType.Неопределено)
				{
					continue;
				}

				// пытаемся найти приказ
				var order = await _orderLogic.GetElementAsync(new OrderGetBindingModel
				{
					OrderNumber = syncOrder.clericNumber,
					OrderDate = Convert.ToDateTime(syncOrder.clericDate)
				});
				if (order == null)
				{
					// если не нашли - пытаемся создать
					order = await _orderLogic.CreateAsync(new OrderSetBindingModel
					{
						OrderNumber = syncOrder.clericNumber,
						OrderDate = Convert.ToDateTime(syncOrder.clericDate),
						OrderType = orderType
					});
					if (order == null)
					{
						var errors = _orderLogic.Errors;
						errors.Add(("Ошибка добавления приказа", $"Не удалось добавить приказ {syncOrder.clericNumber} {syncOrder.clericDate}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
				}

				// ищем в приказе запись по студенту
				var studentOrder = await _orderStudentRecordLogic.GetElementAsync(new OrderStudentRecordGetBindingModel
				{
					OrderId = order.Id,
					StudentId = student.Id
				});

				// если такой приказ по студенту уже есть, просто пропускаем
				if (studentOrder != null)
				{
					continue;
				}

				Guid? studentGroupFromId = null;
				Guid? studentGroupToId = null;
				string info = string.Empty;
				if (syncOrder.groupNameBefore.IsNotEmpty())
				{
					studentGroupFromId = groups.FirstOrDefault(x => x.ToString() == syncOrder.groupNameBefore)?.Id;
				}
				if (syncOrder.groupNameAfter.IsNotEmpty())
				{
					studentGroupToId = groups.FirstOrDefault(x => x.ToString() == syncOrder.groupNameAfter)?.Id;
				}
				// если был переведенец к нам, то игнорируем приказы, не связанные с нашими группами
				if (!studentGroupFromId.HasValue && !studentGroupToId.HasValue)
				{
					continue;
				}
				OrderStudentMoveType orderStudentMoveType = OrderStudentMoveType.Неопределено;

				switch (syncOrder.orderTypeName)
				{
					case "Перевод":
						if (syncOrder.orderSubTypeName == "Распределение по группам")
						{
							orderStudentMoveType = OrderStudentMoveType.Распределение;
							info = $"Распределение студента {student} в группу {groups.First(x => x.Id == studentGroupToId)}";
						}
						// внутренний перевод
						else if (studentGroupFromId.HasValue && studentGroupToId.HasValue)
						{
							orderStudentMoveType = OrderStudentMoveType.ПереводВГруппу;
							info = $"Перевод студента {student} из группы {groups.First(x => x.Id == studentGroupFromId)} в группу {groups.First(x => x.Id == studentGroupToId)}";
						}
						else if (!studentGroupFromId.HasValue && studentGroupToId.HasValue)
						{
							orderStudentMoveType = OrderStudentMoveType.ЗачислитьПоПереводу;
							info = $"Зачисление переовдом студента {student} в группу {groups.First(x => x.Id == studentGroupToId)}";
						}
						else if (studentGroupFromId.HasValue && !studentGroupToId.HasValue)
						{
							orderStudentMoveType = OrderStudentMoveType.ОтчислитьВСвязиСПереводом;
							info = $"Отчисление студента {student} из группы {groups.First(x => x.Id == studentGroupFromId)} в связи с переводом";
						}
						break;
					case "Зачисление в вуз вне приемной кампании":
						orderStudentMoveType = OrderStudentMoveType.Зачисление;
						info = $"Зачисление студента {student}";
						break;
					case "Перевод на следующий курс":
						orderStudentMoveType = OrderStudentMoveType.ПереводНаКурс;
						info = $"Перевод студента {student} из группы {groups.First(x => x.Id == studentGroupFromId)} на следующий курс в группу {groups.First(x => x.Id == studentGroupToId)}";
						break;
					case "Уход в академический отпуск":
						orderStudentMoveType = OrderStudentMoveType.ВАкадем;
						info = $"Уход в АО студента {student} из группы {groups.First(x => x.Id == studentGroupFromId)}";
						break;
					case "Продление академического отпуска":
						orderStudentMoveType = OrderStudentMoveType.ПродлАкадем;
						info = $"Продление АО студента {student}";
						break;
					case "Восстановление из академического отпуска":
						orderStudentMoveType = OrderStudentMoveType.ИзАкадема;
						info = $"Выход из АО студента {student} в группу {groups.First(x => x.Id == studentGroupToId)}";
						break;
					case "Восстановление": // уточнить приказ
						orderStudentMoveType = OrderStudentMoveType.Восстановить;
						info = $"Восстановление отчисленного студента {student} в группу {groups.First(x => x.Id == studentGroupToId)}";
						break;
					case "Отчисление по собственному": // уточнить приказ
						orderStudentMoveType = OrderStudentMoveType.ОтчислитьПоСобственному;
						info = $"Отчисление студента {student} из группы {groups.First(x => x.Id == studentGroupFromId)} по собственному желанию";
						break;
					case "Отчисление за неуспеваемость": // уточнить приказ
						orderStudentMoveType = OrderStudentMoveType.ОтчислитьПоСобственному;
						info = $"Отчисление студента {student} из группы {groups.First(x => x.Id == studentGroupFromId)} за неуспеваемость";
						break;
					case "Отчисление по невыходу из академа": // уточнить приказ
						orderStudentMoveType = OrderStudentMoveType.ОтчислитьПоСобственному;
						info = $"Отчисление студента {student} по невыходу из академа";
						break;
					case "Хавершение обучения": // уточнить приказ
						orderStudentMoveType = OrderStudentMoveType.ОтчислитьПоСобственному;
						info = $"Отчисление студента {student} в связи с окончанием обучения";
						break;
				}

				if (orderStudentMoveType == OrderStudentMoveType.Неопределено)
				{
					continue;
				}

				// создаем, если не нашли
				studentOrder = await _orderStudentRecordLogic.CreateAsync(new OrderStudentRecordSetBindingModel
				{
					OrderId = order.Id,
					StudentId = student.Id,
					Info = info,
					OrderStudentMoveType = orderStudentMoveType,
					StudentGroupFromId = studentGroupFromId,
					StudentGroupToId = studentGroupToId
				});
				if (studentOrder == null)
				{
					var errors = _orderStudentRecordLogic.Errors;
					errors.Add(("Ошибка добавления записи приказа по студенту", $"Не удалось добавить запись приказа {syncOrder.orderSubTypeName} по студенту {student}"));
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
					});
					continue;
				}

				var st = Mapper.MapToClass<StudentViewModel, StudentSetBindingModel>(student, true);
				var studentName = student.ToString();
				if (student.StudentGroupId != studentGroupToId)
				{
					st.StudentGroupId = studentGroupToId;
					student = await _studentLogic.UpdateAsync(st);
					if (student == null)
					{
						var errors = _studentLogic.Errors;
						errors.Add(("Ошибка изменения по студенту", $"Не удалось изменить группу у студента {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = $"У студента {student} сменилась группа на {student.StudentGroupName}"
					});
				}

				if ((orderStudentMoveType == OrderStudentMoveType.Зачисление || orderStudentMoveType == OrderStudentMoveType.ЗачислитьПоПереводу
					|| orderStudentMoveType == OrderStudentMoveType.ПереводВГруппу) && student.StudentState != StudentState.Учится)
				{
					st.StudentState = StudentState.Учится;
					student = await _studentLogic.UpdateAsync(st);
					if (student == null)
					{
						var errors = _studentLogic.Errors;
						errors.Add(("Ошибка изменения по студенту", $"Не удалось изменить статус у студента {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = $"У студента {student} сменился статус на {StudentState.Учится}"
					});
				}

				if ((orderStudentMoveType == OrderStudentMoveType.ВАкадем || orderStudentMoveType == OrderStudentMoveType.ПродлАкадем)
					&& student.StudentState != StudentState.Академ)
				{
					st.StudentState = StudentState.Академ;
					student = await _studentLogic.UpdateAsync(st);
					if (student == null)
					{
						var errors = _studentLogic.Errors;
						errors.Add(("Ошибка изменения по студенту", $"Не удалось изменить статус у студента {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = $"У студента {student} сменился статус на {StudentState.Академ}"
					});
				}

				if (orderStudentMoveType == OrderStudentMoveType.ИзАкадема && student.StudentState != StudentState.Учится)
				{
					st.StudentState = StudentState.Учится;
					student = await _studentLogic.UpdateAsync(st);
					if (student == null)
					{
						var errors = _studentLogic.Errors;
						errors.Add(("Ошибка изменения по студенту", $"Не удалось изменить статус у студента {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = $"У студента {student} сменился статус на {StudentState.Учится}"
					});
				}

				if ((orderStudentMoveType == OrderStudentMoveType.ОтчислитьВСвязиСПереводом || orderStudentMoveType == OrderStudentMoveType.ОтчислитьЗаНевыходСАкадема
					|| orderStudentMoveType == OrderStudentMoveType.ОтчислитьЗаНеуспевамость || orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоСобственному
					|| orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоЗавершению) && student.StudentState != StudentState.Отчислен)
				{
					st.StudentState = orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоЗавершению ? StudentState.Завершил : StudentState.Отчислен;
					student = await _studentLogic.UpdateAsync(st);
					if (student == null)
					{
						var errors = _studentLogic.Errors;
						errors.Add(("Ошибка изменения по студенту", $"Не удалось изменить статус у студента {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = $"У студента {student} сменился статус на {(orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоЗавершению ? StudentState.Завершил : StudentState.Отчислен)}"
					});
					var result = await _studentLogic.DeleteAsync(new StudentGetBindingModel { Id = student.Id });
					if (!result)
					{
						var errors = _userLogic.Errors;
						errors.Add(("Ошибка удаления студента", $"Не удалось удалить студента {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					result = await _userLogic.DeleteAsync(new UserGetBindingModel { Id = student.UserId });
					if (!result)
					{
						var errors = _userLogic.Errors;
						errors.Add(("Ошибка удаления пользователя по студенту", $"Не удалось удалить пользователя по студенту {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
				}

				if (orderStudentMoveType == OrderStudentMoveType.Восстановить && student.StudentState != StudentState.Учится)
				{
					st.StudentState = StudentState.Учится;
					student = await _studentLogic.UpdateAsync(st);
					if (student == null)
					{
						var errors = _studentLogic.Errors;
						errors.Add(("Ошибка изменения по студенту", $"Не удалось изменить статус у студента {studentName}"));
						await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
						{
							OrderSyncHistoryId = history.Id,
							Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
						});
						continue;
					}
					await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
					{
						OrderSyncHistoryId = history.Id,
						Information = $"У студента {student} сменился статус на {StudentState.Учится}"
					});
				}

				await _recordLogic.CreateAsync(new OrderSyncHistoryRecordSetBindingModel
				{
					OrderSyncHistoryId = history.Id,
					Information = $"Добавили запись к приказу {order.OrderNumber} по студенту {student} с формулировкой {info}"
				});

				if (orderStudentMoveType == OrderStudentMoveType.ОтчислитьВСвязиСПереводом ||
					orderStudentMoveType == OrderStudentMoveType.ОтчислитьЗаНевыходСАкадема ||
					orderStudentMoveType == OrderStudentMoveType.ОтчислитьЗаНеуспевамость ||
					orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоЗавершению ||
					orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоСобственному)
				{
					return;
				}
			}
		}

		private static OrderType GetOrderType(string orderTitle) => orderTitle switch
		{
			"Зачисление в вуз" => OrderType.ЗачислениеСтудентов,
			"Распределение по группам" => OrderType.РаспределениеСтудентов,
			"Перевод на следующий курс" => OrderType.ДвижениеСтудентов,
			_ => OrderType.Неопределено,
		};
	}
}