/********************************************************************************
 *                                                                              *
 * This file is part of IfcOpenShell.                                           *
 *                                                                              *
 * IfcOpenShell is free software: you can redistribute it and/or modify         *
 * it under the terms of the Lesser GNU General Public License as published by  *
 * the Free Software Foundation, either version 3.0 of the License, or          *
 * (at your option) any later version.                                          *
 *                                                                              *
 * IfcOpenShell is distributed in the hope that it will be useful,              *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
 * Lesser GNU General Public License for more details.                          *
 *                                                                              *
 * You should have received a copy of the Lesser GNU General Public License     *
 * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
 *                                                                              *
 ********************************************************************************/

#define BOOST_RESULT_OF_USE_DECLTYPE

#ifdef WITH_IFCXML

#include "IfcFile.h"
#include "IfcLogger.h"

#include <boost/algorithm/string.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/algorithm/copy.hpp>
#include <boost/any.hpp>
#include <libxml/parser.h>

namespace {
    // Base case: when there are no more types left to check.
    template <typename Fn>
    void visit_any_impl(Fn& fn, const boost::any& a) {
    }

    // Recursive case: Check the first type in the pack.
    template <typename Fn, typename T, typename... Types>
    void visit_any_impl(Fn& fn, const boost::any& a) {
        if (a.type() == typeid(T)) {
            Fn(boost::any_cast<T>(a));
        } else {
            visit_any_impl<Types...>(a);
        }
    }

    // Helper to prepend a type to a tuple
    template <typename Fn, typename U>
    void visit_any(Fn fn, const boost::any& a);
    template <typename Fn, typename... Types>
    void visit_any(Fn fn, const boost::any & a) {
        visit_any_impl<Fn, Types...>(fn, a);
    };

}

// For debug printing on release builds
// #undef NDEBUG

// ifcXML is quite radically different for ifc2x3 and ifc4. ifc2x3 follows
// iso 10303 part 28 and puts all attribute values in XML text nodes. ifc4
// has attributes in actual XML attributes and may include inverse attributes
// to make trees more compact.
enum ifcxml_dialect {
    ifcxml_dialect_ifc2x3,
    ifcxml_dialect_ifc4,
    ifcxml_dialect_unknown
};

// "Dereferences" a named_attribute. For example:
// IfcCompoundPlaneAngleMeasure -> LIST [3:4] OF INTEGER
void follow_named(const IfcParse::parameter_type*& pt) {
    while (pt->as_named_type() != nullptr) {
        if (pt->as_named_type()->declared_type()->as_type_declaration() != nullptr) {
            pt = pt->as_named_type()->declared_type()->as_type_declaration()->declared_type();
        } else {
            break;
        }
    }
}

// The ifcXML parser uses SAX so we need to keep a stack of where we are in
// the file. These different kinds of nodes could be subclasses but aren't
// for ease in pushing to std::vector.
class stack_node {
  public:
    enum node_type {
        stack_empty,
        node_instance,
        node_instance_attribute,
        node_aggregate,
        node_aggregate_element,
        node_inverse,
        node_select,
        node_header,
        node_header_entry
    };

    // to be coerced into the correct type later on
    std::vector<boost::any> aggregate_elements;

  protected:
    node_type type_;
    IfcUtil::IfcBaseClass* inst_;
    int idx_;
    const IfcParse::inverse_attribute* inv_;
    std::string tagname_;
    std::string id_in_file_;
    const IfcParse::parameter_type* aggregate_elem_type_;

    stack_node()
        : type_(stack_empty),
          inst_(nullptr),
          idx_(-1),
          inv_(nullptr),
          aggregate_elem_type_(nullptr) {}

  public:
    static stack_node instance(const std::string& id, IfcUtil::IfcBaseClass* inst) {
        stack_node node;
        node.type_ = node_instance;
        node.inst_ = inst;
        node.id_in_file_ = id;
        return node;
    }

