/// The foreign-content namespaces HTML5 switches into. File-scope and private.
private enum ForeignNamespace {
    static let svg = "http://www.w3.org/2000/svg"
    static let mathml = "http://www.w3.org/1998/Math/MathML"
}

/// The HTML5 tree-construction insertion modes this builder implements: the
/// document-structure subset that establishes the implied `html`, `head`, and
/// `body`. File-scope and private.
private enum InsertionMode {
    case initial
    case beforeHtml
    case beforeHead
    case inHead
    case afterHead
    case inBody
    case inFrameset
    case afterFrameset
}

/// Builds a full HTML document from tokens by driving the HTML5 insertion modes,
/// materializing the implied `html`/`head`/`body` and routing head-only elements
/// into the head. The adoption agency lives in a sibling file, so this type is
/// internal (its members stay private except the live-body state it shares).
final class HTMLDocument {
    typealias Token = PureXML.HTML.Token
    typealias Node = PureXML.Model.Node
    typealias Attribute = PureXML.Model.Attribute

    /// Elements that belong in the head (`template` is excluded: it nests in body).
    private static let headElements: Set<String> = [
        "base", "basefont", "bgsound", "link", "meta", "title", "style", "script", "noscript", "noframes",
    ]

    private var mode: InsertionMode = .initial
    private var htmlAttributes: [Attribute] = []
    private var headAttributes: [Attribute] = []
    private var bodyAttributes: [Attribute] = []
    private let headRoot = PureXML.Model.TreeNode.element("head")
    private lazy var openHead: [PureXML.Model.TreeNode] = [headRoot]
    /// The body is built as a live mutable tree (the HTML5 model): nodes are
    /// attached to their parent as soon as they open, and `openBody` is the stack
    /// of currently-open elements into that tree, with the body element at the
    /// bottom. This lets the adoption agency reparent already-built subtrees, which
    /// a pop-on-close model cannot.
    let bodyRoot = PureXML.Model.TreeNode.element("body")
    lazy var openBody: [PureXML.Model.TreeNode] = [bodyRoot]
    /// The active formatting elements (HTML5 list); nil entries are scope markers.
    var activeFormatting: [PureXML.Model.TreeNode?] = []
    /// A frameset document's `frameset` stack; when non-empty its root is the body.
    private var framesetStack: [PureXML.Model.TreeNode] = []

    func build(_ tokens: [Token]) -> Node {
        for token in tokens {
            process(token)
        }
        // Open elements are already attached to their live tree, so head and body
        // children are read straight off their roots with no closing pass.
        let head = PureXML.Model.Element(name: .init("head"), attributes: headAttributes, children: headRoot.children.map(\.node))
        let secondChild: Node = if let frameset = framesetStack.first {
            frameset.node
        } else {
            .element(PureXML.Model.Element(name: .init("body"), attributes: bodyAttributes, children: bodyRoot.children.map(\.node)))
        }
        let html = PureXML.Model.Element(
            name: .init("html"),
            attributes: htmlAttributes,
            children: [.element(head), secondChild],
        )
        return .document([.element(html)])
    }

    private func process(_ token: Token) {
        switch mode {
        case .initial: processInitial(token)
        case .beforeHtml: processBeforeHtml(token)
        case .beforeHead: processBeforeHead(token)
        case .inHead: processInHead(token)
        case .afterHead: processAfterHead(token)
        case .inBody: processInBody(token)
        case .inFrameset: processInFrameset(token)
        case .afterFrameset: break
        }
    }

    private func processInitial(_ token: Token) {
        if case .doctype = token {
            return
        }
        if isIgnorableWhitespace(token) {
            return
        }
        mode = .beforeHtml
        process(token)
    }

    private func processBeforeHtml(_ token: Token) {
        if case let .startTag(name, attributes, _) = token, name == "html" {
            htmlAttributes = modelAttributes(attributes)
            mode = .beforeHead
            return
        }
        if isIgnorableWhitespace(token) {
            return
        }
        mode = .beforeHead
        process(token)
    }

    private func processBeforeHead(_ token: Token) {
        if isIgnorableWhitespace(token) {
            return
        }
        if case let .startTag(name, attributes, _) = token, name == "head" {
            headAttributes = modelAttributes(attributes)
            mode = .inHead
            return
        }
        mode = .inHead
        process(token)
    }

    private func processInHead(_ token: Token) {
        switch token {
        case let .startTag(name, attributes, selfClosing) where Self.headElements.contains(name):
            headOpen(name, attributes, selfClosing: selfClosing)
        case .endTag("head"):
            openHead = [headRoot]
            mode = .afterHead
        case let .endTag(name) where openHead.contains(where: { tagName($0) == name }):
            headClose(name)
        case let .comment(value):
            headInsert(.comment(value))
        case let .text(value) where openHead.count > 1 || value.trimmingXMLWhitespace().isEmpty:
            headInsert(.text(value))
        default:
            openHead = [headRoot]
            mode = .afterHead
            process(token)
        }
    }

