using Dpz.Core.Service.Mediator.Features.Account.Internal;
using Dpz.Core.Service.Mediator.Features.Account.Queries;

namespace Dpz.Core.Service.Mediator.Features.Account.Commands;

/// <summary>
/// 处理修改账号资料请求
/// </summary>
public class UpdateAccountInfoHandler(
    IRepository<User> userRepository,
    IRepository<UserHistory> userHistoryRepository,
    IRepository<UserExtendedInfo> userExtendedInfoRepository,
    IMediator mediator,
    IFusionCache fusionCache
) : IRequestHandler<UpdateAccountInfoRequest, ResponseResult<VmUserInfo?>>
{
    /// <summary>
    /// 修改账号资料并返回最新用户信息
    /// </summary>
    public async ValueTask<ResponseResult<VmUserInfo?>> Handle(
        UpdateAccountInfoRequest request,
        CancellationToken cancellationToken
    )
    {
        var result = new ResponseResult<VmUserInfo?>();
        var user = await mediator.Send(
            new GetUserInfoRequest { Account = request.Account },
            cancellationToken
        );
        if (user == null)
        {
            return result.WithFail($"账号【{request.Account}】不存在");
        }

        var changes = new List<ChangeDetail>();
        if (user.Name != request.Name)
        {
            changes.Add(AccountRepositoryHelper.Change(nameof(user.Name), user.Name, request.Name));
        }
        if (user.Sign != request.Sign)
        {
            changes.Add(AccountRepositoryHelper.Change(nameof(user.Sign), user.Sign, request.Sign));
        }
        if (user.Sex != request.Sex)
        {
            changes.Add(AccountRepositoryHelper.Change(nameof(user.Sex), user.Sex, request.Sex));
        }

        if (user.Email != request.Email)
        {
            if (!string.IsNullOrWhiteSpace(request.Email))
            {
                var exists = await userExtendedInfoRepository
                    .SearchFor(x => x.Email == request.Email && x.Id != user.Id)
                    .AnyAsync(cancellationToken: cancellationToken);
                if (exists)
                {
                    return result.WithFail($"邮箱【{request.Email}】已被使用");
                }
            }
            changes.Add(
                AccountRepositoryHelper.Change(nameof(user.Email), user.Email, request.Email)
            );
        }

        if (changes.Count == 0)
        {
            return result.WithOk(user);
        }

        var nameExists = await userRepository
            .SearchFor(x => x.Name == request.Name && x.Id != user.Id)
            .AnyAsync(cancellationToken: cancellationToken);
        if (nameExists)
        {
            return result.WithFail($"昵称【{request.Name}】已被使用");
        }

        await AccountRepositoryHelper.SaveUserHistoryAsync(
            userHistoryRepository,
            user.Id,
            changes,
            cancellationToken
        );

        var update = Builders<User>
            .Update.Set(x => x.Name, request.Name)
            .Set(x => x.Sign, request.Sign)
            .Set(x => x.Sex, request.Sex)
            .Set(x => x.LastUpdateTime, DateTime.Now);
        await userRepository.UpdateAsync(x => x.Id == user.Id, update, cancellationToken);

        var userExtendedInfo = await userExtendedInfoRepository
            .SearchFor(x => x.Id == user.Id)
            .SingleOrDefaultAsync(cancellationToken: cancellationToken);
        if (userExtendedInfo == null)
        {
            await userExtendedInfoRepository.InsertAsync(
                new UserExtendedInfo { Id = user.Id, Email = request.Email },
                cancellationToken
            );
        }
        else
        {
            var userExtendedInfoUpdate = Builders<UserExtendedInfo>
                .Update.Set(x => x.Email, request.Email)
                .Set(x => x.LastUpdateTime, DateTime.Now);
            await userExtendedInfoRepository.UpdateAsync(
                x => x.Id == user.Id,
                userExtendedInfoUpdate,
                cancellationToken
            );
        }

        var userInfo = await mediator.Send(
            new GetUserInfoRequest { Account = request.Account },
            cancellationToken
        );
        await fusionCache.SetAsync(
            UserSessionKeys.ChangedAtKey(request.Account),
            DateTime.Now,
            TimeSpan.FromDays(30),
            token: cancellationToken
        );
        return result.WithOk(userInfo);
    }
}