using Abp.Dependency;
using Abp.Domain.Repositories;
using Abp.Domain.Uow;
using Abp.Events.Bus.Entities;
using Abp.Events.Bus.Handlers;

using VberZero.BaseSystem.MultiTenancy;
using VberZero.BaseSystem.Users;

namespace VberZero.Authorization.Users;

/// <summary>
/// 将用户的信息同步到用户帐户。
/// </summary>
public class UserAccountSynchronizer :
    IEventHandler<EntityCreatedEventData<User>>,
    IEventHandler<EntityDeletedEventData<User>>,
    IEventHandler<EntityUpdatedEventData<User>>,
    IEventHandler<EntityDeletedEventData<Tenant>>,
    ITransientDependency
{
    private readonly IRepository<UserAccount, long> _userAccountRepository;
    private readonly IUnitOfWorkManager _unitOfWorkManager;

    /// <summary>
    /// Constructor
    /// </summary>
    public UserAccountSynchronizer(
        IRepository<UserAccount, long> userAccountRepository,
        IUnitOfWorkManager unitOfWorkManager)
    {
        _userAccountRepository = userAccountRepository;
        _unitOfWorkManager = unitOfWorkManager;
    }

    /// <summary>
    /// 处理用户的创建事件
    /// </summary>
    public virtual void HandleEvent(EntityCreatedEventData<User> eventData)
    {
        _unitOfWorkManager.WithUnitOfWork(() =>
        {
            using (_unitOfWorkManager.Current.SetTenantId(null))
            {
                var userAccount = _userAccountRepository.FirstOrDefault(
                    ua => ua.TenantId == eventData.Entity.TenantId && ua.UserId == eventData.Entity.Id
                );

                if (userAccount == null)
                {
                    _userAccountRepository.Insert(new UserAccount
                    {
                        TenantId = eventData.Entity.TenantId,
                        UserName = eventData.Entity.UserName,
                        UserId = eventData.Entity.Id,
                        EmailAddress = eventData.Entity.EmailAddress,
                        PhoneNumber = eventData.Entity.PhoneNumber
                    });
                }
                else
                {
                    userAccount.UserName = eventData.Entity.UserName;
                    userAccount.EmailAddress = eventData.Entity.EmailAddress;
                    userAccount.PhoneNumber = eventData.Entity.PhoneNumber;
                    _userAccountRepository.Update(userAccount);
                }
            }
        });
    }

    /// <summary>
    /// Handles deletion event of user
    /// </summary>
    /// <param name="eventData"></param>
    public virtual void HandleEvent(EntityDeletedEventData<User> eventData)
    {
        _unitOfWorkManager.WithUnitOfWork(() =>
        {
            using (_unitOfWorkManager.Current.SetTenantId(null))
            {
                var userAccount = _userAccountRepository.FirstOrDefault(
                    ua => ua.TenantId == eventData.Entity.TenantId && ua.UserId == eventData.Entity.Id
                );

                if (userAccount != null)
                {
                    _userAccountRepository.Delete(userAccount);
                }
            }
        });
    }

    /// <summary>
    /// Handles update event of user
    /// </summary>
    /// <param name="eventData"></param>
    public virtual void HandleEvent(EntityUpdatedEventData<User> eventData)
    {
        _unitOfWorkManager.WithUnitOfWork(() =>
        {
            using (_unitOfWorkManager.Current.SetTenantId(null))
            {
                var userAccount = _userAccountRepository.FirstOrDefault(ua =>
                    ua.TenantId == eventData.Entity.TenantId && ua.UserId == eventData.Entity.Id
                );

                if (userAccount != null)
                {
                    userAccount.UserName = eventData.Entity.UserName;
                    userAccount.EmailAddress = eventData.Entity.EmailAddress;
                    userAccount.PhoneNumber = eventData.Entity.PhoneNumber;
                    _userAccountRepository.Update(userAccount);
                }
            }
        });
    }

    /// <summary>
    /// Handles deletion event of tenant
    /// </summary>
    /// <param name="eventData"></param>
    public virtual void HandleEvent(EntityDeletedEventData<Tenant> eventData)
    {
        _unitOfWorkManager.WithUnitOfWork(() =>
        {
            using (_unitOfWorkManager.Current.SetTenantId(null))
            {
                _userAccountRepository.Delete(ua => ua.TenantId == eventData.Entity.Id);
            }
        });
    }
}