mugendefwriter.cpp

#include "prism/mugendefwriter.h"

#include <assert.h>
#include <sstream>
#include <string>

#include "prism/datastructures.h"
#include "prism/log.h"

namespace prism {

	ModifiableMugenDefScript openModifiableMugenDefScript(const std::string& tPath) {
		if (!isFile(tPath)) {
			auto b = copyStringToBuffer("\n");
			bufferToFile(tPath.c_str(), b);
			freeBuffer(b);
		}

		ModifiableMugenDefScript ret;
		ret.mOwnedBuffer = makeBufferOwnedIfNecessary(fileToBuffer(tPath.c_str()));
		return ret;
	}

	void closeModifiableMugenDefScript(ModifiableMugenDefScript* tScript)
	{
		freeBuffer(tScript->mOwnedBuffer);
	}

	void saveModifiableMugenDefScript(ModifiableMugenDefScript* tScript, const std::string& tPath) {
		bufferToFile(tPath.c_str(), tScript->mOwnedBuffer);
	}

	void clearModifiableMugenDefScript(ModifiableMugenDefScript* tScript)
	{
		freeBuffer(tScript->mOwnedBuffer);
		tScript->mOwnedBuffer = copyStringToBuffer("\n");
	}

	static BufferPointer getStartOfModifiableMugenDefScript(ModifiableMugenDefScript* tScript) {
		auto p = getBufferPointer(tScript->mOwnedBuffer);
		return p;
	}

	static void replaceStringInModifiableMugenDefScript(ModifiableMugenDefScript* tScript, BufferPointer writePos, const std::string& tValue, size_t replacedSize) {
		const auto preWriteSize = size_t(writePos - ((char*)tScript->mOwnedBuffer.mData));
		const auto configPart1 = std::string((char*)tScript->mOwnedBuffer.mData, preWriteSize);
		const auto configPart2 = std::string(writePos + replacedSize, tScript->mOwnedBuffer.mLength - preWriteSize - replacedSize);
		const auto finalString = configPart1 + tValue + configPart2;
		freeBuffer(tScript->mOwnedBuffer);
		tScript->mOwnedBuffer = copyStringToBuffer(finalString);
	}

	static void insertStringIntoModifiableMugenDefScript(ModifiableMugenDefScript* tScript, BufferPointer writePos, const std::string& tValue) {
		replaceStringInModifiableMugenDefScript(tScript, writePos, tValue, 0);
	}

	static void addModifiableMugenDefScriptGroup(ModifiableMugenDefScript* tScript, const char* tGroupName) {
		auto writePos = getStartOfModifiableMugenDefScript(tScript);
		insertStringIntoModifiableMugenDefScript(tScript, writePos, std::string("[") + tGroupName + "]\n");
	}

	static BufferPointer findExistingVariablePositionOrNullIfNonExistant(ModifiableMugenDefScript* tScript, const char* tGroupName, const char* tVariableName) {
		auto p = getBufferPointer(tScript->mOwnedBuffer);

		int found = 0;
		while (true) {
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, tScript->mOwnedBuffer);
			if (isBufferPointerOver(p, tScript->mOwnedBuffer)) break;
			if (line.size() > 0 && line[0] != '[') continue;
			std::string groupName;
			for (size_t i = 1; i < line.size() && line[i] != ']'; i++) {
				groupName.push_back(line[i]);
			}
			if (stringEqualCaseIndependent(groupName.c_str(), tGroupName)) {
				found = 1;
				break;
			}
		}

		if (!found) return NULL;

