using AutoMapper;
using GroupService.Domain.Entities;
using GroupService.Domain.IReposities;
using GroupService.Domain.ValueObjects;
using GroupService.WebApi.Application.Dtos;
using GroupService.WebApi.Application.IntegrationServices;
using IM.Commons;

namespace GroupService.WebApi.Application.GroupRequest
{
    public class GroupRequestService
    {
        private readonly IGroupRequestReposity reposity;
        private readonly IGroupReposity groupReposity;
        private readonly IMapper mapper;
        private readonly IGroupMemberReposity memberReposity;
        private readonly IIdentityIntegrationService idService;

        public GroupRequestService(IGroupRequestReposity reposity, IGroupReposity groupReposity, IMapper mapper, IGroupMemberReposity memberReposity, IIdentityIntegrationService idService)
        {
            this.reposity = reposity;
            this.groupReposity = groupReposity;
            this.mapper = mapper;
            this.memberReposity = memberReposity;
            this.idService = idService;
        }

        public async Task<Result<GroupRequestResponse>> CreateAsync(Guid groupId, Guid userId, string? desc)
        {
            var group = await groupReposity.FindByIdAsync(groupId);
            if (group == null)
            {
                return Result.Fail<GroupRequestResponse>(ResultCode.GROUP_NOT_FOUND);
            }

            var user = await idService.FindUserByIdAsync(userId);

            var groupProfile = new GroupProfile()
            {
                Avatar = group.Avatar,
                GroupName = group.Name
            };

            var userProfile = new UserProfile()
            {
                Avatar = user.Data.Avatar,
                NickName = user.Data.NickName
            };


            var request = new GroupJoinRequest(userId,userProfile, groupId, groupProfile, desc);
            reposity.Create(request);

            if (group.Authority == Domain.Enums.GroupAuthorityType.ANYONE_CAN_JOIN)
            {
                request.Approve(user.Data.Id, user.Data.NickName, user.Data.Avatar);
            }

            return Result.Success(mapper.Map<GroupRequestResponse>(request));
        }

        public async Task<Result<object>> HandleAsync(RequestHandleCommand command)
        {
            var request = await reposity.FindByIdAsync(command.RequestId);
            if (request is null)
            {
                return Result.Fail<object>(ResultCode.GROUP_REQUEST_NOT_FOUND);
            }

            var member = await memberReposity.FindOneByGroupIdAndUserIdAsync(request.GroupId, command.UserId);

            if (member is null || member.Role == Domain.Enums.GroupMemberRole.Normal)
            {
                return Result.Fail<object>(ResultCode.PERMISSION_DENIED);
            }

            if (command.Action == RequestHandleAction.Accept)
            {
                request.Approve(member.UserId, member.GroupNickName, member.Avatar);
            }
            else if (command.Action == RequestHandleAction.Reject)
            {
                request.Decline(member.UserId, member.GroupNickName, member.Avatar);
            }
            return Result.Success();

        }

        public async Task<Result<GroupRequestResponse>> GetByIdAsync(Guid id, Guid userId)
        {
            var request = await reposity.FindByIdAsync(id);
            if (request is null || (request.UserId != userId && request.OperatorId != userId))
            {
                return Result.Fail<GroupRequestResponse>(ResultCode.GROUP_REQUEST_NOT_FOUND);
            }

            return Result.Success(mapper.Map<GroupRequestResponse>(request));
        }
        public async Task<Result<List<GroupRequestResponse>>> GetListAsync(Guid userId)
        {
            var list = await reposity.FindByUserIdAsync(userId);
            return Result.Success(mapper.Map<List<GroupRequestResponse>>(list.ToList()));
        }

    }
}