using AutoMapper;
using Project.Application.DTOs.Incoming;
using Project.Application.DTOs.Outgoing;
using Project.Application.Interfaces;
using Project.Domain.Entities;
using Project.Infrastructure.Interfaces;

namespace Project.Application.Services
{
    public class UserService : IUserService
    {
        // FIELDS FOR CTOR
        private readonly IUserRepository _userRepository;
        private readonly IRoleRepository _roleRepository;
        private readonly IMapper _mapper;

        // CTOR
        public UserService(IUserRepository userRepository, IRoleRepository roleRepository, IMapper mapper)
        {
            _userRepository = userRepository;
            _roleRepository = roleRepository;
            _mapper = mapper;
        }

        // CREATE
        public async Task<User?> AddUserAsync(CreatingUserDto creatingUserDto)
        {
            // validating role
            var role = await _roleRepository.GetByIdAsync(creatingUserDto.RoleId);
            if (role == null)
            {
                throw new ArgumentException("Role not found");
            }

            // mapping dto to entity
            var user = _mapper.Map<User>(creatingUserDto);
            var created = await _userRepository.AddAsync(user);
            return created;
        }

        // READ ALL
        public async Task<IEnumerable<ReadingUserDto>> GetUsersAsync()
        {
            var users = await _userRepository.GetAllAsync();
            var readDto = _mapper.Map<IEnumerable<ReadingUserDto>>(users);
            return readDto;
        }

        // READ BY ID
        public async Task<ReadingUserDto> GetByIdAsync(int id)
        {
            var user = await _userRepository.GetByIdAsync(id);
            var readDto = _mapper.Map<ReadingUserDto>(user);
            return readDto;
        }

        // READ BY EMAIL
        public async Task<ReadingUserDto> GetByEmailAsync(string email)
        {
            var user = await _userRepository.GetByEmailAsync(email);
            var readDto = _mapper.Map<ReadingUserDto>(user);
            return readDto;
        }

        // UPDATE
        public async Task<bool> UpdateUserAsync(UpdatingUserDto updatingUserDto)
        {
            var user = _mapper.Map<User>(updatingUserDto);
            bool isUpdated = await _userRepository.UpdateAsync(user);
            return isUpdated;
        }

        // UPDATE USER ROLE -- die Rolle eines Users aktualisieren
        public async Task UpdateUserRoleAsync(int userId, int roleId)
        {
            var user = await _userRepository.GetByIdAsync(userId);
            if (user == null)
            {
                throw new ArgumentException("User not found");
            }

            var role = await _roleRepository.GetByIdAsync(roleId);
            if (role == null)
            {
                throw new ArgumentException("Role not found");
            }

            user.RoleId = roleId;
            await _userRepository.SaveAsync();
        }

        // DELETE
        public async Task<bool> DeleteUserAsync(int id)
        {
            User? user = await _userRepository.GetByIdAsync(id);

            if (user is null)
                return false;

            bool isDeleted = await _userRepository.DeleteAsync(user);
            return isDeleted;
        }
    }
}