		std::vector<std::pair<std::string, BufferPointer>> relevantLines;
		while (true) {
			auto linePosition = p;
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, tScript->mOwnedBuffer);
			if (isBufferPointerOver(p, tScript->mOwnedBuffer)) break;
			if (line.size() > 0 && line[0] == '[') break;
			relevantLines.push_back(std::make_pair(line, linePosition));
		}

		for (size_t i = 0; i < relevantLines.size(); i++) {
			std::istringstream ss(relevantLines[i].first);
			std::string firstWord;
			ss >> firstWord;
			if (stringEqualCaseIndependent(firstWord.c_str(), tVariableName)) {
				return relevantLines[i].second;
			}
		}

		return NULL;
	}

	static BufferPointer findExistingVariablePositionOrNullIfNonExistant(ModifiableMugenDefScript* tScript, const char* tGroupName, size_t tGroupOffset, const char* tVariableName) {
		auto p = getBufferPointer(tScript->mOwnedBuffer);

		int foundOriginal = 0;
		int index = 0;
		int found = 0;
		while (true) {
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, tScript->mOwnedBuffer);
			if (isBufferPointerOver(p, tScript->mOwnedBuffer)) break;
			if (line.empty() || line[0] != '[') continue; // only real group headers count towards the offset
			std::string groupName;
			for (size_t i = 1; i < line.size() && line[i] != ']'; i++) {
				groupName.push_back(line[i]);
			}
			if (foundOriginal)
			{
				if (index == int(tGroupOffset))
				{
					found = 1;
					break;
				}
				index++;
			}
			else
			{
				if (stringEqualCaseIndependent(groupName.c_str(), tGroupName)) {
					foundOriginal = 1;
				}
			}
		}

		if (!found) return NULL;

		std::vector<std::pair<std::string, BufferPointer>> relevantLines;
		while (true) {
			auto linePosition = p;
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, tScript->mOwnedBuffer);
			if (isBufferPointerOver(p, tScript->mOwnedBuffer)) break;
			if (line.size() > 0 && line[0] == '[') break;
			relevantLines.push_back(std::make_pair(line, linePosition));
		}

		for (size_t i = 0; i < relevantLines.size(); i++) {
			std::istringstream ss(relevantLines[i].first);
			std::string firstWord;
			ss >> firstWord;
			if (stringEqualCaseIndependent(firstWord.c_str(), tVariableName)) {
				return relevantLines[i].second;
			}
		}

		return NULL;
	}

	// insert position right after the header of the tGroupOffset-th group following the tGroupName group, mirroring the search in the offset variant of findExistingVariablePositionOrNullIfNonExistant
	static BufferPointer findStartOfGroup(ModifiableMugenDefScript* tScript, const char* tGroupName, size_t tGroupOffset) {
		auto p = getBufferPointer(tScript->mOwnedBuffer);

		int foundOriginal = 0;
		int index = 0;
		while (true) {
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, tScript->mOwnedBuffer);
			if (isBufferPointerOver(p, tScript->mOwnedBuffer)) break;
			if (line.empty() || line[0] != '[') continue; // only real group headers count towards the offset
			std::string groupName;
			for (size_t i = 1; i < line.size() && line[i] != ']'; i++) {
				groupName.push_back(line[i]);
			}
			if (foundOriginal)
			{
				if (index == int(tGroupOffset))
				{
					return p;
				}
				index++;
			}
			else
			{
				if (stringEqualCaseIndependent(groupName.c_str(), tGroupName)) {
					foundOriginal = 1;
				}
			}
		}

		return NULL;
	}

	static BufferPointer findStartOfGroup(ModifiableMugenDefScript* tScript, const char* tGroupName) {
		auto p = getBufferPointer(tScript->mOwnedBuffer);

		while (true) {
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, tScript->mOwnedBuffer);
			if (isBufferPointerOver(p, tScript->mOwnedBuffer)) break;
			if (line.size() > 0 && line[0] != '[') continue;
			std::string groupName;
			for (size_t i = 1; i < line.size() && line[i] != ']'; i++) {
				groupName.push_back(line[i]);
			}
			if (stringEqualCaseIndependent(groupName.c_str(), tGroupName)) {
				return p;
			}
		}

		return NULL;
	}

	static int hasModifiableMugenDefScriptGroup(ModifiableMugenDefScript* tScript, const char* tGroupName) {
		auto p = getBufferPointer(tScript->mOwnedBuffer);

		while (true) {
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, tScript->mOwnedBuffer);
			if (isBufferPointerOver(p, tScript->mOwnedBuffer)) break;
			if (line.size() > 0 && line[0] != '[') continue;
			std::string groupName;
			for (size_t i = 1; i < line.size() && line[i] != ']'; i++) {
				groupName.push_back(line[i]);
			}
			if (stringEqualCaseIndependent(groupName.c_str(), tGroupName)) {
				return 1;
			}
		}

		return 0;
	}

	static int isEmptyCharacter(char tChar) {
		return tChar == ' ';
	}

	static void adaptValueAtPosition(ModifiableMugenDefScript* tScript, BufferPointer writePosition, const std::string& tValue, const char* tGroupName, const char* tVariableName) {
		auto startPosition = writePosition;
		const auto line = readLineOrEOFFromTextStreamBufferPointer(&writePosition, tScript->mOwnedBuffer);
		const auto equalPos = line.find('=');
		if (equalPos == line.npos) {
			logWarningFormat("Unable to write value %s to [%s] %s. Ignoring.", tValue.c_str(), tGroupName, tVariableName);
			return;
		}

		auto start = equalPos + 1;
		while (start < line.size() && isEmptyCharacter(line[start])) start++;

		auto end = start;
		std::string previousValue;
		while (end < line.size() && line[end] != ';') {
			previousValue.push_back(line[end]);
			end++;
		}

		replaceStringInModifiableMugenDefScript(tScript, startPosition + start, tValue, previousValue.size());
	}

	static void writeNewVariableLine(ModifiableMugenDefScript* tScript, BufferPointer writePosition, const char* tVariableName, const std::string& tValue) {
		insertStringIntoModifiableMugenDefScript(tScript, writePosition, std::string("") + tVariableName + " = " + tValue + "\n");
	}

	void saveMugenDefString(ModifiableMugenDefScript* tScript, const char* tGroupName, const char* tVariableName, const std::string& tValue) {
		assert(isStringLowercase(tGroupName));
		assert(isStringLowercase(tVariableName));
		auto sectionStart = findExistingVariablePositionOrNullIfNonExistant(tScript, tGroupName, tVariableName);
		if (sectionStart) {
			adaptValueAtPosition(tScript, sectionStart, tValue, tGroupName, tVariableName);
		}
		else {
			if (!hasModifiableMugenDefScriptGroup(tScript, tGroupName)) {
				addModifiableMugenDefScriptGroup(tScript, tGroupName);
			}

			auto writePosition = findStartOfGroup(tScript, tGroupName);
			assert(writePosition);
			writeNewVariableLine(tScript, writePosition, tVariableName, tValue);
		}
	}

	void saveMugenDefFloat(ModifiableMugenDefScript* tScript, const char* tGroupName, const char* tVariableName, float tValue)
	{
		saveMugenDefString(tScript, tGroupName, tVariableName, std::to_string(tValue));
	}

	void saveMugenDefInteger(ModifiableMugenDefScript* tScript, const char* tGroupName, const char* tVariableName, int tValue) {
		saveMugenDefString(tScript, tGroupName, tVariableName, std::to_string(tValue));
	}

	void addMugenDefScriptGroup(const std::string& tPath, const char* tAnchorGroupName, int tAnchorGroupOffset, const char* tNewGroupName, const std::vector<std::pair<std::string, std::string>>& tVariables)
	{
		auto script = openModifiableMugenDefScript(tPath);

		// find the start of the anchor group's content (same search as the offset variant of saveMugenDefString)
		auto p = getBufferPointer(script.mOwnedBuffer);
		int foundOriginal = 0;
		int index = 0;
		int foundAnchor = 0;
		while (!foundAnchor) {
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, script.mOwnedBuffer);
			if (isBufferPointerOver(p, script.mOwnedBuffer)) break;
			if (line.empty() || line[0] != '[') continue; // only real group headers count towards the offset
			std::string groupName;
			for (size_t i = 1; i < line.size() && line[i] != ']'; i++) {
				groupName.push_back(line[i]);
			}
			if (foundOriginal)
			{
				if (index == tAnchorGroupOffset)
				{
					foundAnchor = 1;
				}
				index++;
			}
			else
			{
				if (stringEqualCaseIndependent(groupName.c_str(), tAnchorGroupName)) {
					foundOriginal = 1;
					if (tAnchorGroupOffset < 0) foundAnchor = 1;
				}
			}
		}

		if (!foundAnchor) {
			closeModifiableMugenDefScript(&script);
			return;
		}

		// advance to the end of the anchor group's content: the start of the next group header line, or EOF
		auto writePosition = p;
		while (true) {
			auto linePosition = p;
			if (isBufferPointerOver(p, script.mOwnedBuffer)) {
				writePosition = (char*)script.mOwnedBuffer.mData + script.mOwnedBuffer.mLength;
				break;
			}
			const auto line = readLineOrEOFFromTextStreamBufferPointer(&p, script.mOwnedBuffer);
			if (!line.empty() && line[0] == '[') {
				writePosition = linePosition;
				break;
			}
			if (isBufferPointerOver(p, script.mOwnedBuffer)) {
				writePosition = (char*)script.mOwnedBuffer.mData + script.mOwnedBuffer.mLength;
				break;
			}
		}

		std::string groupText;
		const auto isAtEndWithoutNewline = (writePosition == (char*)script.mOwnedBuffer.mData + script.mOwnedBuffer.mLength) && script.mOwnedBuffer.mLength && ((char*)script.mOwnedBuffer.mData)[script.mOwnedBuffer.mLength - 1] != '\n';
		if (isAtEndWithoutNewline) groupText += "\n";
		groupText += std::string("[") + tNewGroupName + "]\n";
		for (const auto& variable : tVariables) {
			groupText += variable.first + " = " + variable.second + "\n";
		}
		groupText += "\n";
		insertStringIntoModifiableMugenDefScript(&script, writePosition, groupText);

		saveModifiableMugenDefScript(&script, tPath);
		closeModifiableMugenDefScript(&script);
	}

	void saveMugenDefString(const std::string& tPath, const char* tGroupName, size_t tGroupOffset, const char* tVariableName, const std::string& tValue)
	{
		auto script = openModifiableMugenDefScript(tPath);

		auto sectionStart = findExistingVariablePositionOrNullIfNonExistant(&script, tGroupName, tGroupOffset, tVariableName);
		if (sectionStart)
		{
			adaptValueAtPosition(&script, sectionStart, tValue, tGroupName, tVariableName);
		}
		else
		{
			// variable not declared in the target group yet: append it right below the group header
			// if the target group itself cannot be found, leave the file untouched
			auto writePosition = findStartOfGroup(&script, tGroupName, tGroupOffset);
			if (!writePosition)
			{
				closeModifiableMugenDefScript(&script);
				return;
			}
			writeNewVariableLine(&script, writePosition, tVariableName, tValue);
		}

		saveModifiableMugenDefScript(&script, tPath);
		closeModifiableMugenDefScript(&script);
	}

}