using CMSMicroservice.Application.Common;
using CMSMicroservice.Application.Common.Exceptions;
using CMSMicroservice.Application.Common.Interfaces;
using CMSMicroservice.Domain.Entities;
using CMSMicroservice.Domain.Enums;
using MediatR;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

namespace CMSMicroservice.Application.WalletCQ.Commands.VerifyCreditWalletCharge;

public class VerifyCreditWalletChargeCommandHandler
    : IRequestHandler<VerifyCreditWalletChargeCommand, bool>
{
    private readonly IApplicationDbContext _context;
    private readonly IPaymentGatewayService _paymentGateway;
    private readonly ILogger<VerifyCreditWalletChargeCommandHandler> _logger;
    private readonly IUserPaymentLock _paymentLock;

    public VerifyCreditWalletChargeCommandHandler(
        IApplicationDbContext context,
        IPaymentGatewayService paymentGateway,
        ILogger<VerifyCreditWalletChargeCommandHandler> logger,
        IUserPaymentLock paymentLock)
    {
        _context = context;
        _paymentGateway = paymentGateway;
        _logger = logger;
        _paymentLock = paymentLock;
    }

    public Task<bool> Handle(
        VerifyCreditWalletChargeCommand request,
        CancellationToken cancellationToken) =>
        _paymentLock.ExecuteAsync(
            PaymentLockScopes.Verify(request.UserId, request.Authority),
            PaymentLockStrategy.WaitForRelease,
            ct => HandleCore(request, ct),
            cancellationToken);

    private async Task<bool> HandleCore(
        VerifyCreditWalletChargeCommand request,
        CancellationToken cancellationToken)
    {
        try
        {
            _logger.LogInformation(
                "Verifying credit wallet charge. UserId: {UserId}, Amount: {Amount}, Authority: {Authority}",
                request.UserId,
                request.Amount,
                request.Authority);

            var user = await _context.Users
                .Include(u => u.ClubMembership)
                .FirstOrDefaultAsync(u => u.Id == request.UserId, cancellationToken)
                ?? throw new NotFoundException(nameof(User), request.UserId);

            if (user.ClubMembership?.IsActive != true)
            {
                throw new BadRequestException(
                    "برای شارژ کیف پول اصلی ابتدا باید پکیج را خریداری کرده و قرارداد باشگاه مشتریان را امضا کنید.");
            }

            var paymentTx = await _context.PaymentTransactions
                .FirstOrDefaultAsync(pt => pt.Authority == request.Authority, cancellationToken);

            if (paymentTx?.PaymentStatus == true)
            {
                _logger.LogWarning("PaymentTransaction already verified: {Authority}", request.Authority);
                return true;
            }

            var amountInToman = (decimal)(paymentTx?.Amount ?? 0);

            var verifyResult = await _paymentGateway.VerifyPaymentAsync(
                request.Authority,
                "OK",
                amountInToman,
                cancellationToken);

            if (paymentTx != null)
            {
                paymentTx.PaymentStatus = verifyResult.IsSuccess;
                paymentTx.VerificationStatusCode = verifyResult.VerificationCode;
                paymentTx.VerificationStatusMessage = verifyResult.Message;
                paymentTx.CardPan = verifyResult.CardPan;
                paymentTx.CardHash = verifyResult.CardHash;
                paymentTx.RefId = verifyResult.TrackingCode;
            }

            if (!verifyResult.IsSuccess)
            {
                _logger.LogWarning(
                    "Credit wallet charge verification failed for UserId {UserId}: {Message}",
                    request.UserId,
                    verifyResult.Message);

                throw new Exception($"تراکنش ناموفق: {verifyResult.Message}");
            }

            var wallet = await _context.UserWallets
                .FirstOrDefaultAsync(w => w.UserId == user.Id, cancellationToken)
                ?? throw new NotFoundException($"کیف پول کاربر با شناسه {request.UserId} یافت نشد");

            var oldBalance = wallet.Balance;
            wallet.Balance += request.Amount;

            _logger.LogInformation(
                "Charging credit balance for UserId {UserId}: {OldBalance} -> {NewBalance}",
                request.UserId,
                oldBalance,
                wallet.Balance);

            var transaction = new Transaction
            {
                Amount = request.Amount,
                Description = $"شارژ کیف پول اصلی - کاربر {user.Id}",
                PaymentStatus = PaymentStatus.Success,
                PaymentDate = DateTime.Now,
                RefId = verifyResult.RefId,
                Type = TransactionType.CreditWalletCharge
            };

            _context.Transactions.Add(transaction);
            await _context.SaveChangesAsync(cancellationToken);

            _context.UserWalletHistories.Add(new Domain.Entities.UserWalletHistory
            {
                WalletId = wallet.Id,
                CurrentBalance = wallet.Balance,
                ChangeValue = request.Amount,
                CurrentNetworkBalance = wallet.NetworkBalance,
                ChangeNerworkValue = 0,
                CurrentDiscountBalance = wallet.DiscountBalance,
                ChangeDiscountValue = 0,
                IsIncrease = true,
                RefrenceId = transaction.Id
            });
            await _context.SaveChangesAsync(cancellationToken);

            if (paymentTx != null)
            {
                paymentTx.TransactionId = transaction.Id;
                await _context.SaveChangesAsync(cancellationToken);
            }

            _logger.LogInformation(
                "Credit wallet charged successfully. UserId: {UserId}, TransactionId: {TransactionId}, RefId: {RefId}",
                user.Id,
                transaction.Id,
                verifyResult.RefId);

            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(
                ex,
                "Error in VerifyCreditWalletChargeCommand for UserId: {UserId}",
                request.UserId);
            throw;
        }
    }
}
