Features

public class Feature : AuditableEntity, ISoftDeletable
{
    public string Name { get; set; } = string.Empty;        // Unique system key
    public string DisplayName { get; set; } = string.Empty;  // UI label
    public string? Description { get; set; }
    public string? Category { get; set; }                    // Grouping
    
    public FeatureValueType ValueType { get; set; } = FeatureValueType.Boolean;
    public string DefaultValue { get; set; } = "false";     // Global fallback
    
    public bool IsSystem { get; set; }                      // Read-only if true
    public bool IsVisible { get; set; } = true;
    
    // Validation constraints (Numeric features)
    public string? MinValue { get; set; }                   // e.g. "0"
    public string? MaxValue { get; set; }                   // e.g. "1000", "-1" = unlimited
    public string? AllowedValues { get; set; }              // e.g. "light,dark,custom"
    
    public int SortOrder { get; set; }
}

public enum FeatureValueType
{
    /// <summary>On/Off toggle, stored as "true" or "false"</summary>
    Boolean = 0,
    
    /// <summary>Numeric limit, stored as integer string. -1 = unlimited</summary>
    Numeric = 1,
    
    /// <summary>Arbitrary string configuration value</summary>
    String = 2,
}

public class EntitlementsStartupSeeder : IStartupSeeder
{
    private readonly IFeatureRepository _features;

    public async Task SeedAsync(CancellationToken ct)
    {
        var systemFeatures = new[]
        {
            new Feature 
            { 
                Name = "Chat.Enabled", 
                DisplayName = "Chat", 
                ValueType = FeatureValueType.Boolean,
                DefaultValue = "false",
                IsSystem = true,
                Category = "Communication"
            },
            new Feature 
            { 
                Name = "MaxAdmins", 
                DisplayName = "Maximum Administrators",
                ValueType = FeatureValueType.Numeric,
                DefaultValue = "5",
                MinValue = "1",
                MaxValue = "-1",
                IsSystem = true,
                Category = "Limits"
            },
            new Feature 
            { 
                Name = "SSO.Enabled", 
                DisplayName = "Single Sign-On",
                ValueType = FeatureValueType.Boolean,
                DefaultValue = "false",
                IsSystem = true,
                Category = "Security"
            },
        };

        foreach (var feature in systemFeatures)
        {
            if (!await _features.ExistsByNameAsync(feature.Name, ct))
                await _features.AddAsync(feature, ct);
        }
    }
}

// Inside TenantQuotaService.cs:
public async Task<bool> IsQuotaAvailableAsync(
    Guid tenantId, 
    string featureName, 
    int currentUsage, 
    CancellationToken ct = default)
{
    // Concurrency Protection: acquire row-level lock on the tenant
    await _tenantRepository.LockTenantForQuotaAsync(tenantId, ct);

    // Resolve: 1. IFeatureChecker limit, 2. Fallback to legacy TenantSettings, 3. -1 fallback
    var limit = await GetEffectiveLimitAsync(tenantId, featureName, ct);
    if (limit == -1) 
        return true; 
        
    return currentUsage < limit;
}

// ─── Boolean Feature Gate (IRequireFeature) ───
// Step 1: Mark your command
public class SendBulkEmailCommand : ICommand, IRequireFeature
{
    public string RequiredFeatureName => "BulkEmail.Enabled";
    
    public List<string> Recipients { get; set; } = [];
    public string Subject { get; set; } = string.Empty;
    public string Body { get; set; } = string.Empty;
}

// Step 2: That's it! FeatureCheckBehavior handles the rest.
// If "BulkEmail.Enabled" is resolved to false → returns 403 Forbidden
// If resolved to true → command proceeds normally to the handler


// ─── Numeric Feature Quota (Handler Enforcement) ───
// For numeric features with resource limits, validate quotas in the handler:
public class CreateAdminCommandHandler : IRequestHandler<CreateAdminCommand, Result<Guid>>
{
    private readonly ITenantQuotaService _quotaService;
    private readonly IQuotaCounterRepository _quotaCounterRepository;

    public async Task<Result<Guid>> Handle(CreateAdminCommand request, CancellationToken ct)
    {
        // 1. Validate quota availability (concurrency-safe via LockTenantForQuotaAsync)
        var isAvailable = await _quotaService.IsQuotaAvailableAsync(request.TenantId, "Identity.MaxAdminsPerTenant", currentUsage, ct);
        if (!isAvailable) 
            return Result.Failure(Error.Forbidden("Admin limit exceeded"));

        // 2. Atomically reserve slot in repository
        var reserved = await _quotaCounterRepository.TryReserveSlotAsync(request.TenantId, "Identity.MaxAdminsPerTenant", ct);
        if (!reserved) 
            return Result.Failure(Error.Forbidden("Admin limit exceeded"));

        try
        {
            // Provision resource...
            await _quotaCounterRepository.ConfirmReservationAsync(request.TenantId, "Identity.MaxAdminsPerTenant", ct);
            return Result.Success(adminId);
        }
        catch
        {
            // Rollback reservation on failure
            await _quotaCounterRepository.ReleaseReservationAsync(request.TenantId, "Identity.MaxAdminsPerTenant", ct);
            throw;
        }
    }
}