    static stack_node instance_attribute(IfcUtil::IfcBaseClass* inst, int idx) {
        stack_node node;
        node.type_ = node_instance_attribute;
        node.inst_ = inst;
        node.idx_ = idx;
        return node;
    }

    static stack_node aggregate(IfcUtil::IfcBaseClass* inst, int idx) {
        stack_node node;
        node.type_ = node_aggregate;
        node.inst_ = inst;
        node.idx_ = idx;
        return node;
    }

    static stack_node aggregate_element(const IfcParse::parameter_type* aggregate_elem_type, int idx) {
        stack_node node;
        node.type_ = node_aggregate_element;
        node.idx_ = idx;
        node.aggregate_elem_type_ = aggregate_elem_type;
        return node;
    }

    static stack_node inverse(IfcUtil::IfcBaseClass* inst, const IfcParse::inverse_attribute* inv) {
        stack_node node;
        node.type_ = node_inverse;
        node.inst_ = inst;
        node.inv_ = inv;
        return node;
    }

    static stack_node select(IfcUtil::IfcBaseClass* inst, int idx) {
        stack_node node;
        node.type_ = node_select;
        node.inst_ = inst;
        node.idx_ = idx;
        return node;
    }

    static stack_node header() {
        stack_node node;
        node.type_ = node_header;
        return node;
    };

    static stack_node header_entry(const std::string& tagname) {
        stack_node node;
        node.type_ = node_header_entry;
        node.tagname_ = tagname;
        return node;
    };

    node_type ntype() const { return type_; }

    IfcUtil::IfcBaseClass* inst() const { return inst_; }
    int idx() const { return idx_; }
    const IfcParse::inverse_attribute* inv_attr() const { return inv_; }
    const std::string& tagname() const { return tagname_; }
    const std::string& id() const { return id_in_file_; }
    const IfcParse::parameter_type* aggregate_elem_type() const { return aggregate_elem_type_; }

    std::string repr() const {
        std::stringstream stream;
        static const char* const node_type_names[] = {"empty", "inst", "attr", "aggr", "agelem", "inv", "sel", "head", "hdentry"};
        stream << "[" << node_type_names[type_] << "] ";
        if (inst_ != nullptr) {
            stream << inst_->declaration().name() << " ";
        }
        if (type_ == node_aggregate) {
            stream << "{" << aggregate_elements.size() << " elems} ";
        }
        if (idx_ != -1) {
            stream << idx_ << " ";
        }
        return stream.str();
    }
};

struct ifcxml_parse_state {
    IfcParse::IfcFile* file;
    std::vector<stack_node> stack;
    std::map<std::string, int> idmap;
    std::vector<std::tuple<IfcUtil::IfcBaseEntity*, size_t, std::string>> forward_references;
    ifcxml_dialect dialect;
};

// ifc4 allows for aggregates to be concatenated using whitespace.
template <typename T>
std::vector<T> split(const std::string& value) {
    std::vector<std::string> strs;
    boost::split(
        strs, value, [](char character) { return character == ' '; }, boost::token_compress_on);
    std::vector<T> r(strs.size());
    boost::copy(strs | boost::adaptors::transformed([](const std::string& s) {
                    return boost::lexical_cast<T>(s);
                }),
                r.begin());
    return r;
}

