/********************************************************************************
 *                                                                              *
 * 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/>.         *
 *                                                                              *
 ********************************************************************************/

// A class declaration to silence SWIG warning about base classes being
// undefined, the constructor is private so that SWIG does not wrap them
class IfcEntityInstanceData {
private:
	IfcEntityInstanceData();
};

#define invalid_argument(i, arg_name) { throw IfcParse::IfcException(IfcSchema::Type::GetAttributeName(self->entity->type(), (unsigned char)i) + " is not a valid type for '" + arg_name + "'"); }

%ignore IfcParse::IfcFile::Init;
%ignore IfcParse::IfcFile::entityByGuid;
%ignore IfcParse::IfcFile::register_inverse;
%ignore IfcParse::IfcFile::unregister_inverse;
%ignore operator<<;

%ignore IfcParse::FileDescription::FileDescription;
%ignore IfcParse::FileName::FileName;
%ignore IfcParse::FileSchema::FileSchema;
%ignore IfcParse::IfcFile::tokens;

%ignore IfcParse::IfcSpfHeader::IfcSpfHeader(IfcSpfLexer*);
%ignore IfcParse::IfcSpfHeader::lexer;
%ignore IfcParse::IfcSpfHeader::stream;
%ignore IfcParse::HeaderEntity::is;

%ignore IfcParse::IfcFile::type_iterator;

%ignore IfcUtil::IfcBaseClass::is;

%rename("by_id") entityById;
%rename("by_type") entitiesByType;
%rename("__len__") getArgumentCount;
%rename("get_argument_type") getArgumentType;
%rename("get_argument_name") getArgumentName;
%rename("get_argument_index") getArgumentIndex;
%rename("get_argument_optionality") getArgumentOptionality;
%rename("get_attribute_names") getAttributeNames;
%rename("get_inverse_attribute_names") getInverseAttributeNames;
%rename("entity_instance") IfcBaseClass;
%rename("file") IfcFile;
%rename("add") addEntity;
%rename("remove") removeEntity;

%extend IfcParse::IfcFile {
	IfcUtil::IfcBaseClass* by_guid(const std::string& guid) {
		return $self->entityByGuid(guid);
	}
	IfcEntityList::ptr get_inverse(IfcUtil::IfcBaseClass* e) {
		return $self->getInverse(e->entity->id(), IfcSchema::Type::UNDEFINED, -1);
	}

	void write(const std::string& fn) {
		std::ofstream f(fn.c_str());
		f << (*$self);
	}

	std::vector<unsigned> entity_names() const {
		std::vector<unsigned> keys;
		keys.reserve(std::distance($self->begin(), $self->end()));
		for (IfcParse::IfcFile::entity_by_id_t::const_iterator it = $self->begin(); it != $self->end(); ++ it) {
			keys.push_back(it->first);
		}
		return keys;
	}

	std::vector<std::string> types() const {
		const size_t n = std::distance($self->types_begin(), $self->types_end());
		std::vector<std::string> ts;
		ts.reserve(n);
		std::transform($self->types_begin(), $self->types_end(), std::back_inserter(ts), IfcSchema::Type::ToString);
		return ts;
	}

	std::vector<std::string> types_with_super() const {
		const size_t n = std::distance($self->types_incl_super_begin(), $self->types_incl_super_end());
		std::vector<std::string> ts;
		ts.reserve(n);
		std::transform($self->types_incl_super_begin(), $self->types_incl_super_end(), std::back_inserter(ts), IfcSchema::Type::ToString);
		return ts;
	}

	%pythoncode %{
        # Hide the getters with read-only property implementations
        header = property(header)
	%}
}

