PureXML/Sources/XSLT/XSLTInstantiationSteps.swift

// The step methods of the iterative XSLT evaluator (see XSLTInstantiation.swift).
// Each instruction either appends its produced items to the sink synchronously or
// pushes sub-work; the rest of the body is always pushed first so it pops last,
// keeping result-tree document order.

extension XSLTDriver {
    func stepRun(_ body: [Instruction], _ cursor: Int, _ context: XSLTContext, _ sink: Sink) {
        guard cursor < body.count else { return }
        let instruction = body[cursor]
        switch instruction {
        case let .variable(name, select, variableBody):
            // A variable binds for the rest of the body; thread the updated context.
            var context = context
            context.variables[name] = transformer.variableValue(select, variableBody, context)
            stack.append(.run(body, cursor + 1, context, sink))
            return
        case let .fallback(fallbackBody):
            stack.append(.run(body, cursor + 1, context, sink))
            stack.append(.run(fallbackBody, 0, context, sink))
            return
        default:
            break
        }
        // The remainder of the body runs after this instruction's items.
        stack.append(.run(body, cursor + 1, context, sink))
        if runSimple(instruction, context, sink) {
            return
        }
        if runControl(instruction, context, sink) {
            return
        }
        if runTemplate(instruction, context, sink) {
            return
        }
        runConstruct(instruction, context, sink)
    }

    private func runSimple(_ instruction: Instruction, _ context: XSLTContext, _ sink: Sink) -> Bool {
        switch instruction {
        case let .literalText(text):
            sink.into.items.append(.node(.text(text)))
        case let .valueOf(select, raw):
            let value = transformer.string(select, context)
            sink.into.items.append(.node(.text(raw ? PureXML.XSLT.RawText.marked(value) : value)))
        case .number:
            sink.into.items.append(.node(.text(transformer.numberInstruction(instruction, context))))
        case let .copyOf(select):
            sink.into.items.append(contentsOf: transformer.copyOf(select, context))
        case let .message(terminate, messageBody):
            if terminate, transformer.termination.message == nil {
                transformer.termination.message = Host.text(of: transformer.instantiate(messageBody, context))
            }
        default:
            return false
        }
        return true
    }

    private func runControl(_ instruction: Instruction, _ context: XSLTContext, _ sink: Sink) -> Bool {
        switch instruction {
        case let .ifInstruction(test, thenBody):
            if transformer.boolean(test, context) {
                stack.append(.run(thenBody, 0, context, sink))
            }
        case let .choose(whens, otherwise):
            let branch = whens.first { transformer.boolean($0.test, context) }?.body ?? otherwise
            stack.append(.run(branch, 0, context, sink))
        case let .forEach(select, sorts, eachBody):
            pushForEach(select, sorts, eachBody, context, sink)
        default:
            return false
        }
        return true
    }

    private func runTemplate(_ instruction: Instruction, _ context: XSLTContext, _ sink: Sink) -> Bool {
        switch instruction {
        case let .applyTemplates(select, mode, sorts, parameters):
            let nodes = transformer.sorted(transformer.selectXPathNodes(select ?? "node()", context), sorts, context)
            stack.append(.applyTemplates(nodes, Application(mode: mode, parameters: parameters, caller: context, sink: sink)))
        case let .callTemplate(name, parameters):
            pushCallTemplate(name, parameters, context, sink)
        case .applyImports:
            pushApplyImports(context, sink)
        default:
            return false
        }
        return true
    }

    private func runConstruct(_ instruction: Instruction, _ context: XSLTContext, _ sink: Sink) {
        switch instruction {
        case .literalElement:
            pushLiteralElement(instruction, context, sink)
        case .element:
            pushElement(instruction, context, sink)
        case let .attribute(nameTemplate, namespaceTemplate, namespaces, attributeBody):
            let name = transformer.createdName(nameTemplate, namespaceTemplate, namespaces, context, isAttribute: true)
            pushTextNode(.attribute(name), attributeBody, context, sink)
        case let .copy(useAttributeSets, copyBody):
            pushCopy(useAttributeSets, copyBody, context, sink)
        case let .comment(commentBody):
            pushTextNode(.comment, commentBody, context, sink)
        case let .processingInstruction(nameTemplate, piBody):
            pushTextNode(.processingInstruction(transformer.avt(nameTemplate, context)), piBody, context, sink)
        default:
            break
        }
    }

    private func pushForEach(
        _ select: String,
        _ sorts: [PureXML.XSLT.Sort],
        _ body: [Instruction],
        _ context: XSLTContext,
        _ sink: Sink,
    ) {
        let nodes = transformer.sorted(transformer.selectXPathNodes(select, context), sorts, context)
        // Reversed so the nodes' bodies pop in document order into the sink.
        for (offset, xnode) in nodes.enumerated().reversed() {
            guard let owner = Host.ownerNode(xnode) else { continue }
            var itemContext = XSLTContext(
                node: owner,
                current: xnode.treeNode == nil ? xnode : nil,
                position: offset + 1,
                size: nodes.count,
                variables: context.variables,
            )
            itemContext.baseURI = context.baseURI
            stack.append(.run(body, 0, itemContext, sink))
        }
    }

    private func pushTextNode(_ kind: Finish, _ body: [Instruction], _ context: XSLTContext, _ sink: Sink) {
        let child = Accumulator()
        stack.append(.finish(kind, child, sink.into))
        stack.append(.run(body, 0, context, Sink(depth: sink.depth, into: child)))
    }
}