using Dpz.Core.Entity.Base.ExpressTreeQuery;
using Dpz.Core.Public.ViewModel.Request;
using Dpz.Core.Public.ViewModel.Response;
using Medallion.Threading;

namespace Dpz.Core.Service.RepositoryServiceImpl;

public class AccountLoginHistoryService(
    IRepository<AccountLoginHistory> repository,
    IHttpContextAccessor httpContextAccessor,
    IDistributedLockProvider distributedLockProvider,
    IConfiguration configuration
) : IAccountLoginHistoryService
{
    private static readonly HashSet<LoginResultStatus> FailStatuses =
    [
        LoginResultStatus.AccountOrPasswordError,
        LoginResultStatus.PinCodeError,
        LoginResultStatus.AccountLocked,
        LoginResultStatus.AccountDisabled,
        LoginResultStatus.PasskeyUserVerificationFailed,
    ];

    private async Task AddAsync(string account, LoginMethod method, LoginResultStatus status)
    {
        await using (await distributedLockProvider.AcquireLockAsync($"Login:Fail:{account}"))
        {
            var ipAddress = httpContextAccessor.HttpContext?.Request.GetIpAddress();
            var userAgent = httpContextAccessor.HttpContext?.Request.Headers.UserAgent;
            var sessionId = httpContextAccessor.HttpContext?.Request.Cookies["SessionId"];
            await repository.InsertAsync(
                new AccountLoginHistory
                {
                    Account = account,
                    IpAddress = ipAddress,
                    UserAgent = userAgent,
                    SessionId = sessionId,
                    Method = method,
                    Status = status,
                    CreateTime = DateTime.Now,
                    LastUpdateTime = DateTime.Now,
                }
            );
        }
    }

    public async Task LoginFailAsync(
        string account,
        LoginMethod method = LoginMethod.Password,
        LoginResultStatus status = LoginResultStatus.AccountOrPasswordError
    )
    {
        if (!FailStatuses.Contains(status))
        {
            throw new NotSupportedException();
        }
        await AddAsync(account, method, status);
    }

    public async Task PinCodeErrorAsync(string account, LoginMethod method = LoginMethod.Password)
    {
        await AddAsync(account, method, LoginResultStatus.PinCodeError);
    }

    public async Task AccountLockedAsync(string account, LoginMethod method = LoginMethod.Password)
    {
        await AddAsync(account, method, LoginResultStatus.AccountLocked);
    }

    public async Task AccountDisabledAsync(
        string account,
        LoginMethod method = LoginMethod.Password
    )
    {
        await AddAsync(account, method, LoginResultStatus.AccountDisabled);
    }

    public async Task SuccessAsync(string account, LoginMethod method = LoginMethod.Password)
    {
        await using (await distributedLockProvider.AcquireLockAsync($"Login:Success:{account}"))
        {
            var httpContext = httpContextAccessor.HttpContext;
            var ipAddress = httpContext?.Request.GetIpAddress();
            var userAgent = httpContext?.Request.Headers.UserAgent;
            var sessionId = httpContext?.Request.Cookies["SessionId"];

            if (!string.IsNullOrWhiteSpace(sessionId))
            {
                var window = TimeSpan.FromSeconds(60);
                var recent = await repository
                    .SearchFor(x =>
                        x.Account == account
                        && x.SessionId == sessionId
                        && x.Status == LoginResultStatus.Success
                        && x.CreateTime >= DateTime.Now.Add(-window)
                    )
                    .FirstOrDefaultAsync();
                if (recent != null)
                {
                    return;
                }
            }

            await repository.InsertAsync(
                new AccountLoginHistory
                {
                    Account = account,
                    IpAddress = ipAddress,
                    UserAgent = userAgent,
                    SessionId = sessionId,
                    Method = method,
                    Status = LoginResultStatus.Success,
                    CreateTime = DateTime.Now,
                    LastUpdateTime = DateTime.Now,
                }
            );
        }
    }

    public async Task<bool> LockedAsync(string account)
    {
        var endTime = DateTime.Now;
        var lockPeriod = configuration.GetValue("AccountLockPeriodHours", 12);
        var startTime = endTime.AddHours(-lockPeriod);
        var count = await repository
            .SearchFor(x =>
                x.Account == account
                && x.Status == LoginResultStatus.AccountOrPasswordError
                && x.CreateTime >= startTime
                && x.CreateTime < endTime
            )
            .CountAsync();
        var maxCount = configuration.GetValue("AccountLoginFailTryMaxCount", 3);
        return count >= maxCount;
    }

    public async Task<IPagedList<AccountLoginHistoryResponse>> GetPageAsync(
        AccountLoginHistoryRequest request
    )
    {
        var filter = GenerateConditionFilter.GenerateConditionExpressionTree<
            AccountLoginHistory,
            AccountLoginHistoryRequest
        >(request);
        return await repository
            .SearchFor(filter)
            .OrderByDescending(x => x.CreateTime)
            .ToPagedListAsync<AccountLoginHistory, AccountLoginHistoryResponse>(
                request.PageIndex,
                request.PageSize
            );
    }
}