/**

 * Relational pipes

 * Copyright © 2018 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

 *

 * 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 <iostream>

#include <sstream>

#include <string>

#include <vector>

#include <codecvt>

#include <locale>

#include <relpipe/reader/typedefs.h>

#include <relpipe/cli/RelpipeCLIException.h>

using namespace std;

namespace relpipe {

namespace out {

namespace asn1 {

using namespace relpipe::reader;

/**

 * A simple library for writing ASN.1 BER encoded files.

 */

class ASN1Writer {

private:

	ostream& output;

	wstring_convert<codecvt_utf8<wchar_t>> convertor; // only UTF8String is supported

	int sequenceLevel = 0;

	enum TagClass : uint8_t {

		/** The type is native to ASN.1 */

		Universal = 0,

		/** The type is only valid for one specific application */

		Application = 1,

		/** Meaning of this type depends on the context (such as within a sequence, set or choice) */

		ContextSpecific = 2,

		/** Defined in private specifications */

		Private = 3,

	};

	enum PC : uint8_t {

		/** The contents octets directly encode the element value. */

		Primitive = 0,

		/** The contents octets contain 0, 1, or more element encodings.  */

		Constructed = 1,

	};

	enum UniversalType : uint16_t {

		EndOfContent = 0,

		Boolean = 1,

		Integer = 2,

		OctetString = 4,

		Null = 5,

		ObjectIdentifier = 6,

		Real = 9,

		UTF8String = 12,

		RelativeObjectIdentifier = 13,

		Sequence = 16,

	};

	void writeIdentifier(TagClass tagClass, PC pc, uint16_t tagNumber) {

		if (tagNumber > 30) throw cli::RelpipeCLIException(L"Tag numbers higher than 30 are currently unsupported.", cli::CLI::EXIT_CODE_UNEXPECTED_ERROR); // should not happen, error in the program // TODO: support tag numbers > 30

		uint8_t tag = 0;

		tag |= tagClass << 6;

		tag |= pc << 5;

		tag |= tagNumber;

		output.put(tag);

	}

	/**

	 * @param der

	 * @param length

	 */

	template<typename N, typename = typename std::enable_if<std::is_unsigned<N>::value, N>::type>

	void writeLength(N length) {

		if (length < 128) {

			output.put(length);

		} else {

			for (int i = sizeof (N) - 1; i >= 0; i--) {

				uint8_t b = length >> (i * 8);

				if (b || i == 0) {

					output.put((i + 1) | 0x80);

					for (; i >= 0; i--) {

						b = length >> (i * 8);

						output.put(b);

					}

					break;

				}

			}

		}

	}

	void writeLengthIndefinite() {

		output.put('\x80');

	}

	static bool isLittleEndian() {

		int test = 1;

		return (*(char *) &test);

	}

	static bool isBigEndian() {

		return !isLittleEndian();

	}

public:

	ASN1Writer(std::ostream& output) : output(output) {

	}

	virtual ~ASN1Writer() {

		output.flush();

	}

	/**

	 * Just check whether all sequences are closed. If not, throws RelpipeCLIException.

	 */

	void end() {

		if (sequenceLevel) throw cli::RelpipeCLIException(L"Unable to close ASN1Writer because there are not ended sequences.", cli::CLI::EXIT_CODE_UNEXPECTED_ERROR); // should not happen, error in the program

	}

	void writeStartSequence() {

		sequenceLevel++;

		writeIdentifier(TagClass::Universal, PC::Constructed, UniversalType::Sequence);

		writeLengthIndefinite();

	}

	void writeEndSequence() {

		if (sequenceLevel == 0) throw cli::RelpipeCLIException(L"Unable to writeEndSequence() if not sequence is currently started.", cli::CLI::EXIT_CODE_UNEXPECTED_ERROR); // should not happen, error in the program

		sequenceLevel--;

		writeIdentifier(TagClass::Universal, PC::Primitive, UniversalType::EndOfContent);

		writeLength(0u);

	}

	void writeBoolean(const boolean_t& value) {

		writeIdentifier(TagClass::Universal, PC::Primitive, UniversalType::Boolean);

		writeLength(1u);

		output.put(value ? '\xFF' : '\x00');

	}

	void writeInteger(const integer_t& value) {

		uint8_t* end = (uint8_t*) & value;

		uint8_t* start = end + sizeof (value) - 1;

		uint8_t* current;

		int direction = -1;

		if (isBigEndian()) {

			std::swap(end, start);

			direction = -direction;

		}

		// move current pointer to the first valuable octet

		for (current = start; current != end; current += direction) {

			switch (*current) {

				case 0x00: if ((*(current + direction) & 0x80) == 0) continue;

					break;

				case 0xFF: if ((*(current + direction) & 0x80) != 0) continue;

					break;

			}

			break;

		}

		std::vector<char> v;

		writeIdentifier(TagClass::Universal, PC::Primitive, UniversalType::Integer);

		writeLength((size_t) (end > current ? end - current : current - end) + 1);

		for (end += direction; current != end; current += direction) output.put(*current);

	}

	void writeString(const string_t& value) {

		// TODO: empty string → null?

		std::string bytes = convertor.to_bytes(value);

		writeIdentifier(TagClass::Universal, PC::Primitive, UniversalType::UTF8String);

		writeLength(bytes.length());

		output << bytes;

	}

};

}

}

}