/* libobby - Network text editing library
 * Copyright (C) 2005 0x539 dev group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program 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 GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <fstream>
#include "common.hpp"
#include "format_string.hpp"
#include "serialise/error.hpp"
#include "serialise/parser.hpp"

obby::serialise::parser::parser()
{
}

void obby::serialise::parser::deserialise(const std::string& file)
{
	std::ifstream in(file.c_str() );

	if(!in)
	{
		obby::format_string str(_(
			"Could not open file '%0%' for reading"
		) );

		str << file;
		throw error(str.str(), 0);
	}

	deserialise(in);
}

void obby::serialise::parser::deserialise(std::istream& stream)
{
	const unsigned int bufsize = 1024;
	char readbuf[bufsize];
	std::string result;

	// Initial preallocation
	result.reserve(bufsize << 3);

#ifdef WIN32
	// Other effort (see below) seems not to work on WIN32, the eofflag is
	// set after the first 1024 Bytes have been read. Is this a bug in
	// mingw?
	std::string line;
	while(std::getline(stream, line) )
	{
		// More preallocation, if the following line exceeds the
		// current capacity
		if(result.capacity() < result.length() + bufsize)
			result.reserve(result.capacity() * 2);

		result += line;
		result += '\n';
	}
#else
	while(stream)
	{
		// More preallocation, if the following 1024 byte exceeds the
		// current capacity
		if(result.capacity() < result.length() + bufsize)
			result.reserve(result.capacity() * 2);

		// Read data, append to resulting string
		stream.read(readbuf, bufsize);
		result.append(readbuf, stream.gcount() );
	}
#endif

	deserialise_memory(result);
}

void obby::serialise::parser::deserialise_memory(const std::string& mem)
{
	token_list list;
	list.deserialise(mem);
	token_list::iterator iter = list.begin();

	// Get initial '!'
	if(iter->get_type() != token::TYPE_EXCLAMATION)
	{
		throw error(
			_("Expected initial exclamation mark"),
			iter->get_line()
		);
	}
	list.next_token(iter);

	// Read document type
	if(iter->get_type() != token::TYPE_IDENTIFIER)
	{
		throw error(
			_("Expected document type after '!'"),
			iter->get_line()
		);
	}
	m_type = iter->get_text();
	list.next_token(iter);

	// Get indentation for following object
	if(iter->get_type() != token::TYPE_INDENTATION)
	{
		throw error(
			_("Expected newline after document type"),
			iter->get_line()
		);
	}

	// Must be top-level (indentation == 0)
	if(iter->get_text().length() > 0)
	{
		throw error(
			_("Expected top-level object after document type"),
			iter->get_line()
		);
	}
	list.next_token(iter);

	// Root object should follow
	if(iter->get_type() != token::TYPE_IDENTIFIER)
	{
		throw error(
			_("Expected root object after document type"),
			iter->get_line()
		);
	}

	m_object.deserialise(list, iter);

	// Must be EOF now
	if(iter != list.end() )
	{
		format_string str(_("Expected end of input instead of '%0%'") );
		str << iter->get_text();
		throw error(str.str(), iter->get_line() );
	}
}

void obby::serialise::parser::serialise(const std::string& file) const
{
	std::ofstream out(file.c_str() );
	if(!out)
	{
		obby::format_string str(
			_("Could not open file '%0%' for writing")
		);

		str << file;
		throw std::runtime_error(str.str() );
	}

	serialise(out);
}

void obby::serialise::parser::serialise(std::ostream& stream) const
{
	// Get string
	std::string result;
	serialise_memory(result);

	// Write it into the file
	stream << result;
	stream.flush();
}

void obby::serialise::parser::serialise_memory(std::string& mem) const
{
	// Empty list
	token_list list;

	// Add document type
	list.add(token::TYPE_EXCLAMATION, "!", 0);
	list.add(token::TYPE_IDENTIFIER, m_type, 0);

	// Add top-level indentation
	list.add(token::TYPE_INDENTATION, "", 0);

	// Serialise root object with its children
	m_object.serialise(list);
	list.serialise(mem);
}

const std::string& obby::serialise::parser::get_type() const
{
	return m_type;
}

void obby::serialise::parser::set_type(const std::string& type)
{
	m_type = type;
}

const obby::serialise::object& obby::serialise::parser::get_root() const
{
	return m_object;
}

obby::serialise::object& obby::serialise::parser::get_root()
{
	return m_object;
}