/**

 * Relational pipes

 * Copyright © 2019 František Kučera (Frantovo.cz, GlobalCode.info)

 *

 * 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, version 3 of the License.

 *

 * 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, see <http://www.gnu.org/licenses/>.

 */

#pragma once

#include <codecvt>

#include <vector>

#include <sstream>

#include <iomanip>

#include <libxml++-2.6/libxml++/libxml++.h>

#include <cbor.h>

#include <relpipe/writer/RelpipeWriterException.h>

#include "XMLNameCodec.h"

namespace relpipe {

namespace in {

namespace xmltable {

class XMLDocumentConstructor {

private:

	std::istream* input = nullptr;

	xmlpp::DomParser* parser = nullptr;

	XMLNameCodec nameCodec;

	std::string rootName = "cbor";

	xmlpp::Element* current;

	cbor_callbacks callbacks = cbor_empty_callbacks;

	/**

	 * Both CBOR and XML strings are in UTF-8.

	 */

	static std::string c2x(cbor_data value, uint64_t length) {

		return value && length > 0 ? std::string((const char*) value, length) : "";

	}

	const Glib::ustring c2xname(cbor_data value, uint64_t length) {

		return nameCodec.encode(c2x(value, length));

	}

	xmlpp::Element* parentOrSelf(xmlpp::Element* current) {

		return current->get_parent() == nullptr ? current : current->get_parent();

	}

public:

	XMLDocumentConstructor(std::istream* input, xmlpp::DomParser* parser) : input(input), parser(parser) {

#define CBOR_CALLBACK_START if (XMLDocumentConstructor* instance = static_cast<XMLDocumentConstructor*> (context)) {

#define CBOR_CALLBACK_END } else throw relpipe::writer::RelpipeWriterException(L"Invalid context in the CBOR callback.");

		callbacks.array_start = [](void* context, size_t size) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("array-start");

			CBOR_CALLBACK_END

		};

		callbacks.boolean = [](void* context, bool value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.byte_string = [](void* context, cbor_data value, uint64_t size) {

			CBOR_CALLBACK_START

			std::stringstream hex;

			hex << std::hex << std::setfill('0') << std::setw(2);

			for (uint64_t i = 0; i < size; i++) hex << (int) value[i];

			CBOR_CALLBACK_END

		};

		callbacks.byte_string_start = [](void* context) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("byte-string-start");

			CBOR_CALLBACK_END

		};

		callbacks.float2 = [](void* context, float value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.float4 = [](void* context, float value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.float8 = [](void* context, double value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.indef_array_start = [](void* context) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("array-start");

			CBOR_CALLBACK_END

		};

		callbacks.indef_map_start = [](void* context) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("map-start");

			CBOR_CALLBACK_END

		};

		callbacks.indef_break = [](void* context) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("indef-break");

			CBOR_CALLBACK_END

		};

		callbacks.map_start = [](void* context, size_t size) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("map-start");

			element->set_attribute("size", std::to_string(size));

			CBOR_CALLBACK_END

		};

		callbacks.negint8 = [](void* context, uint8_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.negint16 = [](void* context, uint16_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.negint32 = [](void* context, uint32_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.negint64 = [](void* context, uint64_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.null = [](void* context) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.string = [](void* context, cbor_data value, uint64_t size) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.string_start = [](void* context) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("string-start");

			CBOR_CALLBACK_END

		};

		callbacks.tag = [](void* context, uint64_t value) {

			CBOR_CALLBACK_START

			xmlpp::Element* element = instance->current->add_child("tag");

			element->add_child_text(std::to_string(value));

			CBOR_CALLBACK_END

		};

		callbacks.uint8 = [](void* context, uint8_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.uint16 = [](void* context, uint16_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.uint32 = [](void* context, uint32_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.uint64 = [](void* context, uint64_t value) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

		callbacks.undefined = [](void* context) {

			CBOR_CALLBACK_START

			CBOR_CALLBACK_END

		};

	}

	virtual ~XMLDocumentConstructor() {

	}

	void setOption(const std::string& uri, const std::string& value) {

		if (uri == "root-name") rootName = value;

		else throw std::invalid_argument(std::string("Invalid parser option: „") + uri + "“ with value: „" + value + "“");

	}

	void process() {

		current = parser->get_document()->create_root_node(rootName);

		std::stringstream bufferStream;

		for (char ch = input->get(); input->good(); ch = input->get()) bufferStream.put(ch);

		std::string buffer = bufferStream.str();

		size_t bytesRead = 0;

		size_t length = buffer.size();

		for (cbor_decoder_result result; bytesRead < length; bytesRead += result.read) {

			result = cbor_stream_decode((cbor_data) buffer.c_str() + bytesRead, length - bytesRead, &callbacks, this);

			if (result.status != cbor_decoder_status::CBOR_DECODER_FINISHED) throw relpipe::writer::RelpipeWriterException(L"CBOR parsing failed: status = " + std::to_wstring(result.status));

		}

		parser->get_document()->get_root_node()->set_attribute("bytes-read", std::to_string(bytesRead));

	}

};

}

}

}