#ifndef XMLELEMENT_HH

#define XMLELEMENT_HH

#include "MappedFile.hh"

#include "monotonic_allocator.hh"

#include "serialize_meta.hh"

#include "zstring_view.hh"

#include <cassert>

#include <concepts>

#include <cstddef>

#include <iterator>

//#include <memory_resource>

#include <string>

#include <string_view>

#include <vector>

namespace openmsx {

struct OldXMLElement; // for backwards compatible savestates

// The classes XMLDocument, XMLElement and XMLAttribute together form an

// in-memory representation of XML files (or at least the subset of the features

// needed for openMSX).

//

// This representation is optimized for fast parsing and to be compact in

// memory. This is achieved by:

// - Keeping a buffer to the actual xml file, and modifying that buffer.

//   For example the strings are modified in place (resolve escape sequences

//   and add zero-terminators) and the actual XML classes refer to this buffer.

// - The 'XMLElement' and 'XMLAttribute' objects are allocated from a monotonic

//   allocator.

// - Both the file buffer and the monotonic allocator are owned by the

//   XMLDocument class.

// Modifying the information (e.g. after it has been parsed from a file) is

// possible. But this is not the main intended use-case. For example it is

// possible to assign a new value-string to an attribute or an xml element. That

// string will be allocated from the monotonic allocator, but the memory for the

// old string will not be freed. So it's probably not a good idea to use these

// classes in a heavy-modification scenario.

// XMLAttribute is a name-value pair. This class only refers to the name and

// value strings, it does not own these strings. The owner could be either

// XMLDocument (in the file buffer or in the monotonic allocator) or it could

// be a string with static lifetime (e.g. a string-literal).

//

// XMLAttributes are organized in a (single-)linked list. So this class also

// contains a pointer to the next element in the list. The last element in the

// list contains a nullptr.

class XMLAttribute

{

public:

	XMLAttribute(const char* name_, const char* value_)

		: name(name_), value(value_) {}

	[[nodiscard]] std::string_view getName() const { return name; }

	[[nodiscard]] std::string_view getValue() const { return value; }

	void setValue(const char* value_) { value = value_; }

	XMLAttribute* setNextAttribute(XMLAttribute* attribute) {

		assert(!nextAttribute);

		nextAttribute = attribute;

		return attribute;

	}

private:

	const char* name;

	const char* value;

	XMLAttribute* nextAttribute = nullptr;

	friend class XMLElement;

	friend class XMLDocument;

	friend class XMLDocumentHandler;

};

// This XMLElement class represents a single XML-element (or XML-node). It has a

// name, attributes, a value (could be empty) and zero or more children. The

// value and the children are mutually exclusive, in other words: elements with

// children cannot have a non-empty value.

//

// String-ownership is the same as with XMLAttribute.

//

// Attributes are organized in a (single-)linked list. This class points to the

// first attribute (possibly nullptr when there are no attributes) and that

// attribute points to the next and so on.

//

// Hierarchy is achieved via two pointers. This class has a pointer to its first

// child and to its next sibling. Thus getting all children of a specific

// elements requires to first follow the 'firstChild' pointer, and from there on

// follow the 'nextSibling' pointers (and stop when any of these pointers in

// nullptr). XMLElement objects do not have a pointer to their parent.

class XMLElement

{

	// iterator classes for children and attributes

	template<typename Elem> // 'XMLElement' or 'const XMLElement'

	struct ChildIterator {

		using difference_type = ptrdiff_t;

		using value_type = Elem;

		using pointer = value_type*;

		using reference = value_type&;

		using iterator_category = std::forward_iterator_tag;

		Elem* elem;

		Elem& operator*() const { return *elem; }

		ChildIterator& operator++() { elem = elem->nextSibling; return *this; }

		ChildIterator operator++(int) { auto result = *this; elem = elem->nextSibling; return result; }

		[[nodiscard]] bool operator==(const ChildIterator& i) const = default;

