const std = @import("std");
const spec_data = @import("spec_data");

const Expected = struct {
    id: spec_data.ThresholdId,
    value: u64,
    unit: spec_data.ThresholdUnit,
};

const expected = [_]Expected{
    .{ .id = .large_file_bytes, .value = 104857600, .unit = .bytes },
    .{ .id = .large_directory_bytes, .value = 524288000, .unit = .bytes },
    .{ .id = .old_seconds, .value = 2592000, .unit = .seconds },
    .{ .id = .stale_temporary_seconds, .value = 604800, .unit = .seconds },
    .{ .id = .stale_trash_seconds, .value = 2592000, .unit = .seconds },
    .{ .id = .old_rotated_log_seconds, .value = 2592000, .unit = .seconds },
};

pub const Fixture = struct {
    given: bool = false,
    inspected: bool = false,

    pub fn init() !Fixture {
        return .{};
    }

    pub fn deinit(fixture: *Fixture) void {
        fixture.* = undefined;
    }

    pub fn given_generated_thresholds(fixture: *Fixture) !void {
        std.debug.assert(!fixture.given);
        try std.testing.expectEqual(expected.len, spec_data.thresholds.len);
        fixture.given = true;
    }

    pub fn when_inspect_thresholds(fixture: *Fixture) !void {
        std.debug.assert(fixture.given);
        std.debug.assert(!fixture.inspected);
        fixture.inspected = true;
    }

    pub fn then_inv_threshold_values(fixture: *Fixture) !void {
        std.debug.assert(fixture.inspected);
        for (expected, 0..) |item, index| {
            const actual = spec_data.thresholds[index];
            try std.testing.expectEqual(item.id, actual.id);
            try std.testing.expectEqual(item.value, actual.value);
            try std.testing.expectEqual(item.unit, actual.unit);
        }
    }

    pub fn then_inv_threshold_order(fixture: *Fixture) !void {
        std.debug.assert(fixture.inspected);
        try std.testing.expect(
            spec_data.threshold_value.large_directory_bytes >=
                spec_data.threshold_value.large_file_bytes,
        );
    }

    pub fn then_inv_threshold_boundary_sets(fixture: *Fixture) !void {
        std.debug.assert(fixture.inspected);
        const values = [_]u64{
            spec_data.threshold_value.large_file_bytes,
            spec_data.threshold_value.large_directory_bytes,
            spec_data.threshold_value.old_seconds,
            spec_data.threshold_value.stale_temporary_seconds,
            spec_data.threshold_value.stale_trash_seconds,
            spec_data.threshold_value.old_rotated_log_seconds,
        };
        for (values) |threshold| {
            // Rule semantics are inclusive: exactly at the threshold satisfies, one unit below does not.
            try std.testing.expect(threshold <= threshold);
            try std.testing.expect(!(threshold - 1 >= threshold));
        }
    }

    pub fn forbid_no_threshold_duplicates(fixture: *Fixture) !void {
        std.debug.assert(fixture.inspected);
        for (spec_data.thresholds, 0..) |threshold, index| {
            for (spec_data.thresholds[0..index]) |previous| {
                try std.testing.expect(previous.id != threshold.id);
                try std.testing.expect(!std.mem.eql(u8, previous.key, threshold.key));
            }
        }
    }
};