using Demo.Data.Exceptions;
using Demo.Data.RemoteData.RemoteDataBase;
using Demo.Data.RemoteData.RemoteDataBase.DAO;
using Demo.Data.Repository;
using Demo.domain.Models;

namespace Demo.Domain.UseCase
{
    public class UserUseCase
    {
        private readonly IUserRepository _repositoryUserImpl;
        private readonly IGroupRepository _repositoryGroupImpl;
        private readonly IPresenceRepository _repositoryPresenceImpl;
        public UserUseCase(IUserRepository repositoryImpl, IGroupRepository repositoryGroupImpl, IPresenceRepository presenceRepository)
        {
            _repositoryUserImpl = repositoryImpl;
            _repositoryGroupImpl = repositoryGroupImpl;
            _repositoryPresenceImpl = presenceRepository;
        }

        // Приватный метод для валидации ФИО пользователя
        private void ValidateUserFIO(string fio)
        {
            if (string.IsNullOrWhiteSpace(fio))
            {
                throw new ArgumentException("ФИО не может быть пустым.");
            }
        }

        public void RemovePresenceByUserId(Guid UserGuid)
        {
            using (var context = new RemoteDatabaseContext())
            {
                var presences = context.PresenceDaos.Where(p => p.UserGuid == UserGuid).ToList();
                context.PresenceDaos.RemoveRange(presences);
                context.SaveChanges();
            }
        }

        // Приватный метод для валидации существования пользователя по ID
        private UserDao ValidateUserExistence(Guid UserGuid)
        {
            var user = _repositoryUserImpl.GetAllUsers()
                .FirstOrDefault(u => u.UserGuid == UserGuid);
            
            if (user == null)
            {
                throw new Exception("Пользователь не найден.");
            }

            return user;
        }

        // Приватный метод для валидации существования группы по ID
        private GroupDao ValidateGroupExistence(int groupId)
        {
            var group = _repositoryGroupImpl.GetAllGroups()
                .FirstOrDefault(g => g.Id == groupId);

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

            return group;
        }

        // Вывести всех пользователей
        public List<User> GetAllUsers() => _repositoryUserImpl.GetAllUsers()
            .Join(_repositoryGroupImpl.GetAllGroups(),
            user => user.GroupId, // Ключ для пользователей
            group => group.Id, // Ключ для групп
            (user, group) => // Результирующий объект
            new User
            {
                Guid = user.UserGuid,
                FIO = user.FIO,
                Group = new Group { Id = group.Id, Name = group.Name }
            }).ToList();

        // Удалить пользователя по id
        public bool RemoveUserById(Guid UserGuid)
        {
            try
            {
                return _repositoryUserImpl.RemoveUserById(UserGuid);
            }
            catch (UserNotFoundException ex)
            {
                Console.WriteLine($"Ошибка: {ex.Message}");
                return false;
            }
            catch (RepositoryException ex)
            {
                Console.WriteLine($"Ошибка в репозитории: {ex.Message}");
                return false;
            }
        }

        // Обновить пользователя по id
        public UserDao UpdateUser(UserDao user)
        {
            ValidateUserFIO(user.FIO);
            ValidateGroupExistence(user.GroupId);

            UserDao userDao = new UserDao
            {
                UserGuid = user.UserGuid,
                FIO = user.FIO,
                GroupId = user.GroupId
            };

            UserDao? result = _repositoryUserImpl.UpdateUser(userDao);

            if (result == null)
            {
                throw new Exception("Ошибка при обновлении пользователя.");
            }

            var groupEntity = ValidateGroupExistence(result.GroupId);

            return new UserDao
            {
                UserGuid =user.UserGuid,
                FIO = result.FIO,
                GroupId = result.GroupId
            };
            
        }

        // Найти пользователя по id
        public UserDao FindUserById(Guid UserGuid)
        {
            var user = ValidateUserExistence(UserGuid);
            var group = ValidateGroupExistence(user.GroupId);

            return new UserDao
            {
                UserGuid = user.UserGuid,
                FIO = user.FIO,
                Group = new GroupDao { Id = group.Id, Name=group.Name }
            };
        }
    }
}