#include <sstream>

#include <stdexcept>

namespace relpipe {

namespace in {

namespace ini {

namespace lib {

	/** 

	 * This might be configurable.

	 * 

	 * By default, we ignore all leading whitespace on continuing lines.

	 * If there should be some spaces or tabs, they should be placed on the previous line before the „\“.

	 * If a line break is desired, it should be written as \n (escaped) or the value should be quoted in " or '.

	 * 

	 * Related specifications:

	 *  - https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Properties.html

	 */

	bool consumeLeadingSpacesOnContinuingLines = true;

	/**

	 * This might be configurable.

	 * 

	 * KDE uses some weird INI dialect that allows [section][x] syntax where „x“ is kind of „tag“ that signalizes some properties of given section.

	 * Line „[section_1][$i]“ means that the „section_1“ is „locked“.

	 * We may emit this information somehow later, but for now, it is just ignored.

	 * 

	 * TODO: Is „section tag“ right name?

	 * 

	 * Related specifications:

	 *  - https://userbase.kde.org/KDE_System_Administration/Configuration_Files#Lock_Down

	 */

	bool allowSectionTags = true;

	/**

	 * This might be configurable.

	 * 

	 * If whole key is „aaa[bbb]“ then „aaa“ is considered to be the key and „bbb“ the sub-key.

	 * No \[ escaping is currently supported, so the key might not contain the bracket character.

	 * 

	 * Related specifications:

	 *  - https://userbase.kde.org/KDE_System_Administration/Configuration_Files#Shell_Expansion

	 *  - https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s05.html

	 */

	bool allowSubKeys = true;

	int lineNumber = 1;

	int eventNumber = 0;

	/**

	 * Should be always used instead of input.peek().

	 * Skips \r.

	 */

	char peek() {

		// In 2020 there is no need to manually return the carriage. However some legacy systems still do it.

		char ch = input.peek();

		if (ch == '\r') {

			input.get();

			ch = input.peek();

		}

		return ch;

	}

	/**

	 * Should be always used instead of input.get().

	 * Counts the lines and skips \r.

	 */

	char get() {

		char ch = input.get();

		if (ch == '\n') lineNumber++;

		else if (ch == '\r') ch = get();

		return ch;

	}

	std::string readSpacesAndTabs() {

		std::stringstream result;

		for (char ch = peek(); input.good() && (ch == ' ' || ch == '\t'); ch = peek()) result.put(get());

		return result.str();

	}

