@testable import PureYAML
import Testing

@Suite("Implicit null mapping keys")
struct ImplicitNullKeyTests {
    @Test("A `:` opening a line is an implicit null key")
    func test_implicitNullKey() throws {
        #expect(try PureYAML.parse(": value\n") == .mapping(.init([
            .init(keyNode: .string(""), value: .string("value")),
        ])))
    }

    @Test("Several null-keyed entries and a bare `:` parse")
    func test_multipleNullKeys() throws {
        _ = try PureYAML.parse(": a\n: b\n")
        _ = try PureYAML.parse(":\n")
        #expect(try PureYAML.parse("a: 1\n: b\n") == .mapping(.init([
            .init(key: "a", value: .int(1)),
            .init(keyNode: .string(""), value: .string("b")),
        ])))
    }

    @Test("A property-only key before `:` is an empty key carrying that property")
    func test_propertyOnlyKey() throws {
        // An anchor or tag with no scalar before the `:` decorates an empty implicit key: the block
        // analogue of the flow `{ !!str : v }` case. The resolved key is the empty scalar; the
        // property binds to it during construction.
        #expect(try PureYAML.parse("&a : b\n") == .mapping(.init([
            .init(keyNode: .string(""), value: .string("b")),
        ])))
        #expect(try PureYAML.parse("!!str : a\n") == .mapping(.init([
            .init(keyNode: .string(""), value: .string("a")),
        ])))
    }

    @Test("A property-only key after a block entry is an empty key")
    func test_propertyOnlyKeyAfterBlockEntry() throws {
        // The `-` opens a fresh node position, so `!!str :` after it is still an empty implicit key
        // rather than a malformed node.
        #expect(try PureYAML.parse("- !!str : a\n") == .sequence([
            .mapping(.init([.init(keyNode: .string(""), value: .string("a"))])),
        ]))
    }

    @Test("Explicit keys, including a complex one, are not mistaken for null keys")
    func test_explicitKeysUnaffected() throws {
        #expect(try PureYAML.parse("? a\n: b\n") == .mapping(.init([
            .init(key: "a", value: .string("b")),
        ])))
        // The `:` after a flow complex key is the key's value, not a null key.
        #expect(try PureYAML.parse("? {a: b}\n: c\n") == .mapping(.init([
            .init(keyNode: .mapping(.init([.init(key: "a", value: .string("b"))])), value: .string("c")),
        ])))
    }
}