#ifndef XMLOUTPUTSTREAM_HH

#define XMLOUTPUTSTREAM_HH

#include "XMLEscape.hh"

#include "ranges.hh"

#include <algorithm>

#include <array>

#include <concepts>

#include <cstdint>

#include <string>

#include <string_view>

#include <vector>

/**

 * 'XMLOutputStream' is a helper to write an XML file in a streaming way.

 *

 * That is: all information must be provided in the exact same order as it

 * appears in the output. So attributes for a tag must be provided before the

 * data for that tag. It's not possible to go back to an earlier tag and

 * add/change/remove attributes or data, nor is it possible to add/remove

 * subtags to already streamed tags.

 *

 * In other words: this helper class immediately write the provided data to the

 * output stream, and it cannot make changes to already outputted data. So

 * basically the only thing this class does is take care of the syntax details

 * and formatting of the XML file. The main advantage of this class is that it's

 * very cheap: it does not need to keep (much) state in memory (e.g. it does not

 * build the whole XML tree in memory and then dump it all at the end).

 *

 * One limitation of this helper is that it does not support mixed-content tags.

 * A tag either contains data or it contains subtags, but not both (neither data

 * nor subtags is fine).

 *

 * ---

 *

 * After instantiation of the 'XMLOutputStream', you must call the

 *     begin(), attribute(), data(), end()

 * methods. These directly correspond to elements in the XML file, so the

 * meaning should be clear. There are also constraints on the order in which

 * these methods are allowed to be called:

 * - begin() and end() calls should be properly paired. That is for each begin()

 *   there must be a corresponding end() and the 'tag' parameter for both must

 *   match. One pair must be either fully nested inside another pair or it must

 *   be fully outside that other pair.

 * - attribute() must be called directly after begin() or after another

 *   attribute() call, but not after data() or end()

 * - data() can only be called once per tag, it must be called after begin()

 *   or after attribute(), but not after data() or end().

 * - A call to data() must be followed by a call to end(). Not another data()

 *   call nor attribute() nor begin().

 *

 * ---

 *

 * 'XMLOutputStream' is templatized on an 'Operations' type. This must be a class

 * that implements the following 3 methods:

 *     struct MyOperations {

 *         void write(const char* buf, size_t len);

 *         void write1(char c);

 *         void check(bool condition) const;

 *     };

 *

 * The write() and write1() methods write data (e.g. to a file). Either a whole

 * buffer or a single character. In some implementations it's more efficient to

 * write a single char than to write a buffer of length 1, but in your

   implementation feel free to implement write1() as:

 *     write1(char c) { write(&c, 1); }

 *

 * The check() method should be implemented as:

 *     assert(condition);

 * Though in the unittests we instead make this throw an exception so that we

 * can test the error cases.

 */

template<typename Operations>

class XMLOutputStream

{

public:

	explicit XMLOutputStream(Operations& ops_)

		: ops(ops_) {}

	void begin(std::string_view tag);

	void attribute(std::string_view name, std::string_view value);

	void data(std::string_view value);

	void dataRaw(std::string_view value); // if you're sure 'value' doesn't need to be escaped

	void end(std::string_view tag);

	void with_tag(std::string_view tag, std::invocable auto next);

private:

	void writeSpaces(unsigned n);

	void writeChar(char c);

	void writeString(std::string_view s);

	void writeEscapedString(std::string_view s);

private:

	Operations& ops;

	unsigned level = 0;

	enum State : uint8_t {

		INDENT, // the next (begin or end) tag needs to be indented

		CLOSE,  // the begin tag still needs to be closed

		DATA,   // we got data, but no end-tag yet

	};

	State state = INDENT;

#ifdef DEBUG

	std::vector<std::string> stack;

#endif

};

template<typename Writer>

void XMLOutputStream<Writer>::begin(std::string_view tag)

{

#ifdef DEBUG

	stack.emplace_back(tag);

#endif

	ops.check(state != DATA);

	if (state == CLOSE) {

		writeString(">\n");

	}

	writeSpaces(2 * level);

	writeChar('<');

	writeString(tag);

	++level;

	state = CLOSE;

}

template<typename Writer>

void XMLOutputStream<Writer>::attribute(std::string_view name, std::string_view value)

{

	ops.check(level > 0);

	ops.check(state == CLOSE);

	writeChar(' ');

	writeString(name);

	writeString("=\"");

	writeEscapedString(value);

	writeChar('"');

}

template<typename Writer>

void XMLOutputStream<Writer>::data(std::string_view value)

{

	ops.check(level > 0);

	ops.check(state == CLOSE);

	if (value.empty()) return;

	writeChar('>');

	writeEscapedString(value);

	state = DATA;

}

template<typename Writer>

void XMLOutputStream<Writer>::dataRaw(std::string_view value)

{

	ops.check(level > 0);

	ops.check(state == CLOSE);

	if (value.empty()) return;

	writeChar('>');

	writeString(value); // no escaping here

	state = DATA;

}

template<typename Writer>

void XMLOutputStream<Writer>::end(std::string_view tag)

{

#ifdef DEBUG

	ops.check(stack.size() == level);

	ops.check(!stack.empty());

	ops.check(stack.back() == tag);

	stack.pop_back();

#endif

	ops.check(level > 0);

	--level;

	if (state == CLOSE) {

		writeString("/>\n");

	} else {

		if (state == INDENT) {

			writeSpaces(2 * level);

		}

		writeString("</");

		writeString(tag);

		writeString(">\n");

	}

	state = INDENT;

}

template<typename Writer>

void XMLOutputStream<Writer>::with_tag(std::string_view tag, std::invocable auto next)

{

	begin(tag);

	next();

	end(tag);

}

template<typename Writer>

void XMLOutputStream<Writer>::writeSpaces(unsigned n)

{

	static constexpr std::array<char, 64> spaces = {

		' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',

		' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',

		' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',

		' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',

	};

	while (n) {

		auto t = std::min(64u, n);

		ops.write(subspan(spaces, 0, t));

		n -= t;

	}

}

template<typename Writer>

void XMLOutputStream<Writer>::writeChar(char c)

{

	ops.write1(c);

}

template<typename Writer>

void XMLOutputStream<Writer>::writeString(std::string_view s)

{

	ops.write(s);

}

template<typename Writer>

void XMLOutputStream<Writer>::writeEscapedString(std::string_view s)

{

	XMLEscape(s, [&](std::string_view chunk) { writeString(chunk); });

}

#endif