using FsCheck;
using FsCheck.Xunit;
using MiAssessment.Core.Interfaces;
using MiAssessment.Core.Services;
using MiAssessment.Model.Data;
using MiAssessment.Model.Entities;
using MiAssessment.Model.Models.Payment;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Moq;
using Xunit;

namespace MiAssessment.Tests.Core;

/// <summary>
/// PaymentOrderService 属性测试
/// Feature: framework-template
/// 
/// Property 1: Payment Order Creation Integrity
/// *For any* payment order creation request with valid user ID, order type, and amount, the created order SHALL have:
/// - A unique order number that does not exist in the database
/// - The order_type field correctly set to the requested type
/// - The amount field correctly set to the requested amount
/// - The biz_data field correctly storing the provided JSON data
/// **Validates: Requirements 5.1, 5.2, 5.3**
/// 
/// Property 2: Payment Order State Transition
/// *For any* payment order that receives a successful payment callback:
/// - The status SHALL be updated from 0 (pending) to 1 (paid)
/// - The paid_at timestamp SHALL be set
/// - The transaction_id SHALL be recorded
/// - The reward processing SHALL be triggered
/// - If reward succeeds, reward_status SHALL be 1 and reward_at SHALL be set
/// - If reward fails, reward_status SHALL be 2
/// **Validates: Requirements 5.4, 5.5, 5.6, 5.7**
/// </summary>
public class PaymentOrderServicePropertyTests
{
    private readonly Mock<ILogger<PaymentOrderService>> _mockLogger = new();

    /// <summary>
    /// 订单状态：待支付
    /// </summary>
    private const byte StatusPending = 0;

    /// <summary>
    /// 订单状态：已支付
    /// </summary>
    private const byte StatusPaid = 1;

    /// <summary>
    /// 奖励状态：未发放
    /// </summary>
    private const byte RewardStatusPending = 0;

    /// <summary>
    /// 奖励状态：已发放
    /// </summary>
    private const byte RewardStatusSuccess = 1;

    /// <summary>
    /// 奖励状态：发放失败
    /// </summary>
    private const byte RewardStatusFailed = 2;

    #region Property 1: Payment Order Creation Integrity

    /// <summary>
    /// Feature: framework-template, Property 1: Payment Order Creation Integrity
    /// 
    /// Property 1.1: Created order has unique order number
    /// A unique order number that does not exist in the database
    /// 
    /// **Validates: Requirements 5.1**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool CreateOrder_ShouldGenerateUniqueOrderNo(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request1 = CreateValidRequest(userId.Get, seed.Get);
        var request2 = CreateValidRequest(userId.Get, seed.Get + 1);

        // Act: Create two orders
        var order1 = service.CreateOrderAsync(request1).GetAwaiter().GetResult();
        var order2 = service.CreateOrderAsync(request2).GetAwaiter().GetResult();