    private func headOpen(_ name: String, _ attributes: [(String, String)], selfClosing: Bool) {
        if let closes = PureXML.HTML.Elements.impliedClose[name] {
            while let top = openHead.last, top !== headRoot, closes.contains(tagName(top)) {
                openHead.removeLast()
            }
        }
        let element = PureXML.Model.TreeNode.element(name, attributes: modelAttributes(attributes))
        openHead.last?.append(element)
        if !(PureXML.HTML.Elements.void.contains(name) || selfClosing) {
            openHead.append(element)
        }
    }

    private func headClose(_ name: String) {
        guard let index = openHead.lastIndex(where: { tagName($0) == name }), index >= 1 else { return }
        openHead.removeLast(openHead.count - index)
    }

    private func headInsert(_ node: PureXML.Model.TreeNode) {
        openHead.last?.append(node)
    }

    private func processAfterHead(_ token: Token) {
        if case let .startTag(name, attributes, _) = token, name == "frameset" {
            framesetStack = [PureXML.Model.TreeNode.element("frameset", attributes: modelAttributes(attributes))]
            mode = .inFrameset
            return
        }
        if case let .startTag(name, attributes, _) = token, name == "body" {
            bodyAttributes = modelAttributes(attributes)
            mode = .inBody
            return
        }
        if case let .startTag(name, _, _) = token, Self.headElements.contains(name) {
            mode = .inHead
            process(token)
            return
        }
        if isIgnorableWhitespace(token) {
            return
        }
        mode = .inBody
        process(token)
    }

    private func processInBody(_ token: Token) {
        switch token {
        case let .startTag(name, attributes, selfClosing):
            reconstructActiveFormatting()
            bodyOpen(name, attributes, selfClosing: selfClosing)
            noteOpenedFormatting(name, selfClosing: selfClosing)
        case let .endTag(name) where isFormatting(name):
            adoptionAgency(name)
        case let .endTag(name) where name != "body" && name != "html":
            bodyClose(name)
        case let .text(value):
            reconstructActiveFormatting()
            placeText(.text(value))
        case let .comment(value):
            bodyInsert(.comment(value))
        default:
            break
        }
    }

    /// Records a just-opened formatting element on the active-formatting list.
    private func noteOpenedFormatting(_ name: String, selfClosing: Bool) {
        guard isFormatting(name), !selfClosing, !PureXML.HTML.Elements.void.contains(name), let opened = openBody.last else { return }
        activeFormatting.append(opened)
    }

    private func processInFrameset(_ token: Token) {
        switch token {
        case let .startTag(name, attributes, _) where name == "frameset":
            let element = PureXML.Model.TreeNode.element("frameset", attributes: modelAttributes(attributes))
            framesetStack.last?.append(element)
            framesetStack.append(element)
        case let .startTag(name, attributes, _) where name == "frame":
            framesetStack.last?.append(PureXML.Model.TreeNode.element("frame", attributes: modelAttributes(attributes)))
        case let .startTag(name, attributes, _) where name == "noframes":
            framesetStack.last?.append(PureXML.Model.TreeNode.element("noframes", attributes: modelAttributes(attributes)))
        case let .endTag(name) where name == "frameset":
            if framesetStack.count > 1 {
                framesetStack.removeLast()
            } else {
                mode = .afterFrameset
            }
        case let .comment(value):
            framesetStack.last?.append(.comment(value))
        default:
            break
        }
    }

    /// The lowercased tag name of an open element, for case-insensitive matching.
    func tagName(_ node: PureXML.Model.TreeNode) -> String {
        node.name?.localName.lowercased() ?? ""
    }

    /// Tags that close an open `<select>` (the "in select" rule): a nested select,
    /// or an input/keygen/textarea.
    private static let closesSelect: Set<String> = ["select", "input", "keygen", "textarea"]

    /// Table-structural tags that close a select which is inside a table (the "in
    /// select in table" rule).
    private static let closesSelectInTable: Set<String> = ["caption", "table", "tbody", "tfoot", "thead", "tr", "td", "th"]

    /// The open-stack index of a `<select>` that an opening table tag should close
    /// (a select inside a table), or nil when there is none.
    private func selectInTableToClose(for name: String) -> Int? {
        guard Self.closesSelectInTable.contains(name),
              let selectIndex = openBody.lastIndex(where: { tagName($0) == "select" }), selectIndex >= 1,
              openBody[..<selectIndex].contains(where: { tagName($0) == "table" }) else { return nil }
        return selectIndex
    }

