PureXML/Sources/Schema/ComplexValidatorDerivation.swift

extension PureXML.Schema.ComplexValidator {
    /// The first `xsi:type` override error for `child`, if any: a substitution
    /// blocked by `block`, a substitute not validly derived from the declared type
    /// (cvc-elt.4.3.2.1), or a missing `xsi:type` on an abstract declared type.
    func xsiTypeOverrideError(
        declared: PureXML.Schema.ElementType,
        child: PureXML.Model.Element,
        at path: [PureXML.Validation.PathKey],
    ) -> PureXML.Validation.ValidationError? {
        if let blocked = blockedSubstitutionError(declared: declared, child: child, at: path) { return blocked }
        if let notDerived = notDerivedSubstitutionError(declared: declared, child: child, at: path) { return notDerived }
        if case let .typeReference(name) = declared { return abstractTypeError(named: name, child: child, at: path) }
        return nil
    }

    /// The error when an element's declared type is an abstract complex type and
    /// the element supplies no `xsi:type` to name a concrete derived type. An
    /// abstract type cannot itself be the type of an instance element.
    func abstractTypeError(
        named name: String,
        child: PureXML.Model.Element,
        at path: [PureXML.Validation.PathKey],
    ) -> PureXML.Validation.ValidationError? {
        guard abstractTypes.contains(PureXML.Schema.XSDParser.bareTypeLocalName(name)),
              Self.xsiTypeName(child) == nil
        else { return nil }
        let bare = PureXML.Schema.XSDParser.bareTypeLocalName(name)
        return PureXML.Validation.ValidationError(
            reason: "element '\(child.name.localName)' has abstract type '\(bare)' and requires an xsi:type naming a concrete derived type",
            at: path,
        )
    }

    /// The error when an `xsi:type` substitution is forbidden by `block` on the
    /// declared type: the substituted type reaches the declared type by a method
    /// the declared type lists in `block`. Returns nil when there is no named
    /// declared type, no `block`, or the substitution is permitted.
    func blockedSubstitutionError(
        declared: PureXML.Schema.ElementType,
        child: PureXML.Model.Element,
        at path: [PureXML.Validation.PathKey],
    ) -> PureXML.Validation.ValidationError? {
        guard case let .typeReference(reference) = declared,
              let substitute = Self.xsiTypeName(child),
              Self.resolveNamedType(substitute, in: types) != nil
        else {
            return nil
        }
        // A ref'd child carries its type as an element-ref key (`element:foo`)
        // that resolves through `types` to the concrete type; follow that chain
        // to the declared type name the derivation backbone and `block` use.
        var declaredKey = reference
        var declaredName = PureXML.Schema.XSDParser.bareTypeLocalName(reference)
        var steps = 0
        while steps <= types.count {
            guard let resolved = types[declaredKey] ?? Self.resolveNamedType(declaredKey, in: types),
                  case let .typeReference(next) = resolved
            else { break }
            declaredKey = next
            declaredName = PureXML.Schema.XSDParser.bareTypeLocalName(next)
            steps += 1
        }
        guard let methods = PureXML.Schema.XSDParser.derivationMethods(from: substitute, to: declaredName, typeDerivation) else {
            return nil
        }
        // The substitution is blocked when the derivation method is disallowed by
        // either the declared type's `block` or the element declaration's own
        // `block` (keyed by the element's name).
        let blocked = (typeBlock[declaredName] ?? []).union(elementBlock[child.name.localName] ?? [])
        guard !methods.isDisjoint(with: blocked) else {
            return nil
        }
        return PureXML.Validation.ValidationError(
            reason: "xsi:type '\(substitute)' is blocked: substitution by this derivation is disallowed",
            at: path,
        )
    }

    /// cvc-elt.4.3.2.1: an `xsi:type` must resolve to a type DERIVED from the
    /// element's declared type. This flags ONLY the case where both the declared
    /// type and the substitute resolve to COMPLEX types recorded in the derivation
    /// backbone and there is no derivation path between them (a different branch of
    /// the hierarchy). It deliberately does NOT touch a simple/list/union substitute,
    /// a substitute or declared type absent from the backbone, or the ur-types: there
    /// the relationship cannot be confirmed from the complex-type backbone alone, so
    /// the rule stays silent (under-reject) rather than risk a false positive.
    ///
    /// Disclosed bound: the derivation backbone (`typeDerivation`) is keyed by bare
    /// local name, shared with `blockedSubstitutionError`. Two imported complex types
    /// with the same local name in different namespaces collide in one slot, so a
    /// cross-namespace substitution could in principle be misjudged. This is a
    /// pre-existing, subsystem-wide limitation (not introduced here); the holistic
    /// fix is to key the backbone by namespaced type identity and resolve `xsi:type`
    /// through `xsiTypeReference`. The XSTS corpus exercises no such collision.
    func notDerivedSubstitutionError(
        declared: PureXML.Schema.ElementType,
        child: PureXML.Model.Element,
        at path: [PureXML.Validation.PathKey],
    ) -> PureXML.Validation.ValidationError? {
        guard case let .typeReference(reference) = declared,
              let substitute = Self.xsiTypeName(child),
              case .complex? = Self.resolveNamedType(substitute, in: types)
        else { return nil }
        let substituteName = PureXML.Schema.XSDParser.bareTypeLocalName(substitute)
        let declaredName = resolvedDeclaredTypeName(reference)
        guard substituteName != declaredName,
              typeDerivation[substituteName] != nil,
              typeDerivation[declaredName] != nil || isComplexBackboneRoot(declaredName),
              PureXML.Schema.XSDParser.derivationMethods(from: substituteName, to: declaredName, typeDerivation) == nil
        else { return nil }
        return PureXML.Validation.ValidationError(
            reason: "xsi:type '\(substitute)' is not validly derived from the declared type '\(declaredName)' of '\(child.name.localName)'",
            at: path,
        )
    }

    /// A complex type that heads a derivation backbone (some recorded type derives
    /// from it) even though it records no base of its own, so it is a legitimate
    /// declared-type target for the not-derived check.
    private func isComplexBackboneRoot(_ name: String) -> Bool {
        guard name != "anyType", name != "anySimpleType" else { return false }
        return typeDerivation.values.contains { $0.base == name }
    }

    /// Follows an element-ref / type-reference chain (`element:foo` -> concrete type)
    /// to the declared type's bare local name, which the derivation backbone is
    /// keyed by.
    private func resolvedDeclaredTypeName(_ reference: String) -> String {
        var key = reference
        var name = PureXML.Schema.XSDParser.bareTypeLocalName(reference)
        var steps = 0
        while steps <= types.count {
            guard let resolved = types[key] ?? Self.resolveNamedType(key, in: types),
                  case let .typeReference(next) = resolved
            else { break }
            key = next
            name = PureXML.Schema.XSDParser.bareTypeLocalName(next)
            steps += 1
        }
        return name
    }
}