        // Assert: Order numbers should be unique
        return order1.OrderNo != order2.OrderNo;
    }

    /// <summary>
    /// Feature: framework-template, Property 1: Payment Order Creation Integrity
    /// 
    /// Property 1.2: Created order has correct order_type
    /// The order_type field correctly set to the requested type
    /// 
    /// **Validates: Requirements 5.2**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool CreateOrder_ShouldSetCorrectOrderType(PositiveInt userId, NonEmptyString orderType, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        // Generate a valid order type (alphanumeric with underscores)
        var validOrderType = GenerateValidOrderType(orderType.Get, seed.Get);
        var request = CreateValidRequest(userId.Get, seed.Get);
        request.OrderType = validOrderType;

        // Act
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        // Assert: Order type should match the request
        return order.OrderType == validOrderType;
    }

    /// <summary>
    /// Feature: framework-template, Property 1: Payment Order Creation Integrity
    /// 
    /// Property 1.3: Created order has correct amount
    /// The amount field correctly set to the requested amount
    /// 
    /// **Validates: Requirements 5.3**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool CreateOrder_ShouldSetCorrectAmount(PositiveInt userId, PositiveInt amountCents, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        // Generate a valid amount (convert cents to decimal to avoid floating point issues)
        var amount = Math.Round((decimal)(amountCents.Get % 100000 + 1) / 100, 2);
        var request = CreateValidRequest(userId.Get, seed.Get);
        request.Amount = amount;

        // Act
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        // Assert: Amount should match the request
        return order.Amount == amount;
    }

    /// <summary>
    /// Feature: framework-template, Property 1: Payment Order Creation Integrity
    /// 
    /// Property 1.4: Created order has correct biz_data
    /// The biz_data field correctly storing the provided JSON data
    /// 
    /// **Validates: Requirements 5.3**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool CreateOrder_ShouldSetCorrectBizData(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        // Generate valid JSON biz_data
        var bizData = $"{{\"product_id\":{seed.Get},\"quantity\":{(seed.Get % 10) + 1}}}";
        var request = CreateValidRequest(userId.Get, seed.Get);
        request.BizData = bizData;

        // Act
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        // Assert: BizData should match the request
        return order.BizData == bizData;
    }

    /// <summary>
    /// Feature: framework-template, Property 1: Payment Order Creation Integrity
    /// 
    /// Property 1.5: Created order has initial status of pending (0)
    /// The created order should have status = 0 (pending)
    /// 
    /// **Validates: Requirements 5.1**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool CreateOrder_ShouldHavePendingStatus(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request = CreateValidRequest(userId.Get, seed.Get);

        // Act
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        // Assert: Status should be pending (0)
        return order.Status == StatusPending;
    }

    /// <summary>
    /// Feature: framework-template, Property 1: Payment Order Creation Integrity
    /// 
    /// Property 1.6: Created order has initial reward_status of pending (0)
    /// The created order should have reward_status = 0 (not issued)
    /// 
    /// **Validates: Requirements 5.1**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool CreateOrder_ShouldHavePendingRewardStatus(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request = CreateValidRequest(userId.Get, seed.Get);

        // Act
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        // Assert: RewardStatus should be pending (0)
        return order.RewardStatus == RewardStatusPending;
    }

    /// <summary>
    /// Feature: framework-template, Property 1: Payment Order Creation Integrity
    /// 
    /// Property 1.7: Order number does not exist in database before creation
    /// A unique order number that does not exist in the database
    /// 
    /// **Validates: Requirements 5.1**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool CreateOrder_OrderNoShouldNotExistBeforeCreation(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request = CreateValidRequest(userId.Get, seed.Get);

        // Act
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        // Verify: The order number should exist exactly once in the database
        var count = dbContext.PaymentOrders.Count(o => o.OrderNo == order.OrderNo);

        // Assert: Should exist exactly once
        return count == 1;
    }

    #endregion

    #region Property 2: Payment Order State Transition

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.1: Payment success updates status from 0 to 1
    /// The status SHALL be updated from 0 (pending) to 1 (paid)
    /// 
    /// **Validates: Requirements 5.4**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_ShouldUpdateStatusToPaid(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request = CreateValidRequest(userId.Get, seed.Get);
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act
        var result = service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Refresh the order from database
        var updatedOrder = service.GetOrderByNoAsync(order.OrderNo).GetAwaiter().GetResult();

        // Assert: Status should be updated to paid (1)
        return result && updatedOrder != null && updatedOrder.Status == StatusPaid;
    }

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.2: Payment success sets paid_at timestamp
    /// The paid_at timestamp SHALL be set
    /// 
    /// **Validates: Requirements 5.4**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_ShouldSetPaidAtTimestamp(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request = CreateValidRequest(userId.Get, seed.Get);
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var beforePayment = DateTime.Now.AddSeconds(-1);
        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act
        service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Refresh the order from database
        var updatedOrder = service.GetOrderByNoAsync(order.OrderNo).GetAwaiter().GetResult();
        var afterPayment = DateTime.Now.AddSeconds(1);

        // Assert: PaidAt should be set and within reasonable time range
        return updatedOrder != null &&
               updatedOrder.PaidAt.HasValue &&
               updatedOrder.PaidAt.Value >= beforePayment &&
               updatedOrder.PaidAt.Value <= afterPayment;
    }

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.3: Payment success records transaction_id
    /// The transaction_id SHALL be recorded
    /// 
    /// **Validates: Requirements 5.4**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_ShouldRecordTransactionId(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request = CreateValidRequest(userId.Get, seed.Get);
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act
        service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Refresh the order from database
        var updatedOrder = service.GetOrderByNoAsync(order.OrderNo).GetAwaiter().GetResult();

        // Assert: TransactionId should be recorded
        return updatedOrder != null && updatedOrder.TransactionId == transactionId;
    }

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.4: Payment success with successful reward handler sets reward_status to 1
    /// If reward succeeds, reward_status SHALL be 1 and reward_at SHALL be set
    /// 
    /// **Validates: Requirements 5.5, 5.6**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_WithSuccessfulReward_ShouldSetRewardStatusToSuccess(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        
        var orderType = $"test_reward_success_{seed.Get % 100}";
        var rewardData = $"{{\"reward_id\":{seed.Get}}}";
        
        // Create a mock reward handler that succeeds
        var mockHandler = new Mock<IPaymentRewardHandler>();
        mockHandler.Setup(h => h.OrderType).Returns(orderType);
        mockHandler.Setup(h => h.ProcessRewardAsync(It.IsAny<PaymentOrder>()))
            .ReturnsAsync(RewardResult.Ok(rewardData));

        var service = CreateService(dbContext, new[] { mockHandler.Object });

        var request = CreateValidRequest(userId.Get, seed.Get);
        request.OrderType = orderType;
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act
        service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Refresh the order from database
        var updatedOrder = service.GetOrderByNoAsync(order.OrderNo).GetAwaiter().GetResult();

        // Assert: RewardStatus should be success (1) and RewardAt should be set
        return updatedOrder != null &&
               updatedOrder.RewardStatus == RewardStatusSuccess &&
               updatedOrder.RewardAt.HasValue;
    }

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.5: Payment success with failed reward handler sets reward_status to 2
    /// If reward fails, reward_status SHALL be 2
    /// 
    /// **Validates: Requirements 5.7**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_WithFailedReward_ShouldSetRewardStatusToFailed(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        
        var orderType = $"test_reward_fail_{seed.Get % 100}";
        var errorMessage = $"Reward processing failed for seed {seed.Get}";
        
        // Create a mock reward handler that fails
        var mockHandler = new Mock<IPaymentRewardHandler>();
        mockHandler.Setup(h => h.OrderType).Returns(orderType);
        mockHandler.Setup(h => h.ProcessRewardAsync(It.IsAny<PaymentOrder>()))
            .ReturnsAsync(RewardResult.Fail(errorMessage));

        var service = CreateService(dbContext, new[] { mockHandler.Object });

        var request = CreateValidRequest(userId.Get, seed.Get);
        request.OrderType = orderType;
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act
        service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Refresh the order from database
        var updatedOrder = service.GetOrderByNoAsync(order.OrderNo).GetAwaiter().GetResult();

        // Assert: RewardStatus should be failed (2)
        return updatedOrder != null && updatedOrder.RewardStatus == RewardStatusFailed;
    }

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.6: Payment success triggers reward processing
    /// The reward processing SHALL be triggered
    /// 
    /// **Validates: Requirements 5.5**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_ShouldTriggerRewardProcessing(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        
        var orderType = $"test_trigger_{seed.Get % 100}";
        var rewardProcessed = false;
        
        // Create a mock reward handler that tracks if it was called
        var mockHandler = new Mock<IPaymentRewardHandler>();
        mockHandler.Setup(h => h.OrderType).Returns(orderType);
        mockHandler.Setup(h => h.ProcessRewardAsync(It.IsAny<PaymentOrder>()))
            .Callback(() => rewardProcessed = true)
            .ReturnsAsync(RewardResult.Ok());

        var service = CreateService(dbContext, new[] { mockHandler.Object });

        var request = CreateValidRequest(userId.Get, seed.Get);
        request.OrderType = orderType;
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act
        service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Assert: Reward handler should have been called
        return rewardProcessed;
    }

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.7: Idempotent payment success handling
    /// Processing the same payment twice should not change the order state
    /// 
    /// **Validates: Requirements 5.4**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_ShouldBeIdempotent(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        var service = CreateService(dbContext);

        var request = CreateValidRequest(userId.Get, seed.Get);
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act: Process payment twice
        var result1 = service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();
        var result2 = service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Refresh the order from database
        var updatedOrder = service.GetOrderByNoAsync(order.OrderNo).GetAwaiter().GetResult();

        // Assert: Both calls should succeed and order should be in paid state
        return result1 && result2 && updatedOrder != null && updatedOrder.Status == StatusPaid;
    }

    /// <summary>
    /// Feature: framework-template, Property 2: Payment Order State Transition
    /// 
    /// Property 2.8: Successful reward stores reward_data
    /// If reward succeeds, reward_data SHALL contain the reward information
    /// 
    /// **Validates: Requirements 5.6**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool HandlePaymentSuccess_WithSuccessfulReward_ShouldStoreRewardData(PositiveInt userId, PositiveInt seed)
    {
        // Arrange
        using var dbContext = CreateDbContext();
        
        var orderType = $"test_reward_data_{seed.Get % 100}";
        var rewardData = $"{{\"diamonds\":{seed.Get % 1000 + 100},\"bonus\":{seed.Get % 50}}}";
        
        // Create a mock reward handler that returns reward data
        var mockHandler = new Mock<IPaymentRewardHandler>();
        mockHandler.Setup(h => h.OrderType).Returns(orderType);
        mockHandler.Setup(h => h.ProcessRewardAsync(It.IsAny<PaymentOrder>()))
            .ReturnsAsync(RewardResult.Ok(rewardData));

        var service = CreateService(dbContext, new[] { mockHandler.Object });

        var request = CreateValidRequest(userId.Get, seed.Get);
        request.OrderType = orderType;
        var order = service.CreateOrderAsync(request).GetAwaiter().GetResult();

        var transactionId = $"TX_{seed.Get}_{DateTime.Now.Ticks}";

        // Act
        service.HandlePaymentSuccessAsync(order.OrderNo, transactionId, order.Amount).GetAwaiter().GetResult();

        // Refresh the order from database
        var updatedOrder = service.GetOrderByNoAsync(order.OrderNo).GetAwaiter().GetResult();

        // Assert: RewardData should be stored
        return updatedOrder != null && updatedOrder.RewardData == rewardData;
    }

    #endregion

    #region Helper Methods

    /// <summary>
    /// 创建内存数据库上下文
    /// </summary>
    private MiAssessmentDbContext CreateDbContext()
    {
        var options = new DbContextOptionsBuilder<MiAssessmentDbContext>()
            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
            .Options;

        return new MiAssessmentDbContext(options);
    }

    /// <summary>
    /// 创建 PaymentOrderService 实例
    /// </summary>
    private PaymentOrderService CreateService(MiAssessmentDbContext dbContext, IEnumerable<IPaymentRewardHandler>? handlers = null)
    {
        return new PaymentOrderService(
            dbContext,
            handlers ?? Array.Empty<IPaymentRewardHandler>(),
            _mockLogger.Object);
    }

    /// <summary>
    /// 创建有效的支付订单请求
    /// </summary>
    private CreatePaymentOrderRequest CreateValidRequest(int userId, int seed)
    {
        return new CreatePaymentOrderRequest
        {
            UserId = Math.Max(1, userId), // Ensure positive user ID
            OrderType = $"test_order_{seed % 100}",
            Title = $"测试订单 {seed}",
            Amount = Math.Round((decimal)((seed % 10000) + 100) / 100, 2), // 1.00 to 101.00
            PayMethod = "wechat",
            BizData = $"{{\"seed\":{seed}}}"
        };
    }

    /// <summary>
    /// 生成有效的订单类型（只包含字母、数字和下划线）
    /// </summary>
    private string GenerateValidOrderType(string input, int seed)
    {
        // Filter to only alphanumeric and underscore characters
        var filtered = new string(input.Where(c => char.IsLetterOrDigit(c) || c == '_').ToArray());
        
        // Ensure it's not empty and has reasonable length
        if (string.IsNullOrEmpty(filtered))
        {
            filtered = "order";
        }
        
        // Limit length and add seed for uniqueness
        var maxLength = Math.Min(filtered.Length, 20);
        return $"{filtered.Substring(0, maxLength)}_{seed % 1000}";
    }

    #endregion
}