		[[nodiscard]] bool operator==(std::default_sentinel_t) const { return elem == nullptr; }

	};

	static_assert(std::forward_iterator<ChildIterator<XMLElement>>);

	static_assert(std::sentinel_for<std::default_sentinel_t, ChildIterator<XMLElement>>);

	template<typename Elem> // 'XMLElement' or 'const XMLElement'

	struct ChildRange {

		Elem* elem;

		[[nodiscard]] ChildIterator<Elem> begin() const { return {elem->firstChild}; }

		[[nodiscard]] std::default_sentinel_t end() const { return {}; }

	};

	static_assert(std::ranges::range<ChildRange<XMLElement>>);

	template<typename Elem> // 'XMLElement' or 'const XMLElement'

	struct NamedChildIterator {

		using difference_type = ptrdiff_t;

		using value_type = Elem*;

		using pointer = value_type*;

		using reference = value_type&;

		using iterator_category = std::forward_iterator_tag;

		Elem* elem;

		std::string_view name;

		NamedChildIterator() : elem(nullptr) {}

		NamedChildIterator(Elem* elem_, std::string_view name_)

			: elem(elem_), name(name_)

		{

			while (elem && elem->getName() != name) {

				elem = elem->nextSibling;

			}

		}

		Elem* operator*() const { return elem; }

		NamedChildIterator& operator++() {

			do {

				elem = elem->nextSibling;

			} while (elem && elem->getName() != name);

			return *this;

		}

		NamedChildIterator operator++(int) { auto result = *this; ++(*this); return result; }

		[[nodiscard]] bool operator==(const NamedChildIterator& i) const { return elem == i.elem; }

		[[nodiscard]] bool operator==(std::default_sentinel_t) const { return elem == nullptr; }

	};

	static_assert(std::forward_iterator<NamedChildIterator<XMLElement>>);

	static_assert(std::sentinel_for<std::default_sentinel_t, NamedChildIterator<XMLElement>>);

	template<typename Elem> // 'XMLElement' or 'const XMLElement'

	struct NamedChildRange {

		Elem* elem;

		std::string_view name;

		[[nodiscard]] NamedChildIterator<Elem> begin() const { return {elem->firstChild, name}; }

		[[nodiscard]] std::default_sentinel_t end() const { return {}; }

	};

	static_assert(std::ranges::range<NamedChildRange<XMLElement>>);

	struct AttributeIterator {

		using difference_type = ptrdiff_t;

		using value_type = const XMLAttribute;

		using pointer = value_type*;

		using reference = value_type&;

		using iterator_category = std::forward_iterator_tag;

		const XMLAttribute* attr;

		const XMLAttribute& operator*() const { return *attr; }

		AttributeIterator& operator++() { attr = attr->nextAttribute; return *this; }

		AttributeIterator operator++(int) { auto result = *this; attr = attr->nextAttribute; return result; }

		[[nodiscard]] bool operator==(const AttributeIterator& i) const = default;

		[[nodiscard]] bool operator==(std::default_sentinel_t) const { return attr == nullptr; }

	};

	static_assert(std::forward_iterator<AttributeIterator>);

	static_assert(std::sentinel_for<std::default_sentinel_t, AttributeIterator>);

	struct AttributeRange {

		const XMLElement* elem;

		[[nodiscard]] AttributeIterator begin() const { return {elem->firstAttribute}; }

		[[nodiscard]] std::default_sentinel_t end() const { return {}; }

	};

	static_assert(std::ranges::range<AttributeRange>);

public:

	explicit XMLElement(const char* name_) : name(name_) {}

	XMLElement(const char* name_, const char* data_) : name(name_), data(data_) {}

	[[nodiscard]] zstring_view getName() const { return name; }

	void clearName() { name = ""; } // hack to 'remove' child from findChild()

	[[nodiscard]] zstring_view getData() const {

		return data ? zstring_view(data) : zstring_view{};

	}