    private func bodyOpen(_ name: String, _ attributes: [(String, String)], selfClosing: Bool) {
        if Self.closesSelect.contains(name), let selectIndex = openBody.lastIndex(where: { tagName($0) == "select" }), selectIndex >= 1 {
            openBody.removeLast(openBody.count - selectIndex)
            if name == "select" {
                return
            } // a nested select just closes the open one
        }
        if let selectIndex = selectInTableToClose(for: name) {
            openBody.removeLast(openBody.count - selectIndex)
        }
        if let closes = PureXML.HTML.Elements.impliedClose[name] {
            while let top = openBody.last, top !== bodyRoot, closes.contains(tagName(top)) {
                openBody.removeLast()
            }
        }
        bodyEnsureTableContext(for: name)
        let namespace = bodyForeignNamespace(for: name)
        let element = PureXML.Model.TreeNode.element(qualifiedName(name, namespace), attributes: adjustedAttributes(modelAttributes(attributes), namespace: namespace))
        placeElement(element, name: name)
        if !(PureXML.HTML.Elements.void.contains(name) || selfClosing) {
            openBody.append(element)
        }
    }

    func bodyClose(_ name: String) {
        guard let index = openBody.lastIndex(where: { tagName($0) == name }), index >= 1 else { return }
        openBody.removeLast(openBody.count - index)
    }

    private func bodyInsert(_ node: PureXML.Model.TreeNode) {
        openBody.last?.append(node)
    }

    private func bodyEnsureTableContext(for name: String) {
        let structural: Set = ["table", "tbody", "thead", "tfoot", "tr"]
        guard let context = openBody.reversed().first(where: { structural.contains(tagName($0)) }).map(tagName) else { return }
        switch name {
        case "tr" where context == "table":
            bodyPushImplied("tbody")
        case "td", "th":
            if context == "table" {
                bodyPushImplied("tbody")
            }
            if context == "table" || ["tbody", "thead", "tfoot"].contains(context) {
                bodyPushImplied("tr")
            }
        default:
            break
        }
    }

    private func bodyPushImplied(_ name: String) {
        let element = PureXML.Model.TreeNode.element(name)
        openBody.last?.append(element)
        openBody.append(element)
    }

    /// Restores SVG attribute names to their canonical camel case.
    private func adjustedAttributes(_ attributes: [Attribute], namespace: String?) -> [Attribute] {
        guard namespace == ForeignNamespace.svg else { return attributes }
        return attributes.map { attribute in
            guard let adjusted = PureXML.HTML.ForeignNames.svgAttributes[attribute.name.localName.lowercased()] else { return attribute }
            return Attribute(adjusted, attribute.value)
        }
    }

    /// The foreign-content namespace for a body element: SVG/MathML on entry, the
    /// nearest open foreign ancestor's, or HTML (nil) inside an integration point.
    private func bodyForeignNamespace(for name: String) -> String? {
        if name == "svg" {
            return ForeignNamespace.svg
        }
        if name == "math" {
            return ForeignNamespace.mathml
        }
        for node in openBody.reversed() {
            guard let namespace = node.name?.namespaceURI else { continue }
            if Self.svgIntegrationPoints.contains(tagName(node)) {
                return nil
            }
            return namespace
        }
        return nil
    }

    /// The SVG HTML integration points: their content is parsed as HTML.
    private static let svgIntegrationPoints: Set<String> = ["foreignobject", "desc", "title"]
}

extension HTMLDocument {
    /// A qualified name carrying its foreign-content namespace, with SVG element
    /// names restored to their canonical camel case.
    private func qualifiedName(_ name: String, _ namespace: String?) -> PureXML.Model.QualifiedName {
        let local = namespace == ForeignNamespace.svg ? (PureXML.HTML.ForeignNames.svgElements[name] ?? name) : name
        return PureXML.Model.QualifiedName(prefix: nil, localName: local, namespaceURI: namespace)
    }

    private func modelAttributes(_ attributes: [(String, String)]) -> [Attribute] {
        attributes.map { Attribute($0.0, $0.1) }
    }

    private func isIgnorableWhitespace(_ token: Token) -> Bool {
        if case let .text(value) = token {
            return value.trimmingXMLWhitespace().isEmpty
        }
        return false
    }
}

extension PureXML.HTML {
    /// Builds a full HTML document tree from tokens via the insertion modes.
    enum DocumentBuilder {
        static func build(_ tokens: [Token]) -> PureXML.Model.Node {
            HTMLDocument().build(tokens)
        }
    }
}