%extend IfcUtil::IfcBaseClass {

	int get_attribute_category(const std::string& name) const {
		if (IfcSchema::Type::IsSimple($self->type())) {
			return name == "wrappedValue";
		}
		IfcUtil::IfcBaseEntity* self_ = (IfcUtil::IfcBaseEntity*) self; 
		const std::vector<std::string> names = self_->getAttributeNames();
		if (std::find(names.begin(), names.end(), name) != names.end()) {
			return 1;
		} else {
			const std::vector<std::string> names = self_->getInverseAttributeNames();
			if (std::find(names.begin(), names.end(), name) != names.end()) {
				return 2;
			} else {
				return 0;
			}
		}
	}

	// id() is defined on IfcBaseEntity and not on IfcBaseClass, in order
	// to expose it to the Python wrapper it is simply duplicated here.
	// Same applies to the two methods reimplemented below.
	int id() const {
		return $self->entity->id();
	}

	std::vector<std::string> getAttributeNames() const {
		if (IfcSchema::Type::IsSimple($self->type())) {
			return std::vector<std::string>(1, "wrappedValue");
		}
		IfcUtil::IfcBaseEntity* self_ = (IfcUtil::IfcBaseEntity*) self; 
		return self_->getAttributeNames();
	}

	std::vector<std::string> getInverseAttributeNames() const {
		if (IfcSchema::Type::IsSimple($self->type())) {
			return std::vector<std::string>(0);
		}
		IfcUtil::IfcBaseEntity* self_ = (IfcUtil::IfcBaseEntity*) self; 
		return self_->getInverseAttributeNames();
	}
	
	bool is_a(const std::string& s) {
		return self->is(IfcSchema::Type::FromString(boost::to_upper_copy(s)));
	}

	std::string is_a() const {
		return IfcSchema::Type::ToString(self->entity->type());
	}

	std::pair<IfcUtil::ArgumentType,Argument*> get_argument(unsigned i) {
		return std::pair<IfcUtil::ArgumentType,Argument*>($self->getArgumentType(i), $self->getArgument(i));
	}

	std::pair<IfcUtil::ArgumentType,Argument*> get_argument(const std::string& a) {
		unsigned i = IfcSchema::Type::GetAttributeIndex($self->type(), a);
		return std::pair<IfcUtil::ArgumentType,Argument*>($self->getArgumentType(i), $self->getArgument(i));
	}

	bool __eq__(IfcUtil::IfcBaseClass* other) const {
		if ($self == other) {
			return true;
		}
		if (IfcSchema::Type::IsSimple($self->type()) || IfcSchema::Type::IsSimple(other->type())) {
			/// @todo
			return false;
		} else {
			IfcUtil::IfcBaseEntity* self_ = (IfcUtil::IfcBaseEntity*) self;
			IfcUtil::IfcBaseEntity* other_ = (IfcUtil::IfcBaseEntity*) other;
			return self_->id() == other_->id() && self_->entity->file == other_->entity->file;
		} 
	}

	std::string __repr__() const {
		return $self->entity->toString();
	}

	// Just something to have a somewhat sensible value to hash
	size_t file_pointer() const {
		return reinterpret_cast<size_t>($self->entity->file);
	}

	unsigned get_argument_index(const std::string& a) const {
		return IfcSchema::Type::GetAttributeIndex(self->entity->type(), a);
	}

	IfcEntityList::ptr get_inverse(const std::string& a) {
		std::pair<IfcSchema::Type::Enum, unsigned> inv = IfcSchema::Type::GetInverseAttribute(self->entity->type(), a);
		return self->entity->getInverse(inv.first, inv.second);
	}

	void setArgumentAsNull(unsigned int i) {
		bool is_optional = IfcSchema::Type::GetAttributeOptional(self->entity->type(), (unsigned char)i);
		if (is_optional) {
			self->entity->setArgument(i, new IfcWrite::IfcWriteArgument());
		} else invalid_argument(i,"NULL");
	}

	void setArgumentAsInt(unsigned int i, int v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_INT) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);	
		} else if ( (arg_type == IfcUtil::Argument_BOOL) && ( (v == 0) || (v == 1) ) ) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v == 1);
			self->entity->setArgument(i, arg);	
		} else invalid_argument(i,"INTEGER");
	}

	void setArgumentAsBool(unsigned int i, bool v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_BOOL) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);	
		} else invalid_argument(i,"BOOLEAN");
	}

	void setArgumentAsDouble(unsigned int i, double v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_DOUBLE) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);	
		} else invalid_argument(i,"REAL");
	}

	void setArgumentAsString(unsigned int i, const std::string& a) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_STRING) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(a);
			self->entity->setArgument(i, arg);	
		} else if (arg_type == IfcUtil::Argument_ENUMERATION) {
			std::pair<const char*, int> enum_data = IfcSchema::Type::GetEnumerationIndex(IfcSchema::Type::GetAttributeEntity(self->entity->type(), (unsigned char)i), a);
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(IfcWrite::IfcWriteArgument::EnumerationReference(enum_data.second, enum_data.first));
			self->entity->setArgument(i, arg);
		} else if (arg_type == IfcUtil::Argument_BINARY) {
			if (IfcUtil::valid_binary_string(a)) {
				boost::dynamic_bitset<> bits(a);
				IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
				arg->set(bits);
				self->entity->setArgument(i, arg);
			} else {
				throw IfcParse::IfcException("String not a valid binary representation");
			}
		} else invalid_argument(i,"STRING");
	}

	void setArgumentAsAggregateOfInt(unsigned int i, const std::vector<int>& v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_AGGREGATE_OF_INT) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"AGGREGATE OF INT");
	}

	void setArgumentAsAggregateOfDouble(unsigned int i, const std::vector<double>& v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_AGGREGATE_OF_DOUBLE) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"AGGREGATE OF DOUBLE");
	}

	void setArgumentAsAggregateOfString(unsigned int i, const std::vector<std::string>& v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_AGGREGATE_OF_STRING) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else if (arg_type == IfcUtil::Argument_AGGREGATE_OF_BINARY) {
			std::vector< boost::dynamic_bitset<> > bits;
			bits.reserve(v.size());
			for (std::vector<std::string>::const_iterator it = v.begin(); it != v.end(); ++it) {
				if (IfcUtil::valid_binary_string(*it)) {
					bits.push_back(boost::dynamic_bitset<>(*it));
				} else {
					throw IfcParse::IfcException("String not a valid binary representation");
				}			
			}
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(bits);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"AGGREGATE OF STRING");
	}

	void setArgumentAsEntityInstance(unsigned int i, IfcUtil::IfcBaseClass* v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_ENTITY_INSTANCE) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"ENTITY INSTANCE");
	}

	void setArgumentAsAggregateOfEntityInstance(unsigned int i, IfcEntityList::ptr v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"AGGREGATE OF ENTITY INSTANCE");
	}

	void setArgumentAsAggregateOfAggregateOfInt(unsigned int i, const std::vector< std::vector<int> >& v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"AGGREGATE OF AGGREGATE OF INT");
	}

	void setArgumentAsAggregateOfAggregateOfDouble(unsigned int i, const std::vector< std::vector<double> >& v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"AGGREGATE OF AGGREGATE OF DOUBLE");
	}

	void setArgumentAsAggregateOfAggregateOfEntityInstance(unsigned int i, IfcEntityListList::ptr v) {
		IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(self->entity->type(), (unsigned char)i);
		if (arg_type == IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE) {
			IfcWrite::IfcWriteArgument* arg = new IfcWrite::IfcWriteArgument();
			arg->set(v);
			self->entity->setArgument(i, arg);
		} else invalid_argument(i,"AGGREGATE OF AGGREGATE OF ENTITY INSTANCE");
	}
}