	XMLElement* setData(const char* data_) {

		data = data_;

		return this;

	}

	[[nodiscard]] bool hasChildren() const { return firstChild; }

	[[nodiscard]] const XMLElement* getFirstChild() const { return firstChild; }

	[[nodiscard]] XMLElement* getFirstChild() { return firstChild; }

	[[nodiscard]] const XMLElement* findChild(std::string_view childName) const;

	[[nodiscard]] const XMLElement* findChildWithAttribute(std::string_view childName, std::string_view attrName, std::string_view attrValue) const;

	[[nodiscard]] XMLElement* findChild(std::string_view childName);

	[[nodiscard]] XMLElement* findChild(std::string_view childName, XMLElement*& hint);

	[[nodiscard]] const XMLElement& getChild(std::string_view childName) const;

	[[nodiscard]] XMLElement& getChild(std::string_view childName);

	[[nodiscard]] std::string_view getChildData(std::string_view childName) const;

	[[nodiscard]] std::string_view getChildData(std::string_view childName,

	                                            std::string_view defaultValue) const;

	[[nodiscard]] bool getChildDataAsBool(std::string_view childName, bool defaultValue) const;

	[[nodiscard]] int getChildDataAsInt(std::string_view childName, int defaultValue) const;

	[[nodiscard]] size_t numChildren() const;

	[[nodiscard]] ChildRange<const XMLElement> getChildren() const { return {this}; }

	[[nodiscard]] ChildRange<      XMLElement> getChildren()       { return {this}; }

	[[nodiscard]] NamedChildRange<const XMLElement> getChildren(std::string_view childName) const {

		return {.elem = this, .name = childName};

	}

	[[nodiscard]] NamedChildRange<      XMLElement> getChildren(std::string_view childName) {

		return {.elem = this, .name = childName};

	}

	[[nodiscard]] const XMLAttribute* findAttribute(std::string_view attrName) const;

	[[nodiscard]] XMLAttribute* findAttribute(std::string_view attrName);

	[[nodiscard]] const XMLAttribute& getAttribute(std::string_view attrName) const;

	[[nodiscard]] XMLAttribute& getAttribute(std::string_view attrName);

	[[nodiscard]] std::string_view getAttributeValue(std::string_view attrName) const;

	[[nodiscard]] std::string_view getAttributeValue(std::string_view attrName,

	                                                 std::string_view defaultValue) const;

	[[nodiscard]] bool getAttributeValueAsBool(std::string_view attrName,

	                                           bool defaultValue) const;

	[[nodiscard]] int getAttributeValueAsInt(std::string_view attrName,

	                                         int defaultValue) const;

	[[nodiscard]] XMLAttribute** findAttributePointer(std::string_view attrName);

	static void removeAttribute(XMLAttribute** attrPtr);

	[[nodiscard]] size_t numAttributes() const;

	[[nodiscard]] AttributeRange getAttributes() const { return {this}; }

	XMLElement* setFirstChild(XMLElement* child) {

		assert(!firstChild);

		firstChild = child;

		return child;

	}

	XMLElement* setNextSibling(XMLElement* sibling) {

		assert(!nextSibling);

		nextSibling = sibling;

		return sibling;

	}

	XMLAttribute* setFirstAttribute(XMLAttribute* attribute) {

		assert(!firstAttribute);

		firstAttribute = attribute;

		return attribute;

	}

private:

	const char* name;

	const char* data = nullptr;

	XMLElement* firstChild = nullptr;

	XMLElement* nextSibling = nullptr;

	XMLAttribute* firstAttribute = nullptr;

	friend class XMLDocument;

	friend class XMLDocumentHandler;

};

// This class mainly exists to manage ownership over the objects involved in a

// full XML document. These are the XMLElement and XMLAttribute objects but also

// the name/value/attribute strings. This class also has a pointer to the root

// element.

//

// Because of the way how ownership is handled, most modifying operations are

// part of this class API. For example there's a method 'setChildData()' which

// searches for a child with a specific name, if not found such a child is

// created, then the child-data is set to a new value. Because this operation

// possibly requires to allocate a new XMLElement (and the allocator is part of

// this class) this method is part of this class rather than the XMLElement

// class.

class XMLDocument

{

public:

	// singleton-like document, mainly used as owner for static XML snippets

	// (so with lifetime the whole openMSX session)

	static XMLDocument& getStaticDocument() {

		static XMLDocument doc;

		return doc;

	}

	XMLDocument(const XMLDocument&) = delete;

	XMLDocument(XMLDocument&&) = delete;

	XMLDocument& operator=(const XMLDocument&) = delete;

	XMLDocument& operator=(XMLDocument&&) = delete;

	// Create an empty XMLDocument (root == nullptr).

	XMLDocument() = default;

	// Create an empty XMLDocument (root == nullptr).  All constructor

	// arguments are delegated to the monotonic allocator constructor.

	template<typename T, typename ...Args>

		requires(!std::same_as<XMLDocument, std::remove_cvref_t<T>>) // don't block copy-constructor

	explicit XMLDocument(T&& t, Args&& ...args)

		: allocator(std::forward<T>(t), std::forward<Args>(args)...) {}

	// Load/parse an xml file. Requires that the document is still empty.

	void load(zstring_view filename, std::string_view systemID);

	[[nodiscard]] const XMLElement* getRoot() const { return root; }

	[[nodiscard]] XMLElement* getRoot() { return root; }

	void setRoot(XMLElement* root_) { assert(!root); root = root_; }

	[[nodiscard]] XMLElement* allocateElement(const char* name);

	[[nodiscard]] XMLElement* allocateElement(const char* name, const char* data);

	[[nodiscard]] XMLAttribute* allocateAttribute(const char* name, const char* value);

	[[nodiscard]] const char* allocateString(std::string_view str);

	[[nodiscard]] XMLElement* getOrCreateChild(XMLElement& parent, const char* childName, const char* childData);

	XMLElement* setChildData(XMLElement& parent, const char* childName, const char* childData);

	void setAttribute(XMLElement& elem, const char* attrName, const char* attrValue);

	template<typename Range, typename UnaryOp>

	void generateList(XMLElement& parent, const char* itemName, Range&& range, UnaryOp op) {

		XMLElement** next = &parent.firstChild;

		assert(!*next);

		for (auto& r : range) {

			auto* elem = allocateElement(itemName);

			op(elem, r);

			*next = elem;

			next = &elem->nextSibling;

		}

	}

	void load(const OldXMLElement& elem); // bw compat

	void serialize(MemInputArchive&  ar, unsigned version);

	void serialize(MemOutputArchive& ar, unsigned version) const;

	void serialize(XmlInputArchive&  ar, unsigned version);

	void serialize(XmlOutputArchive& ar, unsigned version) const;

private:

	XMLElement* loadElement(MemInputArchive& ar);

	XMLElement* clone(const XMLElement& inElem);

	XMLElement* clone(const OldXMLElement& elem);

private:

	XMLElement* root = nullptr;

	MappedFile<char> buf;

	// part of c++17, but not yet implemented in libc++

	//    std::pmr::monotonic_buffer_resource allocator;

	monotonic_allocator allocator;

	friend class XMLDocumentHandler;

};

// For backwards-compatibility with old savestates

//   needed with HardwareConfig-version <= 5.

class FileContext;

struct OldXMLElement

{

	template<typename Archive>

	void serialize(Archive& ar, unsigned version);

	// For backwards compatibility with version=1 savestates

	static std::unique_ptr<FileContext> getLastSerializedFileContext();

	std::string name;

	std::string data;

	std::vector<OldXMLElement> children;

	std::vector<std::pair<std::string, std::string>> attributes;

};

SERIALIZE_CLASS_VERSION(OldXMLElement, 2);

} // namespace openmsx

#endif