/*
* Copyright 2016 Huy Cuong Nguyen
* Copyright 2016 ZXing authors
*/
// SPDX-License-Identifier: Apache-2.0

#include "DMHighLevelEncoder.h"

#include "ByteArray.h"
#include "CharacterSet.h"
#include "DMEncoderContext.h"
#include "TextEncoder.h"
#include "ZXAlgorithms.h"

#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <limits>
#include <stdexcept>
#include <string>

namespace ZXing::DataMatrix {

static const uint8_t PAD = 129;
static const uint8_t UPPER_SHIFT = 235;
static const uint8_t MACRO_05 = 236;
static const uint8_t MACRO_06 = 237;
static const uint8_t C40_UNLATCH = 254;
static const uint8_t X12_UNLATCH = 254;

enum
{
	ASCII_ENCODATION,
	C40_ENCODATION,
	TEXT_ENCODATION,
	X12_ENCODATION,
	EDIFACT_ENCODATION,
	BASE256_ENCODATION,
};

static const uint8_t LATCHES[] = {
	0,	// ASCII mode, no latch needed
	230, // LATCH_TO_C40
	239, // LATCH_TO_TEXT
	238, // LATCH_TO_ANSIX12
	240, // LATCH_TO_EDIFACT
	231, // LATCH_TO_BASE256,
};

static bool IsDigit(int ch)
{
	return ch >= '0' && ch <= '9';
}

static bool IsExtendedASCII(int ch)
{
	return ch >= 128 && ch <= 255;
}

static bool IsNativeC40(int ch)
{
	return (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z');
}

static bool IsNativeText(int ch)
{
	return (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z');
}

static bool IsX12TermSep(int ch)
{
	return (ch == '\r') //CR
		|| (ch == '*')
		|| (ch == '>');
}

static bool IsNativeX12(int ch)
{
	return IsX12TermSep(ch) || (ch == ' ') || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z');
}

static bool IsNativeEDIFACT(int ch)
{
	return ch >= ' ' && ch <= '^';
}

static bool IsSpecialB256(int /*ch*/)
{
	return false; //TODO NOT IMPLEMENTED YET!!!
}


/*
* Converts the message to a byte array using the default encoding (cp437) as defined by the
* specification
*
* @param msg the message
* @return the byte array of the message
*/

/*
public static byte[] getBytesForMessage(String msg) {
return msg.getBytes(Charset.forName("cp437")); //See 4.4.3 and annex B of ISO/IEC 15438:2001(E)
}
*/

static uint8_t Randomize253State(uint8_t ch, int codewordPosition)
{
	int pseudoRandom = ((149 * codewordPosition) % 253) + 1;
	int tempVariable = ch + pseudoRandom;
	return narrow_cast<uint8_t>(tempVariable <= 254 ? tempVariable : (tempVariable - 254));
}

static int FindMinimums(const std::array<int, 6>& intCharCounts, int min, std::array<int, 6>& mins)
{
	mins.fill(0);
	for (int i = 0; i < 6; i++) {
		int current = intCharCounts[i];
		if (min > current) {
			min = current;
			mins.fill(0);
		}
		if (min == current) {
			mins[i]++;
		}
	}
	return min;
}

static int LookAheadTest(const std::string& msg, size_t startpos, int currentMode)
{
	if (startpos >= msg.length()) {
		return currentMode;
	}
	std::array<float, 6> charCounts;
	//step J
	if (currentMode == ASCII_ENCODATION) {
		charCounts = { 0, 1, 1, 1, 1, 1.25f };
	}
	else {
		charCounts = { 1, 2, 2, 2, 2, 2.25f };
		charCounts[currentMode] = 0;
	}

	std::array<int, 6> mins;
	std::array<int, 6> intCharCounts;
	int charsProcessed = 0;
	while (true) {
		//step K
		if ((startpos + charsProcessed) == msg.length()) {
			int min = std::numeric_limits<int>::max();
			std::transform(charCounts.begin(), charCounts.end(), intCharCounts.begin(),
						   [](float x) { return static_cast<int>(std::ceil(x)); });
			min = FindMinimums(intCharCounts, min, mins);
			int minCount = Reduce(mins);

			if (intCharCounts[ASCII_ENCODATION] == min) {
				return ASCII_ENCODATION;
			}
			if (minCount == 1 && mins[BASE256_ENCODATION] > 0) {
				return BASE256_ENCODATION;
			}
			if (minCount == 1 && mins[EDIFACT_ENCODATION] > 0) {
				return EDIFACT_ENCODATION;
			}
			if (minCount == 1 && mins[TEXT_ENCODATION] > 0) {
				return TEXT_ENCODATION;
			}
			if (minCount == 1 && mins[X12_ENCODATION] > 0) {
				return X12_ENCODATION;
			}
			return C40_ENCODATION;
		}

		int c = (uint8_t)msg.at(startpos + charsProcessed);
		charsProcessed++;

		//step L
		if (IsDigit(c)) {
			charCounts[ASCII_ENCODATION] += 0.5f;
		}
		else if (IsExtendedASCII(c)) {
			charCounts[ASCII_ENCODATION] = std::ceil(charCounts[ASCII_ENCODATION]);
			charCounts[ASCII_ENCODATION] += 2.0f;
		}
		else {
			charCounts[ASCII_ENCODATION] = std::ceil(charCounts[ASCII_ENCODATION]);
			charCounts[ASCII_ENCODATION] += 1.0f;
		}

		//step M
		if (IsNativeC40(c)) {
			charCounts[C40_ENCODATION] += 2.0f / 3.0f;
		}
		else if (IsExtendedASCII(c)) {
			charCounts[C40_ENCODATION] += 8.0f / 3.0f;
		}
		else {
			charCounts[C40_ENCODATION] += 4.0f / 3.0f;
		}

		//step N
		if (IsNativeText(c)) {
			charCounts[TEXT_ENCODATION] += 2.0f / 3.0f;
		}
		else if (IsExtendedASCII(c)) {
			charCounts[TEXT_ENCODATION] += 8.0f / 3.0f;
		}
		else {
			charCounts[TEXT_ENCODATION] += 4.0f / 3.0f;
		}

		//step O
		if (IsNativeX12(c)) {
			charCounts[X12_ENCODATION] += 2.0f / 3.0f;
		}
		else if (IsExtendedASCII(c)) {
			charCounts[X12_ENCODATION] += 13.0f / 3.0f;
		}
		else {
			charCounts[X12_ENCODATION] += 10.0f / 3.0f;
		}

		//step P
		if (IsNativeEDIFACT(c)) {
			charCounts[EDIFACT_ENCODATION] += 3.0f / 4.0f;
		}
		else if (IsExtendedASCII(c)) {
			charCounts[EDIFACT_ENCODATION] += 17.0f / 4.0f;
		}
		else {
			charCounts[EDIFACT_ENCODATION] += 13.0f / 4.0f;
		}

		// step Q
		if (IsSpecialB256(c)) {
			charCounts[BASE256_ENCODATION] += 4.0f;
		}
		else {
			charCounts[BASE256_ENCODATION] += 1.0f;
		}

		//step R
		if (charsProcessed >= 4) {
			std::transform(charCounts.begin(), charCounts.end(), intCharCounts.begin(),
						   [](float x) { return static_cast<int>(std::ceil(x)); });
			FindMinimums(intCharCounts, std::numeric_limits<int>::max(), mins);
			int minCount = Reduce(mins);

			if (intCharCounts[ASCII_ENCODATION] < intCharCounts[BASE256_ENCODATION]
				&& intCharCounts[ASCII_ENCODATION] < intCharCounts[C40_ENCODATION]
				&& intCharCounts[ASCII_ENCODATION] < intCharCounts[TEXT_ENCODATION]
				&& intCharCounts[ASCII_ENCODATION] < intCharCounts[X12_ENCODATION]
				&& intCharCounts[ASCII_ENCODATION] < intCharCounts[EDIFACT_ENCODATION]) {
				return ASCII_ENCODATION;
			}
			if (intCharCounts[BASE256_ENCODATION] < intCharCounts[ASCII_ENCODATION]
				|| (mins[C40_ENCODATION] + mins[TEXT_ENCODATION] + mins[X12_ENCODATION] + mins[EDIFACT_ENCODATION]) == 0) {
				return BASE256_ENCODATION;
			}
			if (minCount == 1 && mins[EDIFACT_ENCODATION] > 0) {
				return EDIFACT_ENCODATION;
			}
			if (minCount == 1 && mins[TEXT_ENCODATION] > 0) {
				return TEXT_ENCODATION;
			}
			if (minCount == 1 && mins[X12_ENCODATION] > 0) {
				return X12_ENCODATION;
			}
			if (intCharCounts[C40_ENCODATION] + 1 < intCharCounts[ASCII_ENCODATION]
				&& intCharCounts[C40_ENCODATION] + 1 < intCharCounts[BASE256_ENCODATION]
				&& intCharCounts[C40_ENCODATION] + 1 < intCharCounts[EDIFACT_ENCODATION]
				&& intCharCounts[C40_ENCODATION] + 1 < intCharCounts[TEXT_ENCODATION]) {
				if (intCharCounts[C40_ENCODATION] < intCharCounts[X12_ENCODATION]) {
					return C40_ENCODATION;
				}
				if (intCharCounts[C40_ENCODATION] == intCharCounts[X12_ENCODATION]) {
					size_t p = startpos + charsProcessed + 1;
					while (p < msg.length()) {
						int tc = msg.at(p);
						if (IsX12TermSep(tc)) {
							return X12_ENCODATION;
						}
						if (!IsNativeX12(tc)) {
							break;
						}
						p++;
					}
					return C40_ENCODATION;
				}
			}
		}
	}
}

static std::string ToHexString(int c)
{
	const char* digits = "0123456789abcdef";
	std::string val(4, '0');
	val[1] = 'x';
	val[2] = digits[(c >> 4) & 0xf];
	val[3] = digits[c & 0xf];
	return val;
}

namespace ASCIIEncoder {
	/**
	* Determines the number of consecutive characters that are encodable using numeric compaction.
	*
	* @param msg      the message
	* @param startpos the start position within the message
	* @return the requested character count
	*/
	static int DetermineConsecutiveDigitCount(const std::string& msg, int startpos)
	{
		auto begin = msg.begin() + startpos;
		return narrow_cast<int>(std::find_if_not(begin, msg.end(), IsDigit) - begin);
	}

	static uint8_t EncodeASCIIDigits(int digit1, int digit2)
	{
		if (IsDigit(digit1) && IsDigit(digit2)) {
			int num = (digit1 - '0') * 10 + (digit2 - '0');
			return static_cast<uint8_t>(num + 130);
		}
		return '?';
	}

	static void EncodeASCII(EncoderContext& context)
	{
		//step B
		int n = DetermineConsecutiveDigitCount(context.message(), context.currentPos());
		if (n >= 2) {
			context.addCodeword(EncodeASCIIDigits(context.currentChar(), context.nextChar()));
			context.setCurrentPos(context.currentPos() + 2);
		}
		else {
			int c = context.currentChar();
			int newMode = LookAheadTest(context.message(), context.currentPos(), ASCII_ENCODATION);
			if (newMode != ASCII_ENCODATION)
			{
				// the order here is the same as ENCODATION;
				context.addCodeword(LATCHES[newMode]);
				context.setNewEncoding(newMode);
			}
			else if (IsExtendedASCII(c)) {
				context.addCodeword(UPPER_SHIFT);
				context.addCodeword(static_cast<uint8_t>(c - 128 + 1));
				context.setCurrentPos(context.currentPos() + 1);
			}
			else {
				context.addCodeword(static_cast<uint8_t>(c + 1));
				context.setCurrentPos(context.currentPos() + 1);
			}
		}
	}

} // ASCIIEncoder

namespace C40Encoder {

	static int EncodeChar(int c, std::string& sb)
	{
		if (c == ' ') {
			sb.push_back('\3');
			return 1;
		}
		if (c >= '0' && c <= '9') {
			sb.push_back((char)(c - 48 + 4));
			return 1;
		}
		if (c >= 'A' && c <= 'Z') {
			sb.push_back((char)(c - 65 + 14));
			return 1;
		}
		if (c >= '\0' && c <= '\x1f') {
			sb.push_back('\0'); //Shift 1 Set
			sb.push_back(c);
			return 2;
		}
		if (c <= '/') {
			sb.push_back('\1'); //Shift 2 Set
			sb.push_back((char)(c - 33));
			return 2;
		}
		if (c <= '@') {
			sb.push_back('\1'); //Shift 2 Set
			sb.push_back((char)(c - 58 + 15));
			return 2;
		}
		if (c <= '_') {
			sb.push_back('\1'); //Shift 2 Set
			sb.push_back((char)(c - 91 + 22));
			return 2;
		}
		if (c <= '\x7f') {
			sb.push_back('\2'); //Shift 3 Set
			sb.push_back((char)(c - 96));
			return 2;
		}
		sb.append("\1\x1e"); //Shift 2, Upper Shift
		int len = 2;
		len += EncodeChar((char)(c - 0x80), sb);
		return len;
	}

	static int BacktrackOneCharacter(EncoderContext& context, std::string& buffer, std::string& removed, int lastCharSize,
									 std::function<int(int, std::string&)> encodeChar)
	{
		buffer.resize(buffer.size() - lastCharSize);
		context.setCurrentPos(context.currentPos() - 1);
		int c = context.currentChar();
		lastCharSize = encodeChar(c, removed);
		context.resetSymbolInfo(); //Deal with possible reduction in symbol size
		return lastCharSize;
	}

	static void EncodeToCodewords(EncoderContext& context, const std::string& sb, int startPos) {
		int c1 = sb.at(startPos);
		int c2 = sb.at(startPos + 1);
		int c3 = sb.at(startPos + 2);
		int v = (1600 * c1) + (40 * c2) + c3 + 1;
		context.addCodeword(narrow_cast<uint8_t>(v / 256));
		context.addCodeword(narrow_cast<uint8_t>(v % 256));
	}

	static void WriteNextTriplet(EncoderContext& context, std::string& buffer)
	{
		EncodeToCodewords(context, buffer, 0);
		buffer.erase(0, 3);
	}

	/**
	* Handle "end of data" situations
	*
	* @param context the encoder context
	* @param buffer  the buffer with the remaining encoded characters
	*/
	static void HandleEOD(EncoderContext& context, std::string& buffer)
	{
		int unwritten = (Size(buffer) / 3) * 2;
		int rest = Size(buffer) % 3;

		int curCodewordCount = context.codewordCount() + unwritten;
		auto symbolInfo = context.updateSymbolInfo(curCodewordCount);
		int available = symbolInfo->dataCapacity() - curCodewordCount;

		if (rest == 2) {
			buffer.push_back('\0'); //Shift 1
			while (buffer.length() >= 3) {
				WriteNextTriplet(context, buffer);
			}
			if (context.hasMoreCharacters()) {
				context.addCodeword(C40_UNLATCH);
			}
		}
		else if (available == 1 && rest == 1) {
			while (buffer.length() >= 3) {
				WriteNextTriplet(context, buffer);
			}
			if (context.hasMoreCharacters()) {
				context.addCodeword(C40_UNLATCH);
			}
			// else no unlatch
			context.setCurrentPos(context.currentPos() - 1);
		}
		else if (rest == 0) {
			while (buffer.length() >= 3) {
				WriteNextTriplet(context, buffer);
			}
			if (available > 0 || context.hasMoreCharacters()) {
				context.addCodeword(C40_UNLATCH);
			}
		}
		else {
			throw std::logic_error("Unexpected case. Please report!");
		}
		context.setNewEncoding(ASCII_ENCODATION);
	}

	static void EncodeC40(EncoderContext& context, std::function<int (int, std::string&)> encodeChar, int encodingMode)
	{
		//step C
		std::string buffer;
		while (context.hasMoreCharacters()) {
			int c = context.currentChar();
			context.setCurrentPos(context.currentPos() + 1);
			int lastCharSize = encodeChar(c, buffer);
			int unwritten = narrow_cast<int>(buffer.length() / 3) * 2;
			int curCodewordCount = context.codewordCount() + unwritten;
			auto symbolInfo = context.updateSymbolInfo(curCodewordCount);
			int available = symbolInfo->dataCapacity() - curCodewordCount;

			if (!context.hasMoreCharacters()) {
				//Avoid having a single C40 value in the last triplet
				std::string removed;
				if ((buffer.length() % 3) == 2 && available != 2) {
					lastCharSize = BacktrackOneCharacter(context, buffer, removed, lastCharSize, encodeChar);
				}
				while ((buffer.length() % 3) == 1 && ((lastCharSize <= 3 && available != 1) || lastCharSize > 3)) {
					lastCharSize = BacktrackOneCharacter(context, buffer, removed, lastCharSize, encodeChar);
				}
				break;
			}

			if ((buffer.length() % 3) == 0) {
				int newMode = LookAheadTest(context.message(), context.currentPos(), encodingMode);
				if (newMode != encodingMode) {
					// Return to ASCII encodation, which will actually handle latch to new mode
					context.setNewEncoding(ASCII_ENCODATION);
					break;
				}
			}
		}
		return HandleEOD(context, buffer);
	}

	static void EncodeC40(EncoderContext& context)
	{
		EncodeC40(context, EncodeChar, C40_ENCODATION);
	}

} // C40Encoder

namespace DMTextEncoder {

	static int EncodeChar(int c, std::string& sb)
	{
		if (c == ' ') {
			sb.push_back('\3');
			return 1;
		}
		if (c >= '0' && c <= '9') {
			sb.push_back((char)(c - 48 + 4));
			return 1;
		}
		if (c >= 'a' && c <= 'z') {
			sb.push_back((char)(c - 97 + 14));
			return 1;
		}
		if (c >= '\0' && c <= '\x1f') {
			sb.push_back('\0'); //Shift 1 Set
			sb.push_back(c);
			return 2;
		}
		if (c <= '/') {
			sb.push_back('\1'); //Shift 2 Set
			sb.push_back((char)(c - 33));
			return 2;
		}
		if (c <= '@') {
			sb.push_back('\1'); //Shift 2 Set
			sb.push_back((char)(c - 58 + 15));
			return 2;
		}
		if (c >= '[' && c <= '_') {
			sb.push_back('\1'); //Shift 2 Set
			sb.push_back((char)(c - 91 + 22));
			return 2;
		}
		if (c == '\x60') {
			sb.push_back('\2'); //Shift 3 Set
			sb.push_back((char)(c - 96));
			return 2;
		}
		if (c <= 'Z') {
			sb.push_back('\2'); //Shift 3 Set
			sb.push_back((char)(c - 65 + 1));
			return 2;
		}
		if (c <= '\x7f') {
			sb.push_back('\2'); //Shift 3 Set
			sb.push_back((char)(c - 123 + 27));
			return 2;
		}
		sb.append("\1\x1e"); //Shift 2, Upper Shift
		int len = 2;
		len += EncodeChar(c - 128, sb);
		return len;
	}

	static void EncodeText(EncoderContext& context)
	{
		C40Encoder::EncodeC40(context, EncodeChar, TEXT_ENCODATION);
	}

} // DMTextEncoder

namespace X12Encoder {

	static int EncodeChar(int c, std::string& sb)
	{
		switch (c) {
		case '\r': sb.push_back('\0'); break;
		case '*': sb.push_back('\1'); break;
		case '>': sb.push_back('\2'); break;
		case ' ': sb.push_back('\3'); break;
		default:
			if (c >= '0' && c <= '9') {
				sb.push_back((char)(c - 48 + 4));
			} else if (c >= 'A' && c <= 'Z') {
				sb.push_back((char)(c - 65 + 14));
			} else {
				throw std::invalid_argument("Illegal character: " + ToHexString(c));
			}
			break;
		}
		return 1;
	}

	static void HandleEOD(EncoderContext& context, std::string& buffer)
	{
		int codewordCount = context.codewordCount();
		auto symbolInfo = context.updateSymbolInfo(codewordCount);
		int available = symbolInfo->dataCapacity() - codewordCount;
		context.setCurrentPos(context.currentPos() - Size(buffer));
		if (context.remainingCharacters() > 1 || available > 1 || context.remainingCharacters() != available) {
			context.addCodeword(X12_UNLATCH);
		}
		if (context.newEncoding() < 0) {
			context.setNewEncoding(ASCII_ENCODATION);
		}
	}

	static void EncodeX12(EncoderContext& context)
	{
		//step C
		std::string buffer;
		while (context.hasMoreCharacters()) {
			int c = context.currentChar();
			context.setCurrentPos(context.currentPos() + 1);
			EncodeChar(c, buffer);
			size_t count = buffer.length();
			if ((count % 3) == 0) {
				C40Encoder::WriteNextTriplet(context, buffer);

				int newMode = LookAheadTest(context.message(), context.currentPos(), X12_ENCODATION);
				if (newMode != X12_ENCODATION) {
					// Return to ASCII encodation, which will actually handle latch to new mode
					context.setNewEncoding(ASCII_ENCODATION);
					break;
				}
			}
		}
		HandleEOD(context, buffer);
	}
	
} // X12Encoder

namespace EdifactEncoder {

	static void EncodeChar(int c, std::string& sb)
	{
		if (c >= ' ' && c <= '?') {
			sb.push_back(c);
		}
		else if (c >= '@' && c <= '^') {
			sb.push_back((char)(c - 64));
		}
		else {
			throw std::invalid_argument("Illegal character: " + ToHexString(c));
		}
	}

	static ByteArray EncodeToCodewords(const std::string& sb, int startPos)
	{
		int len = Size(sb) - startPos;
		if (len == 0) {
			throw std::invalid_argument("buffer must not be empty");
		}
		int c1 = sb.at(startPos);
		int c2 = len >= 2 ? sb.at(startPos + 1) : 0;
		int c3 = len >= 3 ? sb.at(startPos + 2) : 0;
		int c4 = len >= 4 ? sb.at(startPos + 3) : 0;

		int v = (c1 << 18) + (c2 << 12) + (c3 << 6) + c4;
		uint8_t cw1 = (v >> 16) & 255;
		uint8_t cw2 = (v >> 8) & 255;
		uint8_t cw3 = v & 255;
		ByteArray res;
		res.reserve(3);
		res.push_back(cw1);
		if (len >= 2) {
			res.push_back(cw2);
		}
		if (len >= 3) {
			res.push_back(cw3);
		}
		return res;
	}

	/**
	* Handle "end of data" situations
	*
	* @param context the encoder context
	* @param buffer  the buffer with the remaining encoded characters
	*/
	static void HandleEOD(EncoderContext& context, std::string& buffer)
	{
		try {
			size_t count = buffer.length();
			if (count == 0) {
				return; //Already finished
			}
			if (count == 1) {
				//Only an unlatch at the end
				int codewordCount = context.codewordCount();
				auto symbolInfo = context.updateSymbolInfo(codewordCount);
				int available = symbolInfo->dataCapacity() - codewordCount;
				int remaining = context.remainingCharacters();
				// The following two lines are a hack inspired by the 'fix' from https://sourceforge.net/p/barcode4j/svn/221/
				if (remaining > available)
					available = context.updateSymbolInfo(codewordCount+1)->dataCapacity() - codewordCount;
				if (remaining <= available && available <= 2) {
					return; //No unlatch
				}
			}

			if (count > 4) {
				throw std::invalid_argument("Count must not exceed 4");
			}
			int restChars = static_cast<int>(count - 1);
			auto encoded = EncodeToCodewords(buffer, 0);
			bool endOfSymbolReached = !context.hasMoreCharacters();
			bool restInAscii = endOfSymbolReached && restChars <= 2;

			if (restChars <= 2) {
				int codewordCount = context.codewordCount();
				auto symbolInfo = context.updateSymbolInfo(codewordCount + restChars);
				int available = symbolInfo->dataCapacity() - codewordCount;
				if (available >= 3) {
					restInAscii = false;
					context.updateSymbolInfo(codewordCount + Size(encoded));
					//available = context.symbolInfo.dataCapacity - context.getCodewordCount();
				}
			}

			if (restInAscii) {
				context.resetSymbolInfo();
				context.setCurrentPos(context.currentPos() - restChars);
			}
			else {
				for (uint8_t cw : encoded) {
					context.addCodeword(cw);
				}
			}
		}
		catch (...) {
			context.setNewEncoding(ASCII_ENCODATION);
			throw;
		}
		context.setNewEncoding(ASCII_ENCODATION);
	}

	static void EncodeEdifact(EncoderContext& context)
	{
		//step F
		std::string buffer;
		while (context.hasMoreCharacters()) {
			int c = context.currentChar();
			EncodeChar(c, buffer);
			context.setCurrentPos(context.currentPos() + 1);

			if (buffer.length() >= 4) {
				auto codewords = EncodeToCodewords(buffer, 0);
				for (uint8_t cw : codewords) {
					context.addCodeword(cw);
				}
				buffer.erase(0, 4);

				int newMode = LookAheadTest(context.message(), context.currentPos(), EDIFACT_ENCODATION);
				if (newMode != EDIFACT_ENCODATION) {
					// Return to ASCII encodation, which will actually handle latch to new mode
					context.setNewEncoding(ASCII_ENCODATION);
					break;
				}
			}
		}
		buffer.push_back(31); //Unlatch
		HandleEOD(context, buffer);
	}

} // EdifactEncoder

namespace Base256Encoder {

	static int Randomize255State(int ch, int codewordPosition)
	{
		int pseudoRandom = ((149 * codewordPosition) % 255) + 1;
		int tempVariable = ch + pseudoRandom;
		if (tempVariable <= 255) {
			return tempVariable;
		}
		else {
			return tempVariable - 256;
		}
	}

	static void EncodeBase256(EncoderContext& context)
	{
		std::string buffer;
		buffer.push_back('\0'); //Initialize length field
		while (context.hasMoreCharacters()) {
			int c = context.currentChar();
			buffer.push_back(c);

			context.setCurrentPos(context.currentPos() + 1);

			int newMode = LookAheadTest(context.message(), context.currentPos(), BASE256_ENCODATION);
			if (newMode != BASE256_ENCODATION) {
				// Return to ASCII encodation, which will actually handle latch to new mode
				context.setNewEncoding(ASCII_ENCODATION);
				break;
			}
		}
		int dataCount = Size(buffer) - 1;
		int lengthFieldSize = 1;
		int currentSize = context.codewordCount() + dataCount + lengthFieldSize;
		auto symbolInfo = context.updateSymbolInfo(currentSize);
		bool mustPad = (symbolInfo->dataCapacity() - currentSize) > 0;
		if (context.hasMoreCharacters() || mustPad) {
			if (dataCount <= 249) {
				buffer.at(0) = (char)dataCount;
			}
			else if (dataCount <= 1555) {
				buffer.at(0) = (char)((dataCount / 250) + 249);
				buffer.insert(1, 1, (char)(dataCount % 250));
			}
			else {
				throw std::invalid_argument("Message length not in valid ranges: " + std::to_string(dataCount));
			}
		}
		for (char c : buffer) {
			context.addCodeword(Randomize255State(c, context.codewordCount() + 1));
		}
	}

} // Base256Encoder

//TODO: c++20
static bool StartsWith(std::wstring_view s, std::wstring_view ss)
{
	return s.length() > ss.length() && s.compare(0, ss.length(), ss) == 0;
}

static bool EndsWith(std::wstring_view s, std::wstring_view ss)
{
	return s.length() > ss.length() && s.compare(s.length() - ss.length(), ss.length(), ss) == 0;
}

ByteArray Encode(const std::wstring& msg)
{
	return Encode(msg, CharacterSet::ISO8859_1, SymbolShape::NONE, -1, -1, -1, -1);
}

/**
* Performs message encoding of a DataMatrix message using the algorithm described in annex P
* of ISO/IEC 16022:2000(E).
*
* @param msg     the message
* @param shape   requested shape. May be {@code SymbolShapeHint.FORCE_NONE},
*                {@code SymbolShapeHint.FORCE_SQUARE} or {@code SymbolShapeHint.FORCE_RECTANGLE}.
* @param minSize the minimum symbol size constraint or null for no constraint
* @param maxSize the maximum symbol size constraint or null for no constraint
* @return the encoded message (the char values range from 0 to 255)
*/
ByteArray Encode(const std::wstring& msg, CharacterSet charset, SymbolShape shape, int minWidth, int minHeight, int maxWidth, int maxHeight)
{
	//the codewords 0..255 are encoded as Unicode characters
	//Encoder[] encoders = {
	//	new ASCIIEncoder(), new C40Encoder(), new TextEncoder(),
	//	new X12Encoder(), new EdifactEncoder(),  new Base256Encoder()
	//};

	if (charset == CharacterSet::Unknown) {
		charset = CharacterSet::ISO8859_1;
	}

	EncoderContext context(TextEncoder::FromUnicode(msg, charset));
	context.setSymbolShape(shape);
	context.setSizeConstraints(minWidth, minHeight, maxWidth, maxHeight);

	constexpr std::wstring_view MACRO_05_HEADER = L"[)>\x1E""05\x1D";
	constexpr std::wstring_view MACRO_06_HEADER = L"[)>\x1E""06\x1D";
	constexpr std::wstring_view MACRO_TRAILER = L"\x1E\x04";

	if (StartsWith(msg, MACRO_05_HEADER) && EndsWith(msg, MACRO_TRAILER)) {
		context.addCodeword(MACRO_05);
		context.setSkipAtEnd(2);
		context.setCurrentPos(Size(MACRO_05_HEADER));
	}
	else if (StartsWith(msg, MACRO_06_HEADER) && EndsWith(msg, MACRO_TRAILER)) {
		context.addCodeword(MACRO_06);
		context.setSkipAtEnd(2);
		context.setCurrentPos(Size(MACRO_06_HEADER));
	}

	int encodingMode = ASCII_ENCODATION; //Default mode
	while (context.hasMoreCharacters()) {
		switch (encodingMode) {
		case ASCII_ENCODATION:   ASCIIEncoder::EncodeASCII(context);     break;
		case C40_ENCODATION:     C40Encoder::EncodeC40(context);         break;
		case TEXT_ENCODATION:    DMTextEncoder::EncodeText(context);     break;
		case X12_ENCODATION:     X12Encoder::EncodeX12(context);         break;
		case EDIFACT_ENCODATION: EdifactEncoder::EncodeEdifact(context); break;
		case BASE256_ENCODATION: Base256Encoder::EncodeBase256(context); break;
		}
		if (context.newEncoding() >= 0) {
			encodingMode = context.newEncoding();
			context.clearNewEncoding();
		}
	}
	int len = context.codewordCount();
	auto symbolInfo = context.updateSymbolInfo(len);
	int capacity = symbolInfo->dataCapacity();
	if (len < capacity) {
		if (encodingMode != ASCII_ENCODATION && encodingMode != BASE256_ENCODATION && encodingMode != EDIFACT_ENCODATION) {
			context.addCodeword('\xfe'); //Unlatch (254)
		}
	}
	//Padding
	if (context.codewordCount() < capacity) {
		context.addCodeword(PAD);
	}
	while (context.codewordCount() < capacity) {
		context.addCodeword(Randomize253State(PAD, context.codewordCount() + 1));
	}

	return context.codewords();
}

} // namespace ZXing::DataMatrix