PureXML/Sources/Schema/XSDSimpleParser.swift

extension PureXML.Schema {
    /// Parses XSD simple types: atomic restrictions with the full facet set, and
    /// the `list` and `union` varieties. Kept beside ``XSDParser``, sharing its
    /// module-scope tree helpers and parsing context.
    enum XSDSimpleParser {
        static func simpleType(_ node: XSDTree, _ context: XSDContext) -> SimpleType {
            if let list = XSDNode.firstChild(node, named: "list") {
                return listType(list, context)
            }
            if let union = XSDNode.firstChild(node, named: "union") {
                return unionType(union, context)
            }
            guard let restriction = XSDNode.firstChild(node, named: "restriction") else {
                return SimpleType(base: .string)
            }
            // Resolve the base through simpleTypeReference so the built-in list
            // datatypes (NMTOKENS, IDREFS, ENTITIES) keep their list variety: a
            // length facet on one of them counts list items, not characters (#146).
            // Restricting a user type inherits its base, facets, and variety.
            let baseType = simpleTypeReference(XSDNode.attribute(restriction, "base") ?? "string", context)
            var facets = baseType.facets
            // A restriction's own `enumeration` replaces the inherited set (the new
            // enumeration is the value space, not a union with the base's), whereas
            // `pattern` accumulates across steps and is ANDed. So drop the inherited
            // enumeration when this step declares its own.
            if XSDNode.elementChildren(restriction).contains(where: { XSDNode.localName($0) == "enumeration" }) {
                facets.enumeration = nil
            }
            applyFacets(restriction, into: &facets)
            for error in facetDefinitionErrors(restriction, base: baseType) + patternErrors(restriction) {
                context.diagnostics.report(error)
            }
            return SimpleType(base: baseType.base, facets: facets, variety: baseType.variety)
        }

        /// Schema-validity findings for the `pattern` facets declared on one
        /// `restriction`: each `pattern` value must be a valid XSD regular
        /// expression. The pattern was only compiled lazily at instance time
        /// (`try?`), so an unparseable one was silently ignored and the schema
        /// accepted. Only the unambiguous structural errors reject (a quantifier
        /// with nothing to repeat, `?a`; unbalanced parentheses, `((a)`); see
        /// `rejectsPattern`.
        static func patternErrors(_ restriction: XSDTree) -> [String] {
            var errors: [String] = []
            for facet in XSDNode.elementChildren(restriction) where XSDNode.localName(facet) == "pattern" {
                let value = XSDNode.attribute(facet, "value") ?? ""
                do {
                    _ = try PureXML.Regex.Pattern(value)
                } catch let error as PureXML.Regex.RegexError where rejectsPattern(error) {
                    errors.append("pattern '\(value)' is not a valid regular expression: \(error)")
                } catch {
                    // A construct the engine does not support (`.empty`, `.unsupported`
                    // for an untabulated `\p{Is...}` block, `.badQuantifier` for the
                    // lenient `{,m}` form) is a valid XSD pattern, not a schema error.
                }
            }
            return errors
        }

        /// Whether a regex-compile failure is a genuine syntax error (so the schema
        /// is invalid), as opposed to an engine limitation on an otherwise-valid XSD
        /// pattern. Conservative: only the unambiguous structural errors reject.
        private static func rejectsPattern(_ error: PureXML.Regex.RegexError) -> Bool {
            switch error {
            case .unbalanced, .danglingQuantifier:
                true
            case .empty, .unsupported, .badQuantifier, .badEscape, .badClass:
                false
            }
        }

        /// Schema-validity findings for the constraining facets declared on one
        /// `restriction` (XSD Part 2 Datatypes 4.3): the length-family rules plus
        /// the value-bound rules, both limited to the facets declared on this step
        /// so an inherited facet is never flagged here.
        static func facetDefinitionErrors(_ restriction: XSDTree, base: SimpleType) -> [String] {
            countFacetErrors(restriction) + boundFacetErrors(restriction, base: base)
        }

