using data.Exception;
using data.RemoteData.DAO;
using data.Repository;
using domain.Models;

namespace domain.UseCase
{
    public class GroupUseCase
    {
        private readonly IGroupRepository _repositoryGroupImpl;

        public GroupUseCase(IGroupRepository repositoryGroupImpl)
        {
            _repositoryGroupImpl = repositoryGroupImpl;
        }


        private GroupLocalEntity ValidateGroupExistence(int groupId)
        {
            var existingGroup = _repositoryGroupImpl.GetAllGroup()
                .FirstOrDefault(g => g.Id == groupId);

            if (existingGroup == null)
            {
                throw new ArgumentException("Группа не найдена.");
            }


            return new GroupLocalEntity
            {
                Id = existingGroup.Id,
                Name = existingGroup.Name
            };
        }

        public List<Group> GetAllGroups()
        {
            return [.. _repositoryGroupImpl.GetAllGroup()
                .Select(it => new Group { Id = it.Id, Name = it.Name, Users = it.Users.Select(user => new User { FIO = user.FIO, GroupId = user.GroupID, Guid = user.Guid}).ToList() })];
        }


        public Group FindGroupById(int groupId)
        {
            var group = GetAllGroups().FirstOrDefault(g => g.Id == groupId);

            if (group == null)
            {
                throw new ArgumentException("Группа не найдена.");
            }

            return group;
        }


        public void AddGroup(string groupName)
        {


            var newId = _repositoryGroupImpl.GetAllGroup().Any()
                        ? _repositoryGroupImpl.GetAllGroup().Max(g => g.Id) + 1
                        : 1;

            GroupDao newGroup = new GroupDao
            {
                Id = newId,
                Name = groupName
            };

            _repositoryGroupImpl.AddGroup(newGroup);
        }

        public void RemoveGroupById(int groupId)
        {

            var existingGroup = ValidateGroupExistence(groupId);
            List<Group> _groups = GetAllGroups();

            // Находим группу по ID и удаляем ее
            var groupToRemove = _groups.FirstOrDefault(g => g.Id == existingGroup.Id);
            if (groupToRemove != null)
            {
                _groups.Remove(groupToRemove);
                _repositoryGroupImpl.RemoveGroupById(existingGroup.Id);
            }
            else
            {
                throw new ArgumentException("Группа не найдена.");
            }
        }


        // Метод для изменения названия группы
        public bool UpdateGroup(int groupId, string newGroupName)
        {
            var existingGroup = _repositoryGroupImpl.GetAllGroup()
                .FirstOrDefault(g => g.Id == groupId);

            if (existingGroup == null)
            {
                return false; // Группа с таким ID не найдена
            }

            existingGroup.Name = newGroupName;
            _repositoryGroupImpl.UpdateGroupById(existingGroup.Id, existingGroup);
            return true; // Успешное обновление
        }
        public List<Group> GetAllGroupWithStident()
        {
            // Загружаем группы с пользователями
            var groups = _repositoryGroupImpl.GetAllGroupWithStident()
                .Select(g => new Group
                {
                    Id = g.Id,
                    Name = g.Name,
                    Users = g.Users.Select(u => new User
                    {
                        Guid = u.Guid,
                        FIO = u.FIO
                    }).ToList()
                })
                .ToList();

            return groups;
        }

        public void RemoveAllStudentsFromGroup(int groupId)
        {
            var existingGroup = ValidateGroupExistence(groupId);
            _repositoryGroupImpl.RemoveAllStudentsFromGroup(existingGroup.Id);
        }

        public void AddStudentToGroup(int groupId, User newStudent)
        {
            // Проверяем существование группы по ID
            var existingGroup = ValidateGroupExistence(groupId);

            // Создаем UserDao для добавления в базу данных
            UserDao studentDao = new UserDao
            {
                Guid = newStudent.Guid,
                FIO = newStudent.FIO
            };

            // Проверка существования пользователя в группе (по GUID)
            var existingStudent = existingGroup.Users.FirstOrDefault(u => u.Guid == newStudent.Guid);
            if (existingStudent != null)
            {
                throw new ArgumentException($"Студент с GUID {newStudent.Guid} уже добавлен в эту группу.");
            }

            // Добавляем студента в группу
            _repositoryGroupImpl.AddStudentToGroup(existingGroup.Id, studentDao);
        }

        public void RemoveStudentFromGroup(int groupId, Guid studentGuid)
        {
            // Получаем группу из репозитория
            var group = _repositoryGroupImpl.GetGroupById(groupId);
            if (group == null) throw new ArgumentException("Group not found");

            // Проверяем наличие студента в группе
            var student = group.Users?.FirstOrDefault(u => u.Guid == studentGuid);
            if (student == null) throw new ArgumentException("Student not found in the group");

            // Удаляем студента из группы
            group.Users.Remove(student);

            // Преобразуем объект группы в GroupDao
            var groupDao = new GroupDao
            {
                Id = group.Id,
                Name = group.Name,
                Users = group.Users.Select(u => new UserDao
                {
                    Guid = u.Guid,
                    FIO = u.FIO
                }).ToList()
            };

            // Сохраняем изменения в базе данных
            _repositoryGroupImpl.UpdateGroup(groupDao);
        }


        public bool RemoveUserByGuid(Guid userGuid)
        {
            try
            {
                return _repositoryGroupImpl.RemoveUserByGuid(userGuid);
            }
            catch (UserNotFoundException ex)
            {
                Console.WriteLine($"Ошибка: {ex.Message}");
                return false;
            }
            catch (RepositoryException ex)
            {
                Console.WriteLine($"Ошибка в репозитории: {ex.Message}");
                return false;
            }
        }

        public UserDao UpdateUser(Guid userGuid, string newFio, int groupId)
        {
            UserDao userDao = new UserDao
            {
                Guid = userGuid,
                FIO = newFio,
                GroupID = groupId
            };

            return userDao;
        }
    }
}