using CoreModels.Enums.Department;
using DepartmentBusinessLogic.BindingModels;
using DepartmentBusinessLogic.HelperModels;
using DepartmentBusinessLogic.Interfaces;
using DepartmentBusinessLogic.ViewModels;
using ToolsModule.BusinessLogics;
using ToolsModule.Enums;
using ToolsModule.Extensions;
using ToolsModule.Interfaces;
using SecurityBusinessLogic.BindingModels;
using SecurityBusinessLogic.BusinessLogics;
using SecurityBusinessLogic.ViewModels;
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 UserRoleBusinessLogic _userRoleLogic;

        private RoleBusinessLogic _roleLogic;

        private OrderBusinessLogic _orderLogic;

        private OrderStudentRecordBusinessLogic _orderStudentRecordLogic;

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

        public async Task<bool> SyncOrders()
        {
            InitLogics();

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

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

            var client = GetClinet(history, address);
            if (client == null)
            {
                return false;
            }

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

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

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

            var students = _studentLogic.GetList(new StudentGetBindingModel());
            if (students == null || students.List == null)
            {
                Errors = _studentLogic.Errors;
                Errors.Add(("Ошибка получения данных", "Не удалось получить список студентов с базы"));
                _recordLogic.Create(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 = _studentLogic.GetElement(new StudentGetBindingModel { NumberOfBook = student.recordBookName });
                if (deletedStudent == null && _studentLogic.Errors.FirstOrDefault(x => x.Message == "Элемент удален") != default)
                {
                    // восстановленец
                    deletedStudent = _studentLogic.Restore(new StudentGetBindingModel { NumberOfBook = student.recordBookName });
                    if (deletedStudent == null)
                    {
                        var errors = _studentLogic.Errors;
                        errors.Add(("Ошибка при восстановлении студента", $"Не удалось восстановить студента {student.lastName} {student.firstName} {student.patronymicName}"));
                        _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                        {
                            OrderSyncHistoryId = history.Id,
                            Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
                        });
                        continue;
                    }
                    var deletedUser = _userLogic.Restore(new UserGetBindingModel { Id = deletedStudent.UserId });
                    if (deletedUser == null)
                    {
                        var errors = _userLogic.Errors;
                        errors.Add(("Ошибка при восстановлении пользователя студента", $"Не удалось восстановить пользователя студента {student.lastName} {student.firstName} {student.patronymicName}"));
                        _recordLogic.Create(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 user = WorkWithUser(student, history);
                if (user == null)
                {
                    continue;
                }

                var newStudent = _studentLogic.Create(new StudentSetBindingModel
                {
                    Iduniv = student.iduniv,
                    NumberOfBook = student.recordBookName,
                    UserId = user.Id,
                    FirstName = student.firstName,
                    LastName = student.lastName,
                    Patronymic = student.patronymicName,
                    StudentState = StudentState.Неопределен,
                    Description = string.Empty
                });
                if (newStudent == null)
                {
                    var errors = _studentLogic.Errors;
                    errors.Add(("Ошибка добавления студента", $"Не удалось добавить студента {student.lastName} {student.firstName} {student.patronymicName}"));
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
                    });
                    continue;
                }

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

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

        private void InitLogics()
        {

            _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>();
            _userRoleLogic = DependencyManager.Instance.Resolve<UserRoleBusinessLogic>();
            _roleLogic = DependencyManager.Instance.Resolve<RoleBusinessLogic>();
        }

        /// <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)
        {
            var response = await client.GetAsync($"{address}/univer/hs/Ulstu_StudentsInfo/v1/GetStudentOrdersByIdAndRecordBook?iduniv={student.Iduniv}&recordBookName={student.NumberOfBook}&allOrders=sppd");
            if (!response.IsSuccessStatusCode)
            {
                Errors.Add(("Ошибка получения данных", "Не удалось получить список приказов по студенту"));
                _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                {
                    OrderSyncHistoryId = history.Id,
                    Information = string.Join(Environment.NewLine, Errors.Select(x => x.Message))
                });
                return;
            }
            var syncOrders = JsonSerializer.Deserialize<StudentOrderListSyncModel>(await response.Content.ReadAsStringAsync());
            foreach (var syncOrder in syncOrders.StudentOrders)
            {
                if (syncOrder.orderTypeName == "Утверждение тем курсовых работ" ||
                    syncOrder.orderTypeName == "Утверждение тем ВКР" ||
                    syncOrder.orderTypeName == "Назначение стипендии")
                {
                    continue;
                }
                if (syncOrder.markOfApprove.ToLower() != "true")
                {
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = $"Приказ {syncOrder.clericNumber} от {syncOrder.clericDate} ({syncOrder.orderTypeName}) по студенту {student} не утврежден "
                    });
                    continue;
                }
                if (syncOrder.clericNumber.IsEmpty())
                {
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = $"Приказ без номера от {syncOrder.clericDate} ({student})"
                    });
                    continue;
                }
                if (syncOrder.clericDate.IsEmpty())
                {
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = $"Приказ {syncOrder.clericNumber} - неизвестная дата ({student})"
                    });
                    continue;
                }
                var orderType = GetOrderType(syncOrder.orderTypeName);

                // пропускаем приказы, которые нас не интересуют
                if (orderType == OrderType.Игнорировать)
                {
                    continue;
                }
                if (orderType == OrderType.Неопределено)
                {
                    if (syncOrder.orderTypeName != "Корректировка" && syncOrder.orderTypeName != "Назначение стипендии" &&
                        syncOrder.orderTypeName != "Утверждение тем курсовых работ" && syncOrder.orderTypeName != "Утверждение тем работ"
                         && syncOrder.orderTypeName != "Смена ФИО")
                        _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                        {
                            OrderSyncHistoryId = history.Id,
                            Information = $"Приказ {syncOrder.clericNumber} неопределенного типа {syncOrder.orderTypeName}"
                        });
                    continue;
                }

                // пытаемся найти приказ
                var order = _orderLogic.GetElement(new OrderGetBindingModel
                {
                    OrderNumber = syncOrder.clericNumber
                });
                if (order == null)
                {
                    // если не нашли - пытаемся создать
                    order = _orderLogic.Create(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}"));
                        _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                        {
                            OrderSyncHistoryId = history.Id,
                            Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
                        });
                        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 && syncOrder.groupNameBefore.IsNotEmpty()
                    && !studentGroupToId.HasValue && syncOrder.groupNameAfter.IsNotEmpty())
                {
                    continue;
                }
                OrderStudentMoveType orderStudentMoveType = OrderStudentMoveType.Неопределено;

                switch (syncOrder.orderTypeName)
                {
                    case "Перевод":
                        if (syncOrder.orderSubTypeName == "Распределение по группам")
                        {
                            orderStudentMoveType = OrderStudentMoveType.Распределить;
                            info = $"Распределение студента {student} в группу {groups.FirstOrDefault(x => x.Id == studentGroupToId)}";
                        }
                        else if (studentGroupFromId.HasValue && studentGroupToId.HasValue)
                        {
                            orderStudentMoveType = OrderStudentMoveType.ПеревестиНаДругоеНаправлениеКафедры;
                            info = $"Перевод студента {student} из группы {groups.FirstOrDefault(x => x.Id == studentGroupFromId)} в группу {groups.FirstOrDefault(x => x.Id == studentGroupToId)}";
                        }
                        else if (!studentGroupFromId.HasValue && studentGroupToId.HasValue)
                        {
                            orderStudentMoveType = OrderStudentMoveType.ПринятьПоПереводу;
                            info = $"Перевод студента {student} c группы {syncOrder.groupNameBefore} другой кафедры в группу {groups.FirstOrDefault(x => x.Id == studentGroupToId)}";
                        }
                        else if (studentGroupFromId.HasValue && !studentGroupToId.HasValue)
                        {
                            orderStudentMoveType = OrderStudentMoveType.УбратьПоПереводу;
                            info = $"Перевод студента {student} из группы {groups.FirstOrDefault(x => x.Id == studentGroupFromId)} на другую кафедру";
                        }
                        break;
                    case "Зачисление в вуз вне приемной кампании":
                        orderStudentMoveType = OrderStudentMoveType.ЗачислитьПоПриказу;
                        info = $"Зачисление студента {student} по приказу";
                        break;
                    case "Зачисление в вуз":
                        orderStudentMoveType = OrderStudentMoveType.ЗачислитьПоПриказу;
                        info = $"Зачисление студента {student} по приказу";
                        break;
                    case "Перевод из другого вуза":
                        orderStudentMoveType = OrderStudentMoveType.ПринятьПоПереводусДругогоВуза;
                        info = $"Перевод студента {student} с другого вуза";
                        break;
                    case "Перевод на следующий курс":
                        orderStudentMoveType = OrderStudentMoveType.ПеревестиНаСтаршийКурс;
                        info = $"Перевод студента {student} из группы {groups.FirstOrDefault(x => x.Id == studentGroupFromId)} на следующий курс в группу {groups.FirstOrDefault(x => x.Id == studentGroupToId)}";
                        break;
                    //case "Завершение обучения": // уточнить приказ
                    //	orderStudentMoveType = OrderStudentMoveType.ОтчислитьПоСобственному;
                    //	info = $"Отчисление студента {student} в связи с окончанием обучения";
                    //	break;
                    case "Уход в академический отпуск":
                        DateTime? date = null;
                        if (syncOrder.dateEnd.IsNotEmpty())
                        {
                            date = Convert.ToDateTime(syncOrder.dateEnd);
                        }
                        orderStudentMoveType = OrderStudentMoveType.ОтправитьВАкадем;
                        info = $"Уход в АО студента {student} из группы {groups.FirstOrDefault(x => x.Id == studentGroupFromId)} до {date?.ToShortDateString() ?? string.Empty}";
                        break;
                    case "Продление академического отпуска":
                        orderStudentMoveType = OrderStudentMoveType.ПродлитьАкадем;
                        info = $"Продление АО студента {student}";
                        break;
                    case "Восстановление из академического отпуска":
                        orderStudentMoveType = OrderStudentMoveType.ВосстановитьИзАкадема;
                        info = $"Выход из АО студента {student} в группу {groups.FirstOrDefault(x => x.Id == studentGroupToId)}";
                        break;
                    //case "Отчисление по невыходу из академа": // уточнить приказ
                    //	orderStudentMoveType = OrderStudentMoveType.ОтчислитьЗаНевыходСАкадема;
                    //	info = $"Отчисление студента {student} по невыходу из академа";
                    //	break;
                    case "Отчисление":
                        if (syncOrder.reason == "за невыполнение учебного плана")
                        {
                            orderStudentMoveType = OrderStudentMoveType.ОтчислитьЗаНеуспевамость;
                            info = $"Отчисление студента {student} из группы {groups.FirstOrDefault(x => x.Id == studentGroupFromId)} за неуспеваемость";
                        }
                        if (syncOrder.reason == "по собственному желанию")
                        {
                            orderStudentMoveType = OrderStudentMoveType.ОтчислитьПоСобственному;
                            info = $"Отчисление студента {student} из группы {groups.FirstOrDefault(x => x.Id == studentGroupFromId)} по собственному желанию";
                        }
                        break;
                    case "Восстановление":
                        orderStudentMoveType = OrderStudentMoveType.Восстановить;
                        info = $"Восстановление отчисленного студента {student} в группу {groups.FirstOrDefault(x => x.Id == studentGroupToId)}";
                        break;
                    case "Выпуск":
                        orderStudentMoveType = OrderStudentMoveType.ОтчислитьПоЗавершению;
                        info = $"Завершение обучения студента {student}";
                        break;
                }

                if (orderStudentMoveType == OrderStudentMoveType.Неопределено)
                {
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = $"Неизветсный приказ {syncOrder.orderTypeName} ({syncOrder.reason}) по студенту {student}"
                    });
                    continue;
                }

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

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

                // создаем, если не нашли
                var studentOrder = _orderStudentRecordLogic.Create(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}"));
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
                    });
                    continue;
                }

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

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

        private HttpClient GetClinet(OrderSyncHistoryViewModel history, EnviromentSettingViewModel address)
        {

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

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

            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}")));

            return client;
        }

        private UserViewModel WorkWithUser(StudentSyncModel student, OrderSyncHistoryViewModel history)
        {
            var userName = $"{student.lastName}{(student.firstName.IsNotEmpty() ? $" {student.firstName[0]}." : string.Empty)}{(student.patronymicName.IsNotEmpty() ? $"{student.patronymicName[0]}." : string.Empty)}";
            var user = _userLogic.GetOrCreateUser(new UserGetBindingModel
            {
                Login = student.recordBookName
            }, userName);
            if (user == null)
            {
                if (_userLogic.Errors.Count > 0)
                {
                    var errors = _userLogic.Errors;
                    errors.Add(("Ошибка получения пользователя под студента", $"Не удалось получить пользователя под студента {student.lastName} {student.firstName} {student.patronymicName}"));
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
                    });
                    return null;
                }
            }
            var role = _roleLogic.GetElement(new RoleGetBindingModel { RoleName = "Студент" });
            if (role == null)
            {
                if (_roleLogic.Errors.Count > 0)
                {
                    var errors = _roleLogic.Errors;
                    errors.Add(("Ошибка получения роли студента", $"Не удалось получить роль студента {student.lastName} {student.firstName} {student.patronymicName}"));
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
                    });
                    return null;
                }
            }
            var link = _userRoleLogic.GetElement(new UserRoleGetBindingModel { RoleId = role.Id, UserId = user.Id });
            if (link == null)
            {
                var manager = DependencyManager.Instance.Resolve<ISecurityManager>();
                _userRoleLogic.Create(new UserRoleSetBindingModel { RoleId = role.Id, UserId = user.Id, UserIdForAccess = manager?.User });
                if (_userRoleLogic.Errors.Count > 0)
                {
                    var errors = _userRoleLogic.Errors;
                    errors.Add(("Ошибка создания привязки студента к роли", $"Не удалось привязать студента {student.lastName} {student.firstName} {student.patronymicName} к роли"));
                    _recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
                    {
                        OrderSyncHistoryId = history.Id,
                        Information = string.Join(Environment.NewLine, errors.Select(x => x.Message))
                    });
                    return null;
                }
            }

            return user;
        }

        private static OrderType GetOrderType(string orderTitle) => orderTitle switch
        {
            "Зачисление в вуз вне приемной кампании" => OrderType.ЗачислениеСтудентов,
            "Зачисление в вуз" => OrderType.ЗачислениеСтудентов,
            "Перевод из другого вуза" => OrderType.ЗачислениеСтудентов,
            "Перевод" => OrderType.Перевод,
            "Перевод на следующий курс" => OrderType.ДвижениеСтудентов,
            "Завершение обучения" => OrderType.Отчисление,
            "Уход в академический отпуск" => OrderType.ДвижениеСтудентов,
            "Продление академического отпуска" => OrderType.ДвижениеСтудентов,
            "Восстановление из академического отпуска" => OrderType.ДвижениеСтудентов,
            "Отчисление" => OrderType.Отчисление,
            "Отчисление (за невыполнение обязанностей по добросовестному освоению образовательной программы и выполнению учебного плана)" => OrderType.Отчисление,
            "Отчисление (в связи с переводом в ___)" => OrderType.Отчисление,
            "Отчисление (в связи с невыходом из академического отпуска)" => OrderType.Отчисление,
            "Восстановление" => OrderType.Перевод,
            "Выпуск" => OrderType.ДвижениеСтудентов,
            "Утверждение тем ВКР" => OrderType.Игнорировать,
            _ => OrderType.Неопределено,
        };
    }
}