        /// Length-family findings: `length`, `minLength`, `maxLength`,
        /// `totalDigits`, and `fractionDigits` must be `nonNegativeInteger`
        /// (`totalDigits` a `positiveInteger`), `length` may not co-occur with
        /// `minLength`/`maxLength`, and `minLength` <= `maxLength`,
        /// `fractionDigits` <= `totalDigits`. Reads the raw lexical, since numeric
        /// facet parsing silently drops a malformed value.
        private static func countFacetErrors(_ restriction: XSDTree) -> [String] {
            var errors: [String] = []
            var values: [String: String] = [:] // facet name -> canonical digit string
            let countFacets: Set = ["length", "minLength", "maxLength", "totalDigits", "fractionDigits"]
            for facet in XSDNode.elementChildren(restriction) {
                guard let name = XSDNode.localName(facet), countFacets.contains(name) else { continue }
                let raw = XSDNode.attribute(facet, "value")
                guard let canonical = raw.flatMap(canonicalNonNegativeInteger) else {
                    errors.append("facet '\(name)' value '\(raw ?? "")' is not a valid nonNegativeInteger")
                    continue
                }
                if name == "totalDigits", canonical == "0" {
                    errors.append("facet 'totalDigits' value '\(raw ?? "")' must be a positiveInteger")
                }
                values[name] = canonical
            }
            if values["length"] != nil, values["minLength"] != nil {
                errors.append("facets 'length' and 'minLength' may not both be specified")
            }
            if values["length"] != nil, values["maxLength"] != nil {
                errors.append("facets 'length' and 'maxLength' may not both be specified")
            }
            if let low = values["minLength"], let high = values["maxLength"], greater(low, than: high) {
                errors.append("facet 'minLength' (\(low)) exceeds 'maxLength' (\(high))")
            }
            if let fraction = values["fractionDigits"], let total = values["totalDigits"], greater(fraction, than: total) {
                errors.append("facet 'fractionDigits' (\(fraction)) exceeds 'totalDigits' (\(total))")
            }
            return errors
        }

        /// Value-bound findings: each `minInclusive`/`maxInclusive`/`minExclusive`/
        /// `maxExclusive` and `enumeration` value must be a valid value of the base
        /// type; `minInclusive` excludes `minExclusive` and `maxInclusive` excludes
        /// `maxExclusive`; and the lower bound may not exceed the upper bound (nor
        /// equal it when either side is exclusive, which is an empty value space).
        /// Ordering is compared in the base primitive's value space.
        private static func boundFacetErrors(_ restriction: XSDTree, base: SimpleType) -> [String] {
            var errors: [String] = []
            var bounds: [String: String] = [:]
            for facet in XSDNode.elementChildren(restriction) {
                guard let name = XSDNode.localName(facet) else { continue }
                let raw = XSDNode.attribute(facet, "value") ?? ""
                switch name {
                case "minInclusive", "maxInclusive", "minExclusive", "maxExclusive":
                    if base.validate(raw) != nil {
                        errors.append("facet '\(name)' value '\(raw)' is not a valid value of the base type")
                    } else {
                        bounds[name] = raw
                    }
                case "enumeration":
                    if base.validate(raw) != nil {
                        errors.append("enumeration value '\(raw)' is not a valid value of the base type")
                    }
                default:
                    break
                }
            }
            if bounds["minInclusive"] != nil, bounds["minExclusive"] != nil {
                errors.append("facets 'minInclusive' and 'minExclusive' may not both be specified")
            }
            if bounds["maxInclusive"] != nil, bounds["maxExclusive"] != nil {
                errors.append("facets 'maxInclusive' and 'maxExclusive' may not both be specified")
            }
            errors += boundOrderErrors(bounds, base: base)
            return errors
        }

        /// The lower-versus-upper-bound ordering finding, if any, comparing in the
        /// base primitive's value space. Skipped for an unordered primitive (the
        /// `ordered` lookup returns nil), so only a defined order is checked.
        private static func boundOrderErrors(_ bounds: [String: String], base: SimpleType) -> [String] {
            guard let low = bounds["minInclusive"] ?? bounds["minExclusive"],
                  let high = bounds["maxInclusive"] ?? bounds["maxExclusive"],
                  let lowValue = base.base.primitive.ordered(low),
                  let highValue = base.base.primitive.ordered(high)
            else { return [] }
            if lowValue > highValue {
                return ["lower bound '\(low)' exceeds upper bound '\(high)'"]
            }
            let exclusive = bounds["minExclusive"] != nil || bounds["maxExclusive"] != nil
            if lowValue == highValue, exclusive {
                return ["bounds '\(low)' and '\(high)' describe an empty value space"]
            }
            return []
        }