boost::any parse_attribute_value(const IfcParse::parameter_type* ty, const std::string& value) {
    boost::any any;
    auto cpp_type = IfcUtil::from_parameter_type(ty);

    if (cpp_type == IfcUtil::Argument_STRING) {
        any = value;
    } else if (cpp_type == IfcUtil::Argument_ENUMERATION) {
        const auto* enum_type = ty->as_named_type()->declared_type()->as_enumeration_type();

        std::vector<std::string>::const_iterator iter = std::find(
            enum_type->enumeration_items().begin(),
            enum_type->enumeration_items().end(),
            boost::to_upper_copy(value));

        any = EnumerationReference(enum_type, std::distance(enum_type->enumeration_items().begin(), iter));
    } else if (cpp_type == IfcUtil::Argument_INT) {
        any = boost::lexical_cast<int>(value);
    } else if (cpp_type == IfcUtil::Argument_DOUBLE) {
        any = boost::lexical_cast<double>(value);
    } else if (cpp_type == IfcUtil::Argument_BOOL) {
        any = boost::to_lower_copy(value) == "true";
    } else if (cpp_type == IfcUtil::Argument_AGGREGATE_OF_INT) {
        any = split<int>(value);
    } else if (cpp_type == IfcUtil::Argument_AGGREGATE_OF_DOUBLE) {
        any = split<double>(value);
    }

    if (any.empty()) {
        Logger::Error("Attribute '" + value + "' not successfully parsed");
    }

    return any;
}

static void end_element(void* user, const xmlChar* tag) {
    ifcxml_parse_state* state = (ifcxml_parse_state*)user;

    if (state->file == nullptr) {
        return;
    }

    if (!state->stack.empty() && state->stack.back().ntype() == stack_node::node_aggregate) {
        const auto& back = state->stack.back();
        auto& elems = state->stack.back().aggregate_elements;
        /*
        auto* list = new IfcParse::ArgumentList(elems.size());
        size_t i = 0;
        for (auto& elem : elems) {
            list->arguments()[i++] = elem;
        }
        */
        // @todo
        // back.inst()->set_attribute_value(back.idx(), elems);
    }

    if (state->dialect == ifcxml_dialect_ifc2x3 && state->stack.back().ntype() == stack_node::node_instance) {
        if (state->stack.back().inst() != nullptr) {
            state->idmap[state->stack.back().id()] = state->file->addEntity(state->stack.back().inst())->id();
        }
    }

    const std::string tagname = (char*)tag;

    // ignore uos ex:iso_10303_28 (ifc2x3) and ifc:ifcXML (ifc4)
    if (tagname != "uos" && tagname != "ex:iso_10303_28" && tagname != "ifc:ifcXML" && tagname != "ifcXML") {
        if (state->stack.empty()) {
            Logger::Error("Mismatch in parse stack due to previous errors");
        } else {
            state->stack.pop_back();
        }
    }
}

static void process_characters(void* user, const xmlChar* character, int len) {
    ifcxml_parse_state* state = (ifcxml_parse_state*)user;

    if (state->file == nullptr) {
        return;
    }

    std::string txt((char*)character, len);

    stack_node::node_type state_type = stack_node::stack_empty;
    if (!state->stack.empty()) {
        state_type = state->stack.back().ntype();
    }

    if (!state->stack.empty() && state->stack.back().inst() != nullptr && (state->stack.back().inst()->declaration().as_type_declaration() != nullptr)) {
        const auto* pt = state->stack.back().inst()->declaration().as_type_declaration()->declared_type();
        boost::any val;
        try {
            val = parse_attribute_value(pt, txt);
        } catch (const std::exception& e) {
            Logger::Error(e, state->stack.back().inst());
        }
        if (!val.empty()) {
            // type declaration always at idx 0
            visit_any([&state](auto& v) {
                state->stack.back().inst()->set_attribute_value(0, v);
            }, val);
        }
    } else if (state_type == stack_node::node_header_entry) {
        const std::string tagname = boost::replace_all_copy(state->stack.back().tagname(), "ex:", "");
        auto& header = state->file->header();
        if (tagname == "name") {
            header.file_name()->setname(txt);
        } else if (tagname == "time_stamp") {
            header.file_name()->settime_stamp(txt);
        } else if (tagname == "author") {
            header.file_name()->setauthor({txt});
        } else if (tagname == "organization") {
            header.file_name()->setorganization({txt});
        } else if (tagname == "preprocessor_version") {
            header.file_name()->setpreprocessor_version(txt);
        } else if (tagname == "originating_system") {
            header.file_name()->setoriginating_system(txt);
        } else if (tagname == "authorization") {
            header.file_name()->setauthorization(txt);
        } else if (tagname == "documentation") {
            header.file_description()->setdescription({txt});
        } else {
            Logger::Error("Unrecognized header entry " + tagname);
        }
    } else if (state_type == stack_node::node_instance_attribute) {
        const auto* pt = state->stack.back().inst()->declaration().as_entity()->attribute_by_index(state->stack.back().idx())->type_of_attribute();
        auto cpp_type = IfcUtil::from_parameter_type(pt);
        if (cpp_type != IfcUtil::Argument_ENTITY_INSTANCE) {
            auto val = parse_attribute_value(pt, txt);
            if (!val.empty()) {
                visit_any([&state](auto& v) {
                    state->stack.back().inst()->set_attribute_value(state->stack.back().idx(), v);
                }, val);
            }
        }
    } else if (state_type == stack_node::node_aggregate_element) {
        const auto* pt = state->stack.back().aggregate_elem_type();
        auto val = parse_attribute_value(pt, txt);
        if (!val.empty()) {
            (*(state->stack.rbegin() + 1)).aggregate_elements.push_back(val);
        }
    }
}

