import Testing
@testable import PureXML

/// cvc-identity-constraint.3: a `key`/`keyref`/`unique` field must identify a node
/// of simple type. A field that reaches an element whose declared type is the
/// ur-type `anyType` (no type) or a complex type without simple content is invalid,
/// unless the instance gives the node a simple type through `xsi:type`. Mirrors the
/// W3C XSTS idZ010 shape (a `key`/`keyref` whose fields select no-type elements
/// nested through a path), the case PureXML previously accepted.
@Suite("Identity-constraint field must select a simple-typed node")
struct SchemaIdentityFieldSimpleTypeTests {
    /// idZ010 in miniature: `root/a` carries a `key` whose field path reaches `c`,
    /// declared with no type (so `anyType`). The field is not simple, so the
    /// instance is invalid even though the value would otherwise be a fine key.
    private func anyTypeFieldSchema() throws -> PureXML.Schema.Document {
        try PureXML.Schema.Document("""
        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
          <xsd:element name="root">
            <xsd:complexType><xsd:sequence>
              <xsd:element name="a" maxOccurs="unbounded">
                <xsd:complexType><xsd:sequence>
                  <xsd:element name="b">
                    <xsd:complexType><xsd:sequence>
                      <xsd:element name="c"/>
                    </xsd:sequence></xsd:complexType>
                  </xsd:element>
                </xsd:sequence></xsd:complexType>
              </xsd:element>
            </xsd:sequence></xsd:complexType>
            <xsd:key name="k">
              <xsd:selector xpath="a"/>
              <xsd:field xpath="./b/c"/>
            </xsd:key>
          </xsd:element>
        </xsd:schema>
        """)
    }

    @Test("a key field reaching a no-type (anyType) element is rejected")
    func test_anyTypeFieldRejected() throws {
        let schema = try anyTypeFieldSchema()
        let errors = try schema.validate("<root><a><b><c>1</c></b></a></root>")
        #expect(!errors.isEmpty)
        #expect(errors.contains { $0.reason.contains("simple content") })
    }

    @Test("a simple-typed field at the same path is accepted")
    func test_simpleTypedFieldAccepted() throws {
        let schema = try PureXML.Schema.Document("""
        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
          <xsd:element name="root">
            <xsd:complexType><xsd:sequence>
              <xsd:element name="a" maxOccurs="unbounded">
                <xsd:complexType><xsd:sequence>
                  <xsd:element name="b">
                    <xsd:complexType><xsd:sequence>
                      <xsd:element name="c" type="xsd:int"/>
                    </xsd:sequence></xsd:complexType>
                  </xsd:element>
                </xsd:sequence></xsd:complexType>
              </xsd:element>
            </xsd:sequence></xsd:complexType>
            <xsd:key name="k"><xsd:selector xpath="a"/><xsd:field xpath="./b/c"/></xsd:key>
          </xsd:element>
        </xsd:schema>
        """)
        #expect(try schema.validate("<root><a><b><c>1</c></b></a><a><b><c>2</c></b></a></root>").isEmpty)
    }

    @Test("an anyType field rescued by a simple xsi:type is accepted")
    func test_anyTypeRescuedByXsiType() throws {
        // The element is declared anyType, but the instance gives it xsi:type=int,
        // so its governing type is simple and the field is valid (cvc reads the
        // governing type). This is the guard that keeps the check from a false
        // positive on a legitimately simple-at-runtime node.
        let schema = try anyTypeFieldSchema()
        let xml = """
        <root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\
        <a><b><c xsi:type="xsd:int">1</c></b></a></root>
        """
        #expect(try schema.validate(xml).isEmpty)
    }
}