using FsCheck;
using FsCheck.Xunit;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using MiAssessment.Admin.Business.Data;
using MiAssessment.Admin.Business.Entities;
using MiAssessment.Admin.Business.Models.AssessmentRecord;
using MiAssessment.Admin.Business.Services;
using Moq;
using Xunit;

namespace MiAssessment.Tests.Admin;

/// <summary>
/// 测评记录服务属性测试
/// 验证测评记录服务的正确性属性
/// </summary>
public class AssessmentRecordServicePropertyTests
{
    private readonly Mock<ILogger<AssessmentRecordService>> _mockLogger = new();

    #region 枚举映射字典（用于验证）

    /// <summary>
    /// 状态名称映射
    /// </summary>
    private static readonly Dictionary<int, string> StatusNames = new()
    {
        { 1, "待测评" },
        { 2, "测评中" },
        { 3, "生成中" },
        { 4, "已完成" }
    };

    /// <summary>
    /// 学历阶段名称映射
    /// </summary>
    private static readonly Dictionary<int, string> EducationStageNames = new()
    {
        { 1, "小学及以下" },
        { 2, "初中" },
        { 3, "高中" },
        { 4, "大专" },
        { 5, "本科" },
        { 6, "研究生及以上" }
    };

    /// <summary>
    /// 性别名称映射
    /// </summary>
    private static readonly Dictionary<int, string> GenderNames = new()
    {
        { 1, "男" },
        { 2, "女" }
    };

    #endregion


    #region Property 1: 分页查询返回记录数不超过 PageSize