static void start_element(void* user, const xmlChar* tag, const xmlChar** attrs) {
    ifcxml_parse_state* state = (ifcxml_parse_state*)user;
    std::string tagname = (char*)tag;

#ifndef NDEBUG
    std::cout << "stack:" << std::endl;
    {
        int i = 1;
        for (auto& node : state->stack) {
            std::cout << "  " << (i++) << ":" << node.repr() << std::endl;
        }
    }
    std::cout << std::string(state->stack.size(), ' ') << "<" << tagname << ">";
#endif

    std::vector<std::pair<std::string, std::string>> attributes;

    if (attrs != nullptr) {
        std::string attrname;
        int i = 0;
        while (attrs[i] != NULL) {
            if ((i % 2) != 0) {
                const std::string value = (char*)attrs[i];
#ifndef NDEBUG
                std::cout << " " << attrname << "='" << value << "'";
#endif
                attributes.push_back(std::make_pair(attrname, value));

                if ((tagname == "ifc:ifcXML" || tagname == "ifcXML") && attrname == "xsi:schemaLocation" &&
                    (boost::starts_with(value, "http://www.buildingsmart-tech.org/ifcXML/IFC4") ||
                     boost::starts_with(value, "http://www.buildingsmart-tech.org/ifc/IFC4"))) {
                    // We're expecting a schemaLocation like "http://www.buildingsmart-tech.org/ifcXML/IFC4/Add2 IFC4_ADD2_TC1.xsd"
                    // With token compression this is split into:
                    // [0] http:
                    // [1] www.buildingsmart-tech.org
                    // [2] ifcXML
                    // [3] IFC4
                    // [4] Add2
                    // [5] IFC4_ADD2_TC1.xsd
                    // The hosstname will likely change though.
                    auto it = boost::algorithm::make_split_iterator(value, boost::algorithm::token_finder(boost::algorithm::is_any_of("/ "), boost::algorithm::token_compress_on));
                    decltype(it) end;
                    for (int tok = 0; it != end && tok < 3; ++it, ++tok) {
                    }
                    if (it != end) {
                        std::string schema_name(&it->front(), it->size());
                        boost::to_upper(schema_name);
                        state->file = new IfcParse::IfcFile(IfcParse::schema_by_name(schema_name));
                        state->dialect = ifcxml_dialect_ifc4;
                    }
                    goto end;
                } else if (tagname == "ex:iso_10303_28" && attrname == "xsi:schemaLocation" && boost::starts_with(value, "http://www.iai-tech.org/ifcXML/IFC2x3")) {
                    state->file = new IfcParse::IfcFile(IfcParse::schema_by_name("IFC2X3"));
                    state->dialect = ifcxml_dialect_ifc2x3;
                    goto end;
                }
            } else {
                attrname = (char*)attrs[i];
            }
            i++;
        }
    }

    if (state->file == nullptr) {
        return;
    }

    {
        // ifcXML id attributes are commonly numeric identifiers prefixed with 'i' (as
        // XML identifiers need to start with a alphabetic character). This convention
        // is not always followed, so a mapping is kept from XML string attribute to
        // numeric index into the IfcParse::IfcFile.
        std::string id;

        // Create an attribute value from an instance. Potentially NULL in case it is a
        // forward reference to an instance not yet encountered.
        auto instance_to_attribute = [&state](const std::variant<std::string, IfcUtil::IfcBaseClass*>& inst_or_ref, size_t attribute_index, IfcUtil::IfcBaseClass*& inst) {
            if (inst_or_ref.index() == 0) {
                inst = nullptr;
                // This attribute is NULL initially and after parsing the complete
                // file populated in a subsequent step.
                state->forward_references.push_back(std::make_tuple(inst->as<IfcUtil::IfcBaseEntity>(), attribute_index, std::get<std::string>(inst_or_ref)));
            } else {
                inst = std::get<IfcUtil::IfcBaseClass*>(inst_or_ref);
                inst->set_attribute_value(attribute_index, inst);
            }
        };

        // Create or reference an instance from the file and set attributes based on XML attributes.
        auto create_instance = [&state, &attributes](const IfcParse::declaration* decl) {
            boost::optional<std::string> id;
            std::variant<std::string, IfcUtil::IfcBaseClass*> rv;

            for (auto& pair : attributes) {
                if (pair.first == "id" || pair.first == "href" || pair.first == "ref") {
                    id = id = pair.second;
                    if (pair.first == "href" || pair.first == "ref") {
                        if (state->idmap.find(pair.second) == state->idmap.end()) {
                            rv = pair.second;
                            return rv;
                        }
                        rv = state->file->instance_by_id(state->idmap[pair.second]);
                        return rv;
                    }
                } else if (pair.first == "xsi:type") {
                    decl = state->file->schema()->declaration_by_name(pair.second)->as_entity();
                }
            }

            auto untyped = IfcEntityInstanceData(in_memory_attribute_storage(decl->as_entity() != nullptr ? decl->as_entity()->attribute_count() : 1));

            const IfcParse::entity* entity = decl->as_entity();
            if (entity != nullptr) {
                for (auto& pair : attributes) {
                    if (pair.first == "id" || pair.first == "xsi:type" || pair.first == "pos") {
                        continue;
                    }

                    auto idx = entity->attribute_index(pair.first);
                    if (idx != -1) {
                        const auto* attr = entity->attribute_by_index(idx);
                        auto val = parse_attribute_value(attr->type_of_attribute(), pair.second);
                        if (!val.empty()) {
                            visit_any([&untyped, idx](auto& v) {
                                untyped.set_attribute_value(idx, v);
                            }, val);
                        }
                    } else {
                        Logger::Error("Unknown attribute '" + pair.first + "' on entity '" + entity->name() + "' with value '" + pair.second + "'");
                    }
                }
            }

            IfcUtil::IfcBaseClass* newinst = state->file->schema()->instantiate(decl, std::move(untyped));

            if (state->dialect == ifcxml_dialect_ifc4) {
                // In IFC2X3 not added directly because attrs such as GlobalId are in
                // subsequent child nodes
                newinst = state->file->addEntity(newinst);
                if (id) {
                    state->idmap[*id] = newinst->id();
                }
            }

            rv = newinst;
            return rv;
        };

        stack_node::node_type state_type = stack_node::stack_empty;
        if (!state->stack.empty()) {
            state_type = state->stack.back().ntype();
        }

        const std::string tagname_copy = boost::replace_all_copy(tagname, "-wrapper", "");

        if (state_type == stack_node::node_select) {
            const IfcParse::declaration* decl = state->file->schema()->declaration_by_name(tagname_copy);
            // Argument* attr;
            IfcUtil::IfcBaseClass* inst;
            auto inst_ = create_instance(decl);
            instance_to_attribute(inst_, state->stack.back().idx(), inst);
            // state->stack.back().inst()->set_attribute_value(state->stack.back().idx(), attr);
            state->stack.push_back(stack_node::instance(id, inst));
        } else if (state_type == stack_node::node_aggregate) {

            const IfcParse::parameter_type* attribute_type = state->stack.back().inst()->declaration().as_entity()->attribute_by_index(state->stack.back().idx())->type_of_attribute();
            follow_named(attribute_type);
            const IfcParse::parameter_type* element_type = attribute_type->as_aggregation_type()->type_of_element();
            follow_named(element_type);

            int aggrpos = -1;

            /*
			auto it = std::find_if(attributes.begin(), attributes.end(), [](const std::pair<std::string, std::string>& p) {
				return p.first == "pos";
			});
			boost::lexical_cast<int>(it->second);
			*/

            if (element_type->as_simple_type() != nullptr) {
                state->stack.push_back(stack_node::aggregate_element(element_type, aggrpos));
            } else {
                const IfcParse::declaration* decl = nullptr;
                try {
                    decl = state->file->schema()->declaration_by_name(tagname_copy);
                } catch (const std::exception& e) {
                    Logger::Error(e);
                }
                if (decl != nullptr) {
                    auto inst_or_ref = create_instance(decl);
                    IfcUtil::IfcBaseClass* inst;
                    // Argument* attr;
                    // @todo
                    // instance_to_attribute(inst_or_ref, attr, inst);
                    state->stack.back().aggregate_elements.push_back(boost::any{});
                    state->stack.push_back(stack_node::instance(id, inst));
                }
            }
        } else if (state_type == stack_node::node_instance) {
            const IfcParse::entity* current = state->stack.back().inst()->declaration().as_entity();
            if (current == nullptr) {
                Logger::Error("'" + state->stack.back().inst()->declaration().name() + "' is not an entity, unable to set attribute '" + tagname + "'");
                // We need to push something on the stack. Likely there has been some extra indirection that is not understood.
                state->stack.push_back(state->stack.back());
            } else {
                auto idx = current->attribute_index(tagname);
                if (idx == -1) {
                    auto inverses = current->all_inverse_attributes();
                    auto found = std::find_if(inverses.begin(), inverses.end(), [&tagname](const IfcParse::inverse_attribute* attr) {
                        return attr->name() == tagname;
                    });
                    if (found == inverses.end()) {
                        Logger::Error("Unknown attribute " + tagname);
                        state->stack.push_back(state->stack.back());
                    } else {
                        if ((*found)->bound1() == 0 && (*found)->bound2() == 1) {
                            auto inst_or_ref = create_instance((*found)->entity_reference());
                            IfcUtil::IfcBaseClass* inst;
                            instance_to_attribute(inst_or_ref, 0, inst);
                            if (inst != nullptr) {
                                int idx = (*found)->entity_reference()->attribute_index(
                                    (*found)->attribute_reference());
                                inst->set_attribute_value(idx, state->stack.back().inst());
                                state->stack.push_back(stack_node::instance(id, inst));
                            } else {
                                Logger::Error("Unknown attribute " + tagname);
                                state->stack.push_back(state->stack.back());
                            }
                        } else {
                            state->stack.push_back(stack_node::inverse(state->stack.back().inst(), *found));
                        }
                    }
                } else {
                    const IfcParse::parameter_type* attribute_type = current->attribute_by_index(idx)->type_of_attribute();
                    if (state->dialect == ifcxml_dialect_ifc2x3) {
                        follow_named(attribute_type);
                        if (attribute_type->as_aggregation_type() != nullptr) {
                            state->stack.push_back(stack_node::aggregate(state->stack.back().inst(), idx));
                        } else {
                            state->stack.push_back(stack_node::instance_attribute(state->stack.back().inst(), idx));
                        }
                    } else {
                        if (IfcUtil::from_parameter_type(attribute_type) == IfcUtil::Argument_ENTITY_INSTANCE) {
                            if (const auto* entity = attribute_type->as_named_type()->declared_type()->as_entity()) {
                                auto inst_or_reference = create_instance(entity);
                                IfcUtil::IfcBaseClass* inst;
                                instance_to_attribute(inst_or_reference, idx, inst);
                                // @todo
                                state->stack.back().inst();
                                state->stack.push_back(stack_node::instance(id, std::get<IfcUtil::IfcBaseClass*>(inst_or_reference)));
                            } else if (attribute_type->as_named_type()->declared_type()->as_select_type() != nullptr) {
                                // Select types cause an additional indirection, so the current stack node is simply repeated
                                state->stack.push_back(stack_node::select(state->stack.back().inst(), idx));
                            }
                        } else if (attribute_type->as_aggregation_type() != nullptr) {
                            state->stack.push_back(stack_node::aggregate(state->stack.back().inst(), idx));
                        }
                    }
                }
            }
        } else if (state->file != nullptr) {
            if (state_type == stack_node::node_header) {
                state->stack.push_back(stack_node::header_entry(tagname));
            } else if (tagname == "ex:iso_10303_28_header" || tagname == "header") {
                state->stack.push_back(stack_node::header());
            } else if (tagname == "uos") {
                // intentially empty, ignored in end_element() as well
            } else {
                const IfcParse::declaration* decl = nullptr;
                try {
                    decl = state->file->schema()->declaration_by_name(tagname);
                } catch (const std::exception& e) {
                    Logger::Error(e);
                }

                if (decl == nullptr) {
                    goto end;
                }

                const IfcParse::entity* entity = decl->as_entity();
                if ((entity == nullptr) && state_type != stack_node::node_instance_attribute) {
                    Logger::Error("Not an entity definition " + tagname);
                    goto end;
                }

                auto inst_or_ref = create_instance(decl);
                IfcUtil::IfcBaseClass* inst;
                instance_to_attribute(inst_or_ref, state->stack.back().idx(), inst);

                if (state_type == stack_node::node_inverse) {
                    int idx = state->stack.back().inv_attr()->entity_reference()->attribute_index(
                        state->stack.back().inv_attr()->attribute_reference());
                    if (inst != nullptr) {
                        inst->set_attribute_value(idx, state->stack.back().inst());
                    } else {
                        Logger::Error("Internal error, inverse attribute not processed");
                    }
                } else if (state_type == stack_node::node_instance_attribute) {
                    state->stack.back().inst()->set_attribute_value(state->stack.back().idx(), inst);
                }

                if (entity == nullptr) {
                    // Type declaration, immediately populate attr 0
                    state->stack.push_back(stack_node::instance_attribute(inst, 0));
                } else {
                    state->stack.push_back(stack_node::instance(id, inst));
                }
            }
        }
    }

end:
#ifndef NDEBUG
    std::cout << std::endl;
#endif
    return;
}

IFC_PARSE_API IfcParse::IfcFile* IfcParse::parse_ifcxml(const std::string& filename) {
    throw std::runtime_error("IFC-XML import temporarily disabled");

    ifcxml_parse_state state;
    state.file = nullptr;
    state.dialect = ifcxml_dialect_unknown;

    xmlSAXHandler handler;
    memset(&handler, 0, sizeof(xmlSAXHandler));
    handler.startElement = start_element;
    handler.endElement = end_element;
    handler.characters = process_characters;

    xmlSAXUserParseFile(&handler, &state, filename.c_str());

    for (const auto& pair : state.forward_references) {
        /*
        auto it = state.idmap.find(pair.second);
        if (it == state.idmap.end()) {
            Logger::Error("Instance with id '" + pair.second + "' not encountered");
        } else {
            pair.first->set(state.file->instance_by_id(it->second));
        }
        */
    }

    if (state.file != nullptr) {
        // state.file->parsing_complete() = true;
        state.file->build_inverses();
    }

    return state.file;
}

#endif // WITH_IFCXML