#define IFCUNTYPEDENTITY_H

#include <map>

#include <fstream>

namespace IfcParse { class IfcUntypedEntity; }

#include "../ifcparse/IfcUtil.h"

#include "../ifcparse/Ifc2x3.h"

#include "../ifcgeom/IfcGeom.h"

namespace IfcParse {

class IfcUntypedEntity : public IfcUtil::IfcBaseEntity {

private:

IfcSchema::Type::Enum _type;

public:

IfcUntypedEntity(const std::string& s);

bool is(IfcSchema::Type::Enum v) const;

IfcSchema::Type::Enum type() const;

bool is_a(const std::string& s) const;

std::string is_a() const;

unsigned int id() const;

unsigned int getArgumentCount() const;

IfcUtil::ArgumentType getArgumentType(unsigned int i) const;

ArgumentPtr getArgument(unsigned int i) const;

ArgumentPtr getArgument(const std::string& a) const;

const char* getArgumentName(unsigned int i) const;

unsigned getArgumentIndex(const std::string& a) const;

IfcEntities get_inverse(const std::string& a);

void setArgument(unsigned int i);

void setArgument(unsigned int i, int v);

void setArgument(unsigned int i, bool v);

void setArgument(unsigned int i, double v);

void setArgument(unsigned int i, const std::string& v);

void setArgument(unsigned int i, const std::vector<int>& v);

void setArgument(unsigned int i, const std::vector<double>& v);

void setArgument(unsigned int i, const std::vector<std::string>& v);

void setArgument(unsigned int i, IfcUntypedEntity* v);

void setArgument(unsigned int i, IfcEntities v);

std::string toString();

std::pair<IfcUtil::ArgumentType,ArgumentPtr> get_argument(unsigned i);

std::pair<IfcUtil::ArgumentType,ArgumentPtr> get_argument(const std::string& a);

bool is_valid();

};

}

typedef IfcUtil::IfcSchemaEntity IfcEntity;

typedef std::map<IfcSchema::Type::Enum,IfcEntities> MapEntitiesByType;

typedef std::map<unsigned int,IfcEntity> MapEntityById;

typedef std::map<std::string,IfcSchema::IfcRoot::ptr> MapEntityByGuid;

typedef std::map<unsigned int,IfcEntities> MapEntitiesByRef;

typedef std::map<unsigned int,unsigned int> MapOffsetById;

namespace IfcParse {

class IfcSpfStream;

class Tokens;

class IfcFile {

private:

MapEntityById byid;

MapEntitiesByType bytype;

MapEntitiesByRef byref;

MapEntityByGuid byguid;

MapOffsetById offsets;

unsigned int lastId;

unsigned int MaxId;

std::string _filename;

std::string _timestamp;

std::string _author;

std::string _author_email;

std::string _author_organisation;

public:

IfcParse::IfcSpfStream* stream;

IfcParse::Tokens* tokens;

bool Init(const std::string& fn);

IfcEntities EntitiesByType(const std::string& t);

IfcEntity EntityById(int id);

IfcSchema::IfcRoot::ptr EntityByGuid(const std::string& guid);

void AddEntity(IfcUtil::IfcSchemaEntity e);

IfcFile();

~IfcFile();

std::vector<int> entity_names() const {

std::vector<int> keys;

keys.reserve(byid.size());

for (MapEntityById::const_iterator it = byid.begin(); it != byid.end(); ++ it) {

keys.push_back(it->first);

}

return keys;

}

};

IfcParse::IfcFile* open(const std::string& s) {

IfcParse::IfcFile* f = new IfcParse::IfcFile();

f->Init(s);

IfcEntities projects = f->EntitiesByType("IfcProject");

if (projects->Size() == 1) {

double unit_magnitude;

std::string unit_name;

IfcGeom::initialize_units_and_precision((IfcSchema::IfcProject*)*projects->begin(), unit_magnitude, unit_name);

}

return f;

}

std::string create_shape(IfcParse::IfcUntypedEntity* e, unsigned int settings = 0) {

if (!e->is(IfcSchema::Type::IfcProduct)) throw IfcException("Entity is not an IfcProduct");

IfcSchema::IfcProduct* ifc_product = (IfcSchema::IfcProduct*) e;

return IfcGeom::create_brep_data(ifc_product, settings);

}

void clean() {

IfcGeom::Cache::Purge();

}

const int DISABLE_OPENING_SUBTRACTIONS = 1 << 0;

const int DISABLE_OBJECT_PLACEMENT = 1 << 1;

const int SEW_SHELLS = 1 << 2;

const int CONVERT_TO_METERS = 1 << 3;

}

std::ostream& operator<< (std::ostream& os, const IfcParse::IfcFile& f);