        /// The canonical digit string of a lexical `nonNegativeInteger` (optional
        /// leading `+`, ASCII digits, surrounding whitespace tolerated), with the
        /// sign and leading zeros stripped (`"0"` for zero), or nil when the lexical
        /// is not one (`-1`, ``, `a`, `1e2`). Independent of machine-integer range,
        /// so a huge but well-formed value is canonicalized, not misreported as
        /// malformed; the canonical form orders two values by length then lexically.
        private static func canonicalNonNegativeInteger(_ lexical: String) -> String? {
            var digits = Substring(lexical.trimmingXMLWhitespace())
            if digits.first == "+" { digits = digits.dropFirst() }
            guard !digits.isEmpty, digits.allSatisfy({ $0.isASCII && $0.isNumber }) else { return nil }
            let trimmed = digits.drop { $0 == "0" }
            return trimmed.isEmpty ? "0" : String(trimmed)
        }

        /// Whether canonical nonNegativeInteger `lhs` is greater than `rhs`: a longer
        /// digit string is larger, and same-length strings compare lexicographically.
        private static func greater(_ lhs: String, than rhs: String) -> Bool {
            lhs.count != rhs.count ? lhs.count > rhs.count : lhs > rhs
        }

        static func simpleTypeReference(_ typeName: String, _ context: XSDContext) -> SimpleType {
            let local = XSDNode.stripPrefix(typeName)
            if let builtin = BuiltinType(rawValue: local) { return SimpleType(base: builtin) }
            if let item = listBuiltinItem(local) { return .list(item: SimpleType(base: item)) }
            return context.simpleTypes[local] ?? SimpleType(base: .string)
        }

        /// The item type of a built-in list datatype (`IDREFS`, `ENTITIES`,
        /// `NMTOKENS`), each a whitespace-separated list of its singular form.
        static func listBuiltinItem(_ name: String) -> BuiltinType? {
            switch name {
            case "IDREFS": .idref
            case "ENTITIES": .entity
            case "NMTOKENS": .nmtoken
            default: nil
            }
        }

        static func applyFacets(_ restriction: XSDTree, into facets: inout Facets) {
            for facet in XSDNode.elementChildren(restriction) {
                let value = XSDNode.attribute(facet, "value")
                applyStringFacet(XSDNode.localName(facet), value, into: &facets)
                applyNumericFacet(XSDNode.localName(facet), value, into: &facets)
            }
        }

        private static func listType(_ node: XSDTree, _ context: XSDContext) -> SimpleType {
            let item: SimpleType = if let itemType = XSDNode.attribute(node, "itemType") {
                simpleTypeReference(itemType, context)
            } else if let inline = XSDNode.firstChild(node, named: "simpleType") {
                simpleType(inline, context)
            } else {
                SimpleType(base: .string)
            }
            return .list(item: item)
        }

        private static func unionType(_ node: XSDTree, _ context: XSDContext) -> SimpleType {
            var members: [SimpleType] = []
            if let names = XSDNode.attribute(node, "memberTypes") {
                members += names.split(whereSeparator: \.isWhitespace).map { simpleTypeReference(String($0), context) }
            }
            members += XSDNode.children(node, named: "simpleType").map { simpleType($0, context) }
            return .union(members)
        }

        private static func applyStringFacet(_ name: String?, _ value: String?, into facets: inout Facets) {
            switch name {
            case "pattern": if let value { facets.patterns.append(value) }
            case "enumeration": if let value { facets.enumeration = (facets.enumeration ?? []) + [value] }
            case "minInclusive": facets.minInclusive = value
            case "maxInclusive": facets.maxInclusive = value
            case "minExclusive": facets.minExclusive = value
            case "maxExclusive": facets.maxExclusive = value
            case "whiteSpace": facets.whiteSpace = whiteSpace(value)
            default: break
            }
        }

        private static func applyNumericFacet(_ name: String?, _ value: String?, into facets: inout Facets) {
            let number = value.flatMap(Int.init)
            switch name {
            case "length": facets.length = number
            case "minLength": facets.minLength = number
            case "maxLength": facets.maxLength = number
            case "totalDigits": facets.totalDigits = number
            case "fractionDigits": facets.fractionDigits = number
            default: break
            }
        }

        private static func whiteSpace(_ value: String?) -> WhiteSpace? {
            switch value {
            case "preserve": .preserve
            case "replace": .replace
            case "collapse": .collapse
            default: nil
            }
        }
    }
}