%extend IfcParse::IfcSpfHeader {
	%pythoncode %{
        # Hide the getters with read-only property implementations
        file_description = property(file_description)
        file_name = property(file_name)
        file_schema = property(file_schema)
	%}
};

%extend IfcParse::FileDescription {
	%pythoncode %{
        # Hide the getters with read-write property implementations
        __swig_getmethods__["description"] = description
        __swig_setmethods__["description"] = description
        description = property(description, description)
        __swig_getmethods__["implementation_level"] = implementation_level
        __swig_setmethods__["implementation_level"] = implementation_level
        implementation_level = property(implementation_level, implementation_level)
	%}
};

%extend IfcParse::FileName {
	%pythoncode %{
        # Hide the getters with read-write property implementations
        __swig_getmethods__["name"] = name
        __swig_setmethods__["name"] = name
        name = property(name, name)
        __swig_getmethods__["time_stamp"] = time_stamp
        __swig_setmethods__["time_stamp"] = time_stamp
        time_stamp = property(time_stamp, time_stamp)
        __swig_getmethods__["author"] = author
        __swig_setmethods__["author"] = author
        author = property(author, author)
        __swig_getmethods__["organization"] = organization
        __swig_setmethods__["organization"] = organization
        organization = property(organization, organization)
        __swig_getmethods__["preprocessor_version"] = preprocessor_version
        __swig_setmethods__["preprocessor_version"] = preprocessor_version
        preprocessor_version = property(preprocessor_version, preprocessor_version)
        __swig_getmethods__["originating_system"] = originating_system
        __swig_setmethods__["originating_system"] = originating_system
        originating_system = property(originating_system, originating_system)
        __swig_getmethods__["authorization"] = authorization
        __swig_setmethods__["authorization"] = authorization
        authorization = property(authorization, authorization)
	%}
};

