AnkiPackageLimits.cs

namespace AnkiIO;

public sealed record AnkiPackageLimits
{
    private int maximumEntries = 10_000;
    private long maximumEntryBytes = 256L * 1024 * 1024;
    private long maximumTotalBytes = 2L * 1024 * 1024 * 1024;
    private double maximumCompressionRatio = 200;
    private long maximumCollectionBytes = 512L * 1024 * 1024;

    public AnkiPackageLimits()
    {
    }

    public static AnkiPackageLimits Default { get; } = new();

    public int MaximumEntries
    {
        get => maximumEntries;
        init => maximumEntries = RequirePositive(value, nameof(MaximumEntries));
    }

    public long MaximumEntryBytes
    {
        get => maximumEntryBytes;
        init => maximumEntryBytes = RequirePositive(value, nameof(MaximumEntryBytes));
    }

    public long MaximumTotalBytes
    {
        get => maximumTotalBytes;
        init => maximumTotalBytes = RequirePositive(value, nameof(MaximumTotalBytes));
    }

    public double MaximumCompressionRatio
    {
        get => maximumCompressionRatio;
        init
        {
            if (!double.IsFinite(value) || value <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(MaximumCompressionRatio), value, "The maximum compression ratio must be finite and positive.");
            }
 
            maximumCompressionRatio = value;
        }
    }

    public long MaximumCollectionBytes
    {
        get => maximumCollectionBytes;
        init => maximumCollectionBytes = RequirePositive(value, nameof(MaximumCollectionBytes));
    }
 
    internal void Validate()
    {
        _ = RequirePositive(MaximumEntries, nameof(MaximumEntries));
        _ = RequirePositive(MaximumEntryBytes, nameof(MaximumEntryBytes));
        _ = RequirePositive(MaximumTotalBytes, nameof(MaximumTotalBytes));
        _ = RequirePositive(MaximumCollectionBytes, nameof(MaximumCollectionBytes));
        if (!double.IsFinite(MaximumCompressionRatio) || MaximumCompressionRatio <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(MaximumCompressionRatio), MaximumCompressionRatio, "The maximum compression ratio must be finite and positive.");
        }
    }
 
    private static int RequirePositive(int value, string parameterName)
    {
        if (value <= 0)
        {
            throw new ArgumentOutOfRangeException(parameterName, value, "The limit must be positive.");
        }
 
        return value;
    }
 
    private static long RequirePositive(long value, string parameterName)
    {
        if (value <= 0)
        {
            throw new ArgumentOutOfRangeException(parameterName, value, "The limit must be positive.");
        }
 
        return value;
    }
}