IM_NEW/ContactService.WebApi/Application/FriendRequest/FriendRequestService.cs

using AutoMapper;
using ContactService.Domain;
using ContactService.WebApi.Application.Dtos;
using ContactService.WebApi.Application.IntegrationServices;
using IM.Commons;

namespace ContactService.WebApi.Application.FriendRequest
{
    public class FriendRequestService
    {
        private readonly IFriendRequestReposity reposity;
        private readonly FriendRequestDomainService service;
        private readonly IMapper mapper;
        private readonly IIdentityIntegrationService identityService;

        public FriendRequestService(IFriendRequestReposity reposity, FriendRequestDomainService service,
            IMapper mapper, IIdentityIntegrationService identityService)
        {
            this.reposity = reposity;
            this.service = service;
            this.mapper = mapper;
            this.identityService = identityService;
        }

        public async Task<Result<FriendRequestResponse>> CreateAsync(CreateFriendRequestCommand command)
        {
            var request = await service.CreateAsync(command.ownerId, command.targetId, command.description, command.remarkName);
            if (!request.Succeeded)
            {
                return Result<FriendRequestResponse>.Fail(request);
            }
            var response = mapper.Map<FriendRequestResponse>(request.Data);
            await PopulateUserInfoAsync(response);
            return Result<FriendRequestResponse>.Success(response);
        }

        public async Task<Result<FriendRequestResponse>> UpdateStatusAsync(FriendRequestHandleCommand command)
        {
            var request = await reposity.FindByIdAsync(command.RequestId);
            if (request == null)
            {
                return Result<FriendRequestResponse>.Fail(ResultCode.FRIEND_REQUEST_NOT_FOUND);
            }

            if (request.TargetId != command.UserId)
            {
                return Result<FriendRequestResponse>.Fail(ResultCode.PERMISSION_DENIED);
            }

            switch (command.Action)
            {
                case FriendRequestAction.Accpet:
                    request.Accept(command.RemarkName);
                    break;
                case FriendRequestAction.Block:
                    request.Block();
                    break;
                case FriendRequestAction.Reject:
                    request.Reject();
                    break;
                default:
                    return Result<FriendRequestResponse>.Fail(ResultCode.PARAMETER_ERROR);
            }
            var response = mapper.Map<FriendRequestResponse>(request);
            await PopulateUserInfoAsync(response);
            return Result<FriendRequestResponse>.Success(response);
        }

        public async Task<Result<List<FriendRequestResponse>>> GetByOwnerIdAsync(Guid ownerId)
        {
            var requests = await reposity.FindByOwnerIdAsync(ownerId);
            var responses = mapper.Map<List<FriendRequestResponse>>(requests);
            await PopulateUserInfoAsync(responses);
            return Result<List<FriendRequestResponse>>.Success(responses);
        }

        public async Task<Result<List<FriendRequestResponse>>> GetByTargetIdAsync(Guid targetId)
        {
            var requests = await reposity.FindByTargetIdAsync(targetId);
            var responses = mapper.Map<List<FriendRequestResponse>>(requests);
            await PopulateUserInfoAsync(responses);
            return Result<List<FriendRequestResponse>>.Success(responses);
        }

        public async Task<Result<List<FriendRequestResponse>>> GetByTargetIdOrOwnerIdAsync(Guid id)
        {
            var requests = await reposity.FindByTargetIdAsync(id);
            var requests2 = await reposity.FindByOwnerIdAsync(id);
            var responses = mapper.Map<List<FriendRequestResponse>>(requests.Concat(requests2));
            await PopulateUserInfoAsync(responses);
            return Result<List<FriendRequestResponse>>.Success(responses);
        }

        private async Task PopulateUserInfoAsync(List<FriendRequestResponse> responses)
        {
            if (responses.Count == 0) return;

            var allUserIds = responses.Select(r => r.OwnerId)
                .Concat(responses.Select(r => r.TargetId))
                .Distinct()
                .ToList();

            var userResult = await identityService.FindByIdsAsync(allUserIds);
            if (!userResult.Succeeded || userResult.Data == null) return;

            var userDict = userResult.Data;
            foreach (var r in responses)
            {
                if (userDict.TryGetValue(r.OwnerId, out var owner))
                {
                    r.OwnerNickName = owner.NickName;
                    r.OwnerAvatar = owner.Avatar;
                }
                if (userDict.TryGetValue(r.TargetId, out var target))
                {
                    r.TargetNickName = target.NickName;
                    r.TargetAvatar = target.Avatar;
                }
            }
        }

        private async Task PopulateUserInfoAsync(FriendRequestResponse response)
        {
            var ids = new List<Guid> { response.OwnerId, response.TargetId }.Distinct().ToList();
            var userResult = await identityService.FindByIdsAsync(ids);
            if (!userResult.Succeeded || userResult.Data == null) return;

            var userDict = userResult.Data;
            if (userDict.TryGetValue(response.OwnerId, out var owner))
            {
                response.OwnerNickName = owner.NickName;
                response.OwnerAvatar = owner.Avatar;
            }
            if (userDict.TryGetValue(response.TargetId, out var target))
            {
                response.TargetNickName = target.NickName;
                response.TargetAvatar = target.Avatar;
            }
        }
    }
}