/// <summary>
/// 數(shù)據(jù)庫上下文（EF Core）
/// </summary>
public class ApplicationDbContext : DbContext
{
    public DbSet<RequestLog> RequestLogs { get; set; }

    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }
}

/// <summary>
/// 請求日志實(shí)體
/// </summary>
public class RequestLog
{
    [Key] // 唯一主鍵約束
    public string RequestId { get; set; } = Guid.NewGuid().ToString();
    public DateTime Timestamp { get; set; } = DateTime.UtcNow;
    public string BusinessType { get; set; } // 業(yè)務(wù)類型（如"Payment"）
}

/// <summary>
/// 服務(wù)層邏輯
/// </summary>
public class PaymentService
{
    private readonly ApplicationDbContext _context;

    public PaymentService(ApplicationDbContext context)
    {
        _context = context;
    }

    /// <summary>
    /// 處理支付請求
    /// </summary>
    /// <param name="requestId">唯一請求ID</param>
    /// <returns></returns>
    public async Task<bool> ProcessPayment(string requestId)
    {
        try
        {
            // 1. 嘗試插入請求記錄（利用主鍵約束防重）
            var log = new RequestLog
            {
                RequestId = requestId,
                BusinessType = "Payment"
            };

            await _context.RequestLogs.AddAsync(log);
            await _context.SaveChangesAsync(); // 若RequestId已存在，會拋出DbUpdateException

            // 2. 執(zhí)行核心業(yè)務(wù)邏輯（如扣款）
            await DeductBalanceAsync();

            return true;
        }
        catch (DbUpdateException ex)
        {
            // 3. 捕獲主鍵沖突異常，判定為重復(fù)請求
            Console.WriteLine($"請求ID {requestId} 已處理過。異常：{ex.Message}");
            return false;
        }
    }

    private async Task DeductBalanceAsync()
    {
        // 模擬扣款邏輯
        await Task.Delay(100);
    }
}

/// <summary>
/// 庫存實(shí)體
/// </summary>
public class ProductStock
{
    [Key]
    public int ProductId { get; set; }
    public int Stock { get; set; }
    public int Version { get; set; } // 樂觀鎖版本號
}

/// <summary>
/// 庫存服務(wù)
/// </summary>
public class StockService
{
    private readonly ApplicationDbContext _context;

    public StockService(ApplicationDbContext context)
    {
        _context = context;
    }

    /// <summary>
    /// 扣減庫存（樂觀鎖）
    /// </summary>
    /// <param name="productId">商品ID</param>
    /// <param name="quantity">扣減數(shù)量</param>
    /// <returns></returns>
    public async Task<bool> DeductStock(int productId, int quantity)
    {
        while (true)
        {
            try
            {
                // 1. 查詢當(dāng)前庫存及版本號
                var product = await _context.ProductStocks
                    .FirstOrDefaultAsync(p => p.ProductId == productId);

                if (product == null || product.Stock < quantity)
                    return false;

                // 2. 執(zhí)行扣減并更新版本號（原子操作）
                product.Stock -= quantity;
                product.Version += 1;

                await _context.SaveChangesAsync();
                return true;
            }
            catch (DbUpdateConcurrencyException ex)
            {
                // 3. 版本沖突時重試
                Console.WriteLine("檢測到并發(fā)修改，重試中...");
                await Task.Delay(10); // 避免忙等待
            }
        }
    }
}

/// <summary>
/// Redis Token服務(wù)
/// </summary>
public class TokenService
{
    private readonly IDatabase _redisDb;

    public TokenService(IConnectionMultiplexer redis)
    {
        _redisDb = redis.GetDatabase();
    }

    /// <summary>
    /// 生成Token并緩存
    /// </summary>
    /// <param name="businessKey">業(yè)務(wù)標(biāo)識（如用戶ID+訂單號）</param>
    /// <param name="expireMinutes">過期時間（分鐘）</param>
    /// <returns></returns>
    public string GenerateToken(string businessKey, int expireMinutes = 5)
    {
        var token = Guid.NewGuid().ToString();
        var key = $"idempotent:token:{businessKey}";

        _redisDb.StringSet(key, token, TimeSpan.FromMinutes(expireMinutes));
        return token;
    }

