import PureYAML
@testable import PureYAMLJSON
import Testing

/// "Coverage is itself a tested law" (validation-rules.md), applied to the JSON-representability
/// validator, the same discipline `ValidationCoverageMetaTests` in the core target applies to the model
/// and tagged validators.
@Suite("JSON representability finding-coverage law")
struct JSONCoverageMetaTests {
    private struct Fixture {
        let check: PureYAML.Validation.AnyValidation<PureYAML.Model.Value>
        let failing: PureYAML.Model.Value
        let nearMiss: PureYAML.Model.Value
    }

    private static let fixtures: [Fixture] = [
        .init(
            check: .init(PureYAML.Validation.BuiltinValidation.mappingKeysAreUnique),
            failing: .mapping(.init([
                .init(key: "a", value: .int(1)),
                .init(key: "a", value: .int(2)),
            ])),
            nearMiss: .mapping(.init([
                .init(key: "a", value: .int(1)),
                .init(key: "b", value: .int(2)),
            ])),
        ),
        .init(
            check: .init(PureYAML.Validation.BuiltinValidation.mappingKeysAreStrings),
            failing: .mapping(.init([.init(keyNode: .sequence([.int(1)]), value: .int(2))])),
            // The boundary: a string key, the only key shape JSON permits.
            nearMiss: .mapping(.init([.init(key: "a", value: .int(2))])),
        ),
        .init(
            check: .init(PureYAML.Validation.BuiltinValidation.numbersAreFinite),
            failing: .mapping(.init([.init(key: "x", value: .double(.infinity))])),
            // The boundary: the largest finite double, one step from non-finite.
            nearMiss: .mapping(.init([.init(key: "x", value: .double(.greatestFiniteMagnitude))])),
        ),
    ]

    @Test("The JSON representability validator's descriptions are pinned")
    func test_representabilityDescriptionsArePinned() {
        #expect(PureYAML.JSON.Validator.representability.validationDescriptions == [
            "Mapping keys are unique",
            "Mapping keys are strings",
            "Numbers are finite",
        ])
    }

    @Test("JSON fixtures cover exactly the representability validator's default checks")
    func test_fixturesCoverDefaults() {
        let ruled = Set(PureYAML.JSON.Validator.representability.validationDescriptions)
        let covered = Set(Self.fixtures.map(\.check.description))
        #expect(ruled.subtracting(covered).isEmpty, "JSON default checks without fixtures: \(ruled.subtracting(covered).sorted())")
        #expect(covered.subtracting(ruled).isEmpty, "JSON fixtures for checks that no longer ship: \(covered.subtracting(ruled).sorted())")
    }

    @Test("Each JSON check fails its failing fixture and passes its near miss in isolation")
    func test_checksFailAndNearMiss() throws {
        for fixture in Self.fixtures {
            let isolated = PureYAML.Validation.Validator<PureYAML.Model.Value, PureYAML.Model.Value>(nonReferenceDefaultValidations: [fixture.check])
            #expect(throws: PureYAML.Validation.ValidationErrorCollection.self, "check '\(fixture.check.description)' did not fail its failing fixture") {
                try isolated.validate(fixture.failing)
            }
            _ = try isolated.validate(fixture.nearMiss)
        }
    }
}