%extend IfcParse::FileSchema {
	%pythoncode %{
        # Hide the getters with read-write property implementations
        __swig_getmethods__["schema_identifiers"] = schema_identifiers
        __swig_setmethods__["schema_identifiers"] = schema_identifiers
        schema_identifiers = property(schema_identifiers, schema_identifiers)
	%}
};

%include "../ifcparse/ifc_parse_api.h"
%include "../ifcparse/IfcSpfHeader.h"
%include "../ifcparse/IfcFile.h"
%include "../ifcparse/IfcBaseClass.h"

// The IfcFile* returned by open() is to be freed by SWIG/Python
%newobject open;
%newobject read;

%inline %{
	IfcParse::IfcFile* open(const std::string& fn) {
		IfcParse::IfcFile* f = new IfcParse::IfcFile();
		f->Init(fn);
		return f;
	}
    IfcParse::IfcFile* read(const std::string& data) {
		char* copiedData = new char[data.length()];
		memcpy(copiedData, data.c_str(), data.length());
		IfcParse::IfcFile* f = new IfcParse::IfcFile();
		f->Init((void *)copiedData, data.length());
		return f;
	}
	const char* schema_identifier() {
		return IfcSchema::Identifier;
	}

	const char* version() {
		return IFCOPENSHELL_VERSION;
	}

	std::string get_supertype(std::string n) {
		boost::to_upper(n);
		IfcSchema::Type::Enum t = IfcSchema::Type::FromString(n);
		if (IfcSchema::Type::Parent(t)) {
			return IfcSchema::Type::ToString(*IfcSchema::Type::Parent(t));
		} else {
			return "";
		}
	}

	IfcUtil::IfcBaseClass* new_IfcBaseClass(const std::string& s) {
		IfcSchema::Type::Enum ty = IfcSchema::Type::FromString(boost::to_upper_copy(s));
		IfcEntityInstanceData* data = new IfcEntityInstanceData(ty);
		data->setArgument(IfcSchema::Type::GetAttributeCount(ty) - 1, new IfcWrite::IfcWriteArgument());
		IfcSchema::Type::PopulateDerivedFields(data);
		return IfcSchema::SchemaEntity(data);
	}
%}

%{
	static std::stringstream ifcopenshell_log_stream;
%}
%init %{
	Logger::SetOutput(0, &ifcopenshell_log_stream);
%}
%inline %{
	std::string get_log() {
		std::string log = ifcopenshell_log_stream.str();
		ifcopenshell_log_stream.str("");
		return log;
	}
%}