    /// <summary>
    /// Feature: admin-missing-modules, Property 1: 分页查询返回记录数不超过 PageSize
    /// *For any* assessment record dataset and valid PagedRequest (Page ≥ 1, 1 ≤ PageSize ≤ 100), 
    /// the number of items returned by GetRecordListAsync should be ≤ PageSize, 
    /// and the items should be sorted by CreateTime descending.
    /// **Validates: Requirements 1.1**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool PaginationReturnsCorrectCount_ResultCountNotExceedPageSize(PositiveInt seed, PositiveInt pageSize)
    {
        // Arrange: 创建包含多个测评记录的数据库
        using var dbContext = CreateDbContext();
        var recordCount = (seed.Get % 50) + 1; // 1-50 条记录
        var actualPageSize = Math.Min(pageSize.Get, 100); // PageSize 最大 100

        CreateTestRecords(dbContext, recordCount, seed.Get);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 执行分页查询
        var request = new AssessmentRecordQueryRequest
        {
            Page = 1,
            PageSize = actualPageSize
        };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 返回的记录数不超过 PageSize
        return result.List.Count <= actualPageSize;
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 1: 分页查询返回记录数不超过 PageSize
    /// 验证 Total 等于数据库中匹配记录的实际数量
    /// **Validates: Requirements 1.1**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool PaginationReturnsCorrectCount_TotalEqualsActualCount(PositiveInt seed)
    {
        // Arrange: 创建包含多个测评记录的数据库
        using var dbContext = CreateDbContext();
        var recordCount = (seed.Get % 50) + 1; // 1-50 条记录

        CreateTestRecords(dbContext, recordCount, seed.Get);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // 计算数据库中实际的非删除记录数量
        var actualCount = dbContext.AssessmentRecords.Count(r => !r.IsDeleted);

        // Act: 执行分页查询
        var request = new AssessmentRecordQueryRequest { Page = 1, PageSize = 10 };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: Total 等于实际数量
        return result.Total == actualCount;
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 1: 分页查询返回记录数不超过 PageSize
    /// 验证结果按 CreateTime 降序排列
    /// **Validates: Requirements 1.1**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool PaginationReturnsCorrectCount_SortedByCreateTimeDescending(PositiveInt seed)
    {
        // Arrange: 创建包含多个测评记录的数据库
        using var dbContext = CreateDbContext();
        var recordCount = (seed.Get % 20) + 5; // 5-24 条记录

        CreateTestRecords(dbContext, recordCount, seed.Get);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 执行分页查询
        var request = new AssessmentRecordQueryRequest { Page = 1, PageSize = 100 };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 结果按 CreateTime 降序排列
        if (result.List.Count <= 1) return true;

        for (int i = 0; i < result.List.Count - 1; i++)
        {
            if (result.List[i].CreateTime < result.List[i + 1].CreateTime)
            {
                return false;
            }
        }
        return true;
    }

    #endregion


    #region Property 2: 筛选条件一致性

    /// <summary>
    /// Feature: admin-missing-modules, Property 2: 筛选条件一致性
    /// *For any* assessment record dataset and any combination of filter values 
    /// (UserId, AssessmentTypeId, Status, StartDate, EndDate), 
    /// every record returned by GetRecordListAsync must satisfy all specified filter criteria simultaneously.
    /// **Validates: Requirements 1.2, 1.7**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool FilteredRecordsMatchCriteria_UserIdFilter(PositiveInt seed)
    {
        // Arrange: 创建包含多个用户的测评记录
        using var dbContext = CreateDbContext();
        var userCount = 3;
        var recordsPerUser = (seed.Get % 5) + 1;

        var userIds = CreateTestUsersAndRecords(dbContext, userCount, recordsPerUser, seed.Get);
        var targetUserId = userIds[seed.Get % userIds.Count];
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 按 UserId 筛选
        var request = new AssessmentRecordQueryRequest
        {
            Page = 1,
            PageSize = 100,
            UserId = targetUserId
        };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 所有返回的记录都属于指定用户
        return result.List.All(r => r.UserId == targetUserId);
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 2: 筛选条件一致性
    /// 验证按 AssessmentTypeId 筛选的正确性
    /// **Validates: Requirements 1.2, 1.7**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool FilteredRecordsMatchCriteria_AssessmentTypeIdFilter(PositiveInt seed)
    {
        // Arrange: 创建包含多个测评类型的记录
        using var dbContext = CreateDbContext();
        var typeCount = 3;
        var recordsPerType = (seed.Get % 5) + 1;

        var typeIds = CreateTestTypesAndRecords(dbContext, typeCount, recordsPerType, seed.Get);
        var targetTypeId = typeIds[seed.Get % typeIds.Count];
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 按 AssessmentTypeId 筛选
        var request = new AssessmentRecordQueryRequest
        {
            Page = 1,
            PageSize = 100,
            AssessmentTypeId = targetTypeId
        };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 所有返回的记录都属于指定测评类型
        return result.List.All(r => r.AssessmentTypeId == targetTypeId);
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 2: 筛选条件一致性
    /// 验证按 Status 筛选的正确性
    /// **Validates: Requirements 1.2, 1.7**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool FilteredRecordsMatchCriteria_StatusFilter(PositiveInt seed)
    {
        // Arrange: 创建包含不同状态的测评记录
        using var dbContext = CreateDbContext();
        var recordsPerStatus = (seed.Get % 5) + 1;

        CreateTestRecordsWithDifferentStatuses(dbContext, recordsPerStatus, seed.Get);
        var validStatuses = new[] { 1, 2, 3, 4 };
        var targetStatus = validStatuses[seed.Get % validStatuses.Length];
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 按 Status 筛选
        var request = new AssessmentRecordQueryRequest
        {
            Page = 1,
            PageSize = 100,
            Status = targetStatus
        };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 所有返回的记录都是指定状态
        return result.List.All(r => r.Status == targetStatus);
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 2: 筛选条件一致性
    /// 验证按日期范围筛选的正确性
    /// **Validates: Requirements 1.2, 1.7**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool FilteredRecordsMatchCriteria_DateRangeFilter(PositiveInt seed)
    {
        // Arrange: 创建跨越多天的测评记录
        using var dbContext = CreateDbContext();
        var recordCount = (seed.Get % 20) + 5;

        CreateTestRecordsWithDifferentDates(dbContext, recordCount, seed.Get);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // 设置日期范围（最近7天）
        var endDate = DateTime.Today;
        var startDate = endDate.AddDays(-7);

        // Act: 按日期范围筛选
        var request = new AssessmentRecordQueryRequest
        {
            Page = 1,
            PageSize = 100,
            StartDate = startDate,
            EndDate = endDate
        };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 所有返回的记录都在指定日期范围内
        var endDatePlusOne = endDate.AddDays(1);
        return result.List.All(r => r.CreateTime >= startDate && r.CreateTime < endDatePlusOne);
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 2: 筛选条件一致性
    /// 验证多条件组合筛选的正确性
    /// **Validates: Requirements 1.2, 1.7**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool FilteredRecordsMatchCriteria_CombinedFilters(PositiveInt seed)
    {
        // Arrange: 创建复杂的测试数据
        using var dbContext = CreateDbContext();
        var userCount = 2;
        var recordsPerUser = 5;

        var userIds = CreateTestUsersAndRecordsWithStatuses(dbContext, userCount, recordsPerUser, seed.Get);
        var targetUserId = userIds[0];
        var targetStatus = (seed.Get % 4) + 1; // 1-4
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 组合筛选
        var request = new AssessmentRecordQueryRequest
        {
            Page = 1,
            PageSize = 100,
            UserId = targetUserId,
            Status = targetStatus
        };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 所有返回的记录都满足所有筛选条件
        return result.List.All(r => r.UserId == targetUserId && r.Status == targetStatus);
    }

    #endregion


    #region Property 4: 枚举显示名称映射正确性

    /// <summary>
    /// Feature: admin-missing-modules, Property 4: 枚举显示名称映射正确性
    /// *For any* valid Status value in {1,2,3,4}, EducationStage value in {1,2,3,4,5,6}, 
    /// and Gender value in {1,2}, the corresponding display name (StatusName, EducationStageName, GenderName) 
    /// must match the defined mapping dictionary.
    /// **Validates: Requirements 1.4, 1.5, 1.6**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool EnumDisplayNameMappingsCorrect_StatusNameMapping(PositiveInt seed)
    {
        // Arrange: 创建包含不同状态的测评记录
        using var dbContext = CreateDbContext();
        var validStatuses = new[] { 1, 2, 3, 4 };
        var targetStatus = validStatuses[seed.Get % validStatuses.Length];

        CreateTestRecordWithStatus(dbContext, seed.Get, targetStatus);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 查询记录
        var request = new AssessmentRecordQueryRequest
        {
            Page = 1,
            PageSize = 100,
            Status = targetStatus
        };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: StatusName 与预期映射一致
        if (result.List.Count == 0) return true;

        var expectedStatusName = StatusNames[targetStatus];
        return result.List.All(r => r.StatusName == expectedStatusName);
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 4: 枚举显示名称映射正确性
    /// 验证 EducationStageName 映射正确性
    /// **Validates: Requirements 1.4, 1.5, 1.6**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool EnumDisplayNameMappingsCorrect_EducationStageNameMapping(PositiveInt seed)
    {
        // Arrange: 创建包含不同学历阶段的测评记录
        using var dbContext = CreateDbContext();
        var validEducationStages = new[] { 1, 2, 3, 4, 5, 6 };
        var targetEducationStage = validEducationStages[seed.Get % validEducationStages.Length];

        CreateTestRecordWithEducationStage(dbContext, seed.Get, targetEducationStage);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 查询记录
        var request = new AssessmentRecordQueryRequest { Page = 1, PageSize = 100 };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: EducationStageName 与预期映射一致
        if (result.List.Count == 0) return true;

        var expectedEducationStageName = EducationStageNames[targetEducationStage];
        return result.List.Any(r => r.EducationStage == targetEducationStage 
            && r.EducationStageName == expectedEducationStageName);
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 4: 枚举显示名称映射正确性
    /// 验证 GenderName 映射正确性
    /// **Validates: Requirements 1.4, 1.5, 1.6**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool EnumDisplayNameMappingsCorrect_GenderNameMapping(PositiveInt seed)
    {
        // Arrange: 创建包含不同性别的测评记录
        using var dbContext = CreateDbContext();
        var validGenders = new[] { 1, 2 };
        var targetGender = validGenders[seed.Get % validGenders.Length];

        CreateTestRecordWithGender(dbContext, seed.Get, targetGender);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 查询记录
        var request = new AssessmentRecordQueryRequest { Page = 1, PageSize = 100 };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: GenderName 与预期映射一致
        if (result.List.Count == 0) return true;

        var expectedGenderName = GenderNames[targetGender];
        return result.List.Any(r => r.Gender == targetGender && r.GenderName == expectedGenderName);
    }

    /// <summary>
    /// Feature: admin-missing-modules, Property 4: 枚举显示名称映射正确性
    /// 验证所有枚举值的映射完整性
    /// **Validates: Requirements 1.4, 1.5, 1.6**
    /// </summary>
    [Property(MaxTest = 100)]
    public bool EnumDisplayNameMappingsCorrect_AllEnumMappingsComplete(PositiveInt seed)
    {
        // Arrange: 创建包含所有枚举值组合的测评记录
        using var dbContext = CreateDbContext();
        var validStatuses = new[] { 1, 2, 3, 4 };
        var validEducationStages = new[] { 1, 2, 3, 4, 5, 6 };
        var validGenders = new[] { 1, 2 };

        var status = validStatuses[seed.Get % validStatuses.Length];
        var educationStage = validEducationStages[seed.Get % validEducationStages.Length];
        var gender = validGenders[seed.Get % validGenders.Length];

        CreateTestRecordWithAllEnums(dbContext, seed.Get, status, educationStage, gender);
        var service = new AssessmentRecordService(dbContext, _mockLogger.Object);

        // Act: 查询记录
        var request = new AssessmentRecordQueryRequest { Page = 1, PageSize = 100 };
        var result = service.GetRecordListAsync(request).GetAwaiter().GetResult();

        // Assert: 所有枚举映射都正确
        if (result.List.Count == 0) return true;

        var record = result.List.First();
        var expectedStatusName = StatusNames[record.Status];
        var expectedEducationStageName = EducationStageNames[record.EducationStage];
        var expectedGenderName = GenderNames[record.Gender];

        return record.StatusName == expectedStatusName
            && record.EducationStageName == expectedEducationStageName
            && record.GenderName == expectedGenderName;
    }

    #endregion


    #region 辅助方法

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

        return new AdminBusinessDbContext(options);
    }

    /// <summary>
    /// 创建测试用户
    /// </summary>
    private User CreateTestUser(AdminBusinessDbContext dbContext, int seed)
    {
        var user = new User
        {
            Uid = $"{seed % 1000000:D6}",
            OpenId = $"openid_{seed}_{Guid.NewGuid():N}",
            Phone = $"138{seed % 100000000:D8}",
            Nickname = $"User_{seed}",
            UserLevel = 1,
            Status = 1,
            CreateTime = DateTime.Now,
            UpdateTime = DateTime.Now,
            IsDeleted = false
        };
        dbContext.Users.Add(user);
        dbContext.SaveChanges();
        return user;
    }

    /// <summary>
    /// 创建测试订单
    /// </summary>
    private Order CreateTestOrder(AdminBusinessDbContext dbContext, long userId, int seed)
    {
        var order = new Order
        {
            OrderNo = $"ORD{DateTime.Now:yyyyMMddHHmmss}{seed % 10000:D4}_{Guid.NewGuid():N}",
            UserId = userId,
            OrderType = 1,
            ProductId = 1,
            ProductName = $"测试商品_{seed}",
            Amount = 100m,
            PayAmount = 100m,
            PayType = 1,
            Status = 2,
            PayTime = DateTime.Now,
            CreateTime = DateTime.Now,
            UpdateTime = DateTime.Now,
            IsDeleted = false
        };
        dbContext.Orders.Add(order);
        dbContext.SaveChanges();
        return order;
    }

    /// <summary>
    /// 创建测试测评类型
    /// </summary>
    private AssessmentType CreateTestAssessmentType(AdminBusinessDbContext dbContext, int seed)
    {
        var assessmentType = new AssessmentType
        {
            Name = $"测评类型_{seed}",
            Code = $"TYPE_{seed}_{Guid.NewGuid():N}",
            Price = 99.00m,
            QuestionCount = 80,
            Sort = seed,
            Status = 1,
            CreateTime = DateTime.Now,
            UpdateTime = DateTime.Now,
            IsDeleted = false
        };
        dbContext.AssessmentTypes.Add(assessmentType);
        dbContext.SaveChanges();
        return assessmentType;
    }

    /// <summary>
    /// 创建多个测试记录
    /// </summary>
    private void CreateTestRecords(AdminBusinessDbContext dbContext, int count, int seed)
    {
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        for (int i = 0; i < count; i++)
        {
            var record = new AssessmentRecord
            {
                UserId = user.Id,
                OrderId = order.Id,
                AssessmentTypeId = assessmentType.Id,
                Name = $"测试人_{seed}_{i}",
                Phone = $"139{(seed + i) % 100000000:D8}",
                Gender = (i % 2) + 1,
                Age = 10 + (i % 20),
                EducationStage = (i % 6) + 1,
                Province = "北京市",
                City = "北京市",
                District = "朝阳区",
                Status = (i % 4) + 1,
                CreateTime = DateTime.Now.AddMinutes(-i),
                UpdateTime = DateTime.Now,
                IsDeleted = false
            };
            dbContext.AssessmentRecords.Add(record);
        }
        dbContext.SaveChanges();
    }


    /// <summary>
    /// 创建多个用户及其测评记录，返回用户ID列表
    /// </summary>
    private List<long> CreateTestUsersAndRecords(AdminBusinessDbContext dbContext, int userCount, int recordsPerUser, int seed)
    {
        var userIds = new List<long>();
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        for (int u = 0; u < userCount; u++)
        {
            var user = CreateTestUser(dbContext, seed + u * 1000);
            var order = CreateTestOrder(dbContext, user.Id, seed + u * 1000);
            userIds.Add(user.Id);

            for (int r = 0; r < recordsPerUser; r++)
            {
                var record = new AssessmentRecord
                {
                    UserId = user.Id,
                    OrderId = order.Id,
                    AssessmentTypeId = assessmentType.Id,
                    Name = $"测试人_{u}_{r}",
                    Phone = $"139{(seed + u * 100 + r) % 100000000:D8}",
                    Gender = (r % 2) + 1,
                    Age = 10 + (r % 20),
                    EducationStage = (r % 6) + 1,
                    Province = "北京市",
                    City = "北京市",
                    District = "朝阳区",
                    Status = (r % 4) + 1,
                    CreateTime = DateTime.Now.AddMinutes(-r),
                    UpdateTime = DateTime.Now,
                    IsDeleted = false
                };
                dbContext.AssessmentRecords.Add(record);
            }
        }
        dbContext.SaveChanges();
        return userIds;
    }

    /// <summary>
    /// 创建多个测评类型及其记录，返回测评类型ID列表
    /// </summary>
    private List<long> CreateTestTypesAndRecords(AdminBusinessDbContext dbContext, int typeCount, int recordsPerType, int seed)
    {
        var typeIds = new List<long>();
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);

        for (int t = 0; t < typeCount; t++)
        {
            var assessmentType = CreateTestAssessmentType(dbContext, seed + t * 1000);
            typeIds.Add(assessmentType.Id);

            for (int r = 0; r < recordsPerType; r++)
            {
                var record = new AssessmentRecord
                {
                    UserId = user.Id,
                    OrderId = order.Id,
                    AssessmentTypeId = assessmentType.Id,
                    Name = $"测试人_{t}_{r}",
                    Phone = $"139{(seed + t * 100 + r) % 100000000:D8}",
                    Gender = (r % 2) + 1,
                    Age = 10 + (r % 20),
                    EducationStage = (r % 6) + 1,
                    Province = "北京市",
                    City = "北京市",
                    District = "朝阳区",
                    Status = (r % 4) + 1,
                    CreateTime = DateTime.Now.AddMinutes(-r),
                    UpdateTime = DateTime.Now,
                    IsDeleted = false
                };
                dbContext.AssessmentRecords.Add(record);
            }
        }
        dbContext.SaveChanges();
        return typeIds;
    }

    /// <summary>
    /// 创建包含不同状态的测评记录
    /// </summary>
    private void CreateTestRecordsWithDifferentStatuses(AdminBusinessDbContext dbContext, int recordsPerStatus, int seed)
    {
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);
        var assessmentType = CreateTestAssessmentType(dbContext, seed);
        var statuses = new[] { 1, 2, 3, 4 };

        foreach (var status in statuses)
        {
            for (int r = 0; r < recordsPerStatus; r++)
            {
                var record = new AssessmentRecord
                {
                    UserId = user.Id,
                    OrderId = order.Id,
                    AssessmentTypeId = assessmentType.Id,
                    Name = $"测试人_状态{status}_{r}",
                    Phone = $"139{(seed + status * 100 + r) % 100000000:D8}",
                    Gender = (r % 2) + 1,
                    Age = 10 + (r % 20),
                    EducationStage = (r % 6) + 1,
                    Province = "北京市",
                    City = "北京市",
                    District = "朝阳区",
                    Status = status,
                    CreateTime = DateTime.Now.AddMinutes(-r),
                    UpdateTime = DateTime.Now,
                    IsDeleted = false
                };
                dbContext.AssessmentRecords.Add(record);
            }
        }
        dbContext.SaveChanges();
    }


    /// <summary>
    /// 创建跨越多天的测评记录
    /// </summary>
    private void CreateTestRecordsWithDifferentDates(AdminBusinessDbContext dbContext, int count, int seed)
    {
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        for (int i = 0; i < count; i++)
        {
            var record = new AssessmentRecord
            {
                UserId = user.Id,
                OrderId = order.Id,
                AssessmentTypeId = assessmentType.Id,
                Name = $"测试人_{seed}_{i}",
                Phone = $"139{(seed + i) % 100000000:D8}",
                Gender = (i % 2) + 1,
                Age = 10 + (i % 20),
                EducationStage = (i % 6) + 1,
                Province = "北京市",
                City = "北京市",
                District = "朝阳区",
                Status = (i % 4) + 1,
                CreateTime = DateTime.Today.AddDays(-i), // 每条记录相差一天
                UpdateTime = DateTime.Now,
                IsDeleted = false
            };
            dbContext.AssessmentRecords.Add(record);
        }
        dbContext.SaveChanges();
    }

    /// <summary>
    /// 创建多个用户及其带状态的测评记录，返回用户ID列表
    /// </summary>
    private List<long> CreateTestUsersAndRecordsWithStatuses(AdminBusinessDbContext dbContext, int userCount, int recordsPerUser, int seed)
    {
        var userIds = new List<long>();
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        for (int u = 0; u < userCount; u++)
        {
            var user = CreateTestUser(dbContext, seed + u * 1000);
            var order = CreateTestOrder(dbContext, user.Id, seed + u * 1000);
            userIds.Add(user.Id);

            for (int r = 0; r < recordsPerUser; r++)
            {
                var record = new AssessmentRecord
                {
                    UserId = user.Id,
                    OrderId = order.Id,
                    AssessmentTypeId = assessmentType.Id,
                    Name = $"测试人_{u}_{r}",
                    Phone = $"139{(seed + u * 100 + r) % 100000000:D8}",
                    Gender = (r % 2) + 1,
                    Age = 10 + (r % 20),
                    EducationStage = (r % 6) + 1,
                    Province = "北京市",
                    City = "北京市",
                    District = "朝阳区",
                    Status = (r % 4) + 1, // 状态 1-4 循环
                    CreateTime = DateTime.Now.AddMinutes(-r),
                    UpdateTime = DateTime.Now,
                    IsDeleted = false
                };
                dbContext.AssessmentRecords.Add(record);
            }
        }
        dbContext.SaveChanges();
        return userIds;
    }

    /// <summary>
    /// 创建指定状态的测评记录
    /// </summary>
    private void CreateTestRecordWithStatus(AdminBusinessDbContext dbContext, int seed, int status)
    {
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        var record = new AssessmentRecord
        {
            UserId = user.Id,
            OrderId = order.Id,
            AssessmentTypeId = assessmentType.Id,
            Name = $"测试人_{seed}",
            Phone = $"139{seed % 100000000:D8}",
            Gender = 1,
            Age = 15,
            EducationStage = 2,
            Province = "北京市",
            City = "北京市",
            District = "朝阳区",
            Status = status,
            CreateTime = DateTime.Now,
            UpdateTime = DateTime.Now,
            IsDeleted = false
        };
        dbContext.AssessmentRecords.Add(record);
        dbContext.SaveChanges();
    }

    /// <summary>
    /// 创建指定学历阶段的测评记录
    /// </summary>
    private void CreateTestRecordWithEducationStage(AdminBusinessDbContext dbContext, int seed, int educationStage)
    {
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        var record = new AssessmentRecord
        {
            UserId = user.Id,
            OrderId = order.Id,
            AssessmentTypeId = assessmentType.Id,
            Name = $"测试人_{seed}",
            Phone = $"139{seed % 100000000:D8}",
            Gender = 1,
            Age = 15,
            EducationStage = educationStage,
            Province = "北京市",
            City = "北京市",
            District = "朝阳区",
            Status = 1,
            CreateTime = DateTime.Now,
            UpdateTime = DateTime.Now,
            IsDeleted = false
        };
        dbContext.AssessmentRecords.Add(record);
        dbContext.SaveChanges();
    }


    /// <summary>
    /// 创建指定性别的测评记录
    /// </summary>
    private void CreateTestRecordWithGender(AdminBusinessDbContext dbContext, int seed, int gender)
    {
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        var record = new AssessmentRecord
        {
            UserId = user.Id,
            OrderId = order.Id,
            AssessmentTypeId = assessmentType.Id,
            Name = $"测试人_{seed}",
            Phone = $"139{seed % 100000000:D8}",
            Gender = gender,
            Age = 15,
            EducationStage = 2,
            Province = "北京市",
            City = "北京市",
            District = "朝阳区",
            Status = 1,
            CreateTime = DateTime.Now,
            UpdateTime = DateTime.Now,
            IsDeleted = false
        };
        dbContext.AssessmentRecords.Add(record);
        dbContext.SaveChanges();
    }

    /// <summary>
    /// 创建包含所有枚举值的测评记录
    /// </summary>
    private void CreateTestRecordWithAllEnums(AdminBusinessDbContext dbContext, int seed, int status, int educationStage, int gender)
    {
        var user = CreateTestUser(dbContext, seed);
        var order = CreateTestOrder(dbContext, user.Id, seed);
        var assessmentType = CreateTestAssessmentType(dbContext, seed);

        var record = new AssessmentRecord
        {
            UserId = user.Id,
            OrderId = order.Id,
            AssessmentTypeId = assessmentType.Id,
            Name = $"测试人_{seed}",
            Phone = $"139{seed % 100000000:D8}",
            Gender = gender,
            Age = 15,
            EducationStage = educationStage,
            Province = "北京市",
            City = "北京市",
            District = "朝阳区",
            Status = status,
            CreateTime = DateTime.Now,
            UpdateTime = DateTime.Now,
            IsDeleted = false
        };
        dbContext.AssessmentRecords.Add(record);
        dbContext.SaveChanges();
    }

    #endregion
}