/********************************************************************************
 *                                                                              *
 * 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/>.         *
 *                                                                              *
 ********************************************************************************/
 
#ifndef IFCSPFHEADER_H
#define IFCSPFHEADER_H

#include "../ifcparse/IfcSpfStream.h"
#include "../ifcparse/IfcWrite.h"

namespace IfcParse {

class HeaderEntity : public IfcAbstractEntity {
private:	
	ArgumentList* _list;
	const char * const _datatype;

	HeaderEntity(const HeaderEntity&); //N/A
	HeaderEntity& operator =(const HeaderEntity&); //N/A
protected:
	HeaderEntity(const char * const datatype, IfcSpfLexer* lexer) 
		: _datatype(datatype), _list(0)
	{
		std::vector<unsigned int> ids;
		_list = new ArgumentList();
		if (lexer) {
			_list->read(lexer, ids);
		}
	}

	~HeaderEntity() {
		delete _list;
	}

	void setArgument(unsigned int i, const std::string& s) {
		IfcWrite::IfcWriteArgument* argument = new IfcWrite::IfcWriteArgument(this);
		argument->set(s);
		_list->set(i, argument);
	}

	void setArgument(unsigned int i, const std::vector<std::string>& s) {
		IfcWrite::IfcWriteArgument* argument = new IfcWrite::IfcWriteArgument(this);
		argument->set(s);
		_list->set(i, argument);
	}

public:
	Argument* getArgument(unsigned int i) const {
		return (*_list)[i];
	}

	Argument* getArgument(unsigned int i) {
		return (*_list)[i];
	}

	IfcEntityList::ptr getInverse(IfcSchema::Type::Enum /*type*/, int /*attribute_index*/) {
		return IfcEntityList::ptr(new IfcEntityList);
	}

	std::string datatype() const {
		return _datatype;
	}
	
	unsigned int getArgumentCount() const {
		return _list->size();
	}

	IfcSchema::Type::Enum type() const {
		return (IfcSchema::Type::Enum) -1;
	}

	bool is(IfcSchema::Type::Enum /*v*/) const {
		return false;
	}

	std::string toString(bool upper=false) const {
		std::stringstream ss;
		ss << _datatype << _list->toString(upper) << ";";
		return ss.str();
	}
	
	unsigned int id() {
		return 0;
	}

	IfcWrite::IfcWritableEntity* isWritable() {
		return 0;
	}
};

class FileDescription : public HeaderEntity {
public:
	explicit FileDescription(IfcSpfLexer* = 0);

	std::vector<std::string> description() const { return *getArgument(0); }
	std::string implementation_level() const { return *getArgument(1); }

	void description(const std::vector<std::string>& value) { setArgument(0, value); }
	void implementation_level(const std::string& value) { setArgument(1, value); }
};

class FileName : public HeaderEntity  {
public:
	explicit FileName(IfcSpfLexer* = 0);

	std::string name() const { return *getArgument(0); }
	std::string time_stamp() const { return *getArgument(1); }
	std::vector<std::string> author() const { return *getArgument(2); }
	std::vector<std::string> organization() const { return *getArgument(3); }
	std::string preprocessor_version() const { return *getArgument(4); }
	std::string originating_system() const { return *getArgument(5); }
	std::string authorization() const { return *getArgument(6); }

	void name(const std::string& value) { setArgument(0, value); }
	void time_stamp(const std::string& value) { setArgument(1, value); }
	void author(const std::vector<std::string>& value) { setArgument(2, value); }
	void organization(const std::vector<std::string>& value) { setArgument(3, value); }
	void preprocessor_version(const std::string& value) { setArgument(4, value); }
	void originating_system(const std::string& value) { setArgument(5, value); }
	void authorization(const std::string& value) { setArgument(6, value); }
};

class FileSchema : public HeaderEntity  {
public:
	explicit FileSchema(IfcSpfLexer* = 0);

	std::vector<std::string> schema_identifiers() const { return *getArgument(0); }

	void schema_identifiers(const std::vector<std::string>& value) { setArgument(0, value); }
};

class IfcSpfHeader {
private:
	IfcSpfLexer* _lexer;
	FileDescription* _file_description;
	FileName* _file_name;
	FileSchema* _file_schema;
	void readParen();
	void readSemicolon();
	enum Trail {
		TRAILING_SEMICOLON,
		TRAILING_PAREN,
		NONE
	};
	void readTerminal(const std::string& term, Trail trail);
public:
	explicit IfcSpfHeader(IfcSpfLexer* lexer = 0)
		: _lexer(lexer), _file_description(0), _file_name(0), _file_schema(0) 
	{
		_file_description = new FileDescription();
		_file_name = new FileName();
		_file_schema = new FileSchema();
	}
	
	IfcSpfLexer* lexer() { return _lexer; }
	void lexer(IfcSpfLexer* l) { _lexer = l; }

	void read();	
	bool tryRead();
	
	void write(std::ostream& os) const;

	const FileDescription& file_description() const;
	const FileName& file_name() const;
	const FileSchema& file_schema() const;

	FileDescription& file_description();
	FileName& file_name();
	FileSchema& file_schema();
};

}

#endif