    /// <summary>
    /// 驗(yàn)證并消耗Token
    /// </summary>
    /// <param name="businessKey"></param>
    /// <param name="token"></param>
    /// <returns></returns>
    public bool ValidateToken(string businessKey, string token)
    {
        var key = $"idempotent:token:{businessKey}";
        var storedToken = _redisDb.StringGet(key);

        if (storedToken.IsNullOrEmpty || !storedToken.ToString().Equals(token))
            return false;

        // 原子刪除Token（防止并發(fā)問題）
        _redisDb.KeyDelete(key);
        return true;
    }
}

/// <summary>
/// 控制器示例
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class OrderController : ControllerBase
{
    private readonly TokenService _tokenService;
    private readonly ApplicationDbContext _context;

    public OrderController(TokenService tokenService, ApplicationDbContext context)
    {
        _tokenService = tokenService;
        _context = context;
    }

    [HttpPost("submit")]
    public async Task<IActionResult> SubmitOrder([FromBody] OrderRequest request)
    {
        var businessKey = $"{request.UserId}:{request.OrderNo}";
        var isValid = _tokenService.ValidateToken(businessKey, request.Token);

        if (!isValid)
            return BadRequest("重復(fù)提交或Token無效");

        // 執(zhí)行核心邏輯
        await CreateOrderAsync(request);
        return Ok("訂單提交成功");
    }
}

/// <summary>
/// Redis分布式鎖服務(wù)
/// </summary>
public class DistributedLockService
{
    private readonly IConnectionMultiplexer _redis;

    public DistributedLockService(IConnectionMultiplexer redis)
    {
        _redis = redis;
    }

    /// <summary>
    /// 嘗試獲取分布式鎖
    /// </summary>
    /// <param name="lockKey">鎖標(biāo)識</param>
    /// <param name="lockValue">鎖值（通常為請求ID）</param>
    /// <param name="expiry">過期時間</param>
    /// <returns></returns>
    public async Task<bool> TryAcquireLock(string lockKey, string lockValue, TimeSpan expiry)
    {
        var redisDb = _redis.GetDatabase();
        return await redisDb.StringSetAsync(lockKey, lockValue, expiry, When.NotExists);
    }

    /// <summary>
    /// 釋放分布式鎖
    /// </summary>
    public async Task ReleaseLock(string lockKey, string lockValue)
    {
        var script = @"
            if redis.call('get', KEYS[1]) == ARGV[1] then
                return redis.call('del', KEYS[1])
            else
                return 0
            end
        ";

        var redisDb = _redis.GetDatabase();
        await redisDb.ScriptEvaluateAsync(script, new[] { lockKey }, new[] { lockValue });
    }
}

/// <summary>
/// 服務(wù)層示例
/// </summary>
public class TransferService
{
    private readonly DistributedLockService _lockService;
    private readonly ApplicationDbContext _context;

    public TransferService(DistributedLockService lockService, ApplicationDbContext context)
    {
        _lockService = lockService;
        _context = context;
    }

    /// <summary>
    /// 執(zhí)行轉(zhuǎn)賬（分布式鎖保護(hù)）
    /// </summary>
    public async Task<bool> ExecuteTransfer(string transferId, decimal amount)
    {
        var lockKey = $"transfer:{transferId}";
        var requestId = Guid.NewGuid().ToString();
        var expiry = TimeSpan.FromSeconds(30); // 鎖超時時間

        try
        {
            // 1. 嘗試獲取鎖
            if (!await _lockService.TryAcquireLock(lockKey, requestId, expiry))
                return false; // 已被其他線程處理

            // 2. 執(zhí)行核心邏輯
            await TransferMoneyAsync(amount);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"轉(zhuǎn)賬失?。簕ex.Message}");
            return false;
        }
        finally
        {
            // 3. 釋放鎖
            await _lockService.ReleaseLock(lockKey, requestId);
        }
    }

    private async Task TransferMoneyAsync(decimal amount)
    {
        // 模擬轉(zhuǎn)賬邏輯
        await Task.Delay(200);
    }
}