	std::string readAllWhitespace() {

		std::stringstream result;

		for (char ch = peek(); input.good() && (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'); ch = peek()) result.put(get());

		return result.str();

	}

	void processContinuingLine(std::stringstream& result) {

		if (consumeLeadingSpacesOnContinuingLines) readSpacesAndTabs();

		else result.put('\n');

	}

	std::string readUntil(char until, bool* found = nullptr) {

		std::stringstream result;

		for (char ch = peek(); input.good() && ch != until; ch = peek()) {

			if (ch == '\\') {

				get();

				ch = get();

				if (ch == until && ch == '\n') processContinuingLine(result);

				else if (ch == until) result.put(ch);

				else if (ch == std::istream::traits_type::eof()) break;

				else result.put('\\').put(ch);

				// TODO: two-stage and modular unescaping: here unescape only \+LF or more genereally: unescape only the until character and rest leave untouched

				// second escaping stage move to separate class/wrapper (similar to hierarchical wrappers)

			} else {

				ch = get();

				result.put(ch);

			}

		}

		if (peek() == until) {

			get();

			if (found) *found = true;

		} else {

			if (found) *found = false;

		}

		return result.str();

	}

	std::string readToken(char until, char* quote = nullptr, bool* found = nullptr) {

		std::string result;

		char ch = peek();

		if (isQuote(ch)) {

			if (quote) *quote = ch;

			result = readUntil(get(), found);

		} else {

			if (quote) *quote = 0;

			result = readUntil(until, found);

		}

		return result;

	}

	std::string readTokenAndEatTerminator(char until, char* quote = nullptr, bool* found = nullptr) {

		std::string result = readToken(until, quote, found);

		if (*quote) {

			readAllWhitespace();

			if (get() != until) throw std::logic_error(std::string("missing „") + std::string(1, until) + "“ after quoted section name");

		}

		return result;

	}

	bool isComment(char ch) {

		return ch == '#' || ch == ';';

	}

	bool isQuote(char ch) {

		return ch == '"' || ch == '\'';

	}

	std::string trim(std::string s) {

		return std::regex_replace(s, std::regex("^\\s+|\\s+$"), "");

	}

		bool inSection = false;

		while (input.good()) { // TODO: condition

			{

				std::string whitespace = readAllWhitespace();

				if (whitespace.size()) {

					INIContentHandler::WhitespaceEvent event;

					event.lineNumber = lineNumber;

					event.eventNumber = ++eventNumber;

					event.whitespace = whitespace;

					for (INIContentHandler* handler : handlers) handler->whitespace(event);

				}

			}

			bool found;

			char quote;

			char ch = peek();

			if (ch == std::istream::traits_type::eof()) {

				break;

			} else if (ch == '[') {

				if (inSection) for (INIContentHandler* handler : handlers) handler->endSection();

				inSection = true;

				get();

				readAllWhitespace();

				INIContentHandler::SectionStartEvent event;

				event.name = readTokenAndEatTerminator(']', &quote, &found);

				readSpacesAndTabs();

				if (allowSectionTags && peek() == '[') {

					get();

					event.tag = readTokenAndEatTerminator(']', &quote, &found);

				}

				readSpacesAndTabs();

				ch = peek();

				if (isComment(ch)) {

					get();

					readSpacesAndTabs();

					event.comment = readUntil('\n', &found);

				} else if (ch == '\n') {

					get();

				} else {

					throw std::logic_error(std::string("unexpected content after the section: '") + event.name + "'");

				}

				for (INIContentHandler* handler : handlers) handler->startSection(event);

			} else if (isComment(ch)) {

				get();

				readSpacesAndTabs();

				event.comment = readUntil('\n', &found);

			} else {

				std::string fullKey = readToken('=', &quote, &found);

				if (!found) throw std::logic_error(std::string("missing = after key: '") + fullKey + "'");

				if (!quote) fullKey = trim(fullKey);

				readSpacesAndTabs();

				if (quote) {

					ch = get();

					if (ch == '=') readSpacesAndTabs();

					else throw std::logic_error(std::string("missing = after quoted key: '") + fullKey + "'");

				}

				std::string value = readToken('\n', &quote, &found);

				if (!quote) value = trim(value);

				event.key = fullKey;

				event.fullKey = fullKey;

				event.value = value;

				if (allowSubKeys) {

					std::smatch match;

					if (std::regex_match(fullKey, match, std::regex("([^\\[]+)\\[([^\\[]+)\\]"))) {

						event.key = match[1];

						event.subKey = match[2];

						event.fullKey = fullKey;

					}

				}

				if (quote) {

					readSpacesAndTabs();

					ch = peek();

					if (isComment(ch)) {

						get();

						readSpacesAndTabs();

						event.comment = readUntil('\n', &found);

					} else if (ch == '\n') {

						get();

					} else {

						throw std::logic_error(std::string("unexpected content after the quoted value: key='") + fullKey + "' value='" + event.value + "'");

		// TODO: error at the end, catch premature/unexpected EOF

		// TODO: unescape + trim values + ignore \r

		// TODO: count lines

	// General feautres:

	// TODO: warning/error handler

	// TODO: support also escaped characters

	// TODO: support also Java .properties and manifest.mf formats?

	// TODO: support also nested sections – hierarchy

	// TODO: support also nested keys e.g. key.sub.subsub.subsubsub=value – translate them to nested sections

	// TODO: support also option for alternative key-value separator (: instead of =)

	// TODO: support also other encodings (currently only UTF-8 is supported)

	// TODO: better exceptions

	// Lossless conversions:

	// TODO: emit also the quote style ('/"/)

	// TODO: emit also the comment style (;/#) ?

	// TODO: emit also the whitespace before key name, around =, after "values"/'values', around [sections] ?

	// TODO: emit also the line-end type (LF/CRLF) ?

}

}

}

}