/*
 * stringutils.h
 *
 *  Created on: Dec 4, 2016
 *      Author: gregor
 */

#ifndef GLTB_STRINGUTILS_H_
#define GLTB_STRINGUTILS_H_

#include <sstream>
#include <string>
#include <vector>

namespace gltb {
	extern inline
	std::string toUpper(const std::string &input)
	{
		std::string result;

		for(size_t i = 0; i < input.length(); i++) {
			result += toupper(input[i]);
		}

		return result;
	}

	extern inline
	std::string toLower(const std::string &input)
	{
		std::string result;

		for(size_t i = 0; i < input.length(); i++) {
			result += tolower(input[i]);
		}

		return result;
	}

	extern inline
	std::vector<std::string> split(const std::string &input, const std::string &token)
	{
		std::vector<std::string> result;

		size_t lastSplit = 0;

		for(size_t i = 0; i < input.length() - token.length() + 1; i++) {
			if(input.substr(i, token.length()) == token) {
				result.push_back(input.substr(lastSplit, i - lastSplit));
				lastSplit = i + token.length();

				// skip remainder of token
				i += token.length() - 1;
			}
		}

		result.push_back(input.substr(lastSplit, input.length() - lastSplit));

		return result;
	}

	template<typename intType>
	intType parseInt(std::string value)
	{
		intType result = 0;

		bool isNegative = false;

		size_t index = 0;
		if(value[0] == '-') {
			isNegative = true;
			index++;
		}

		while(value[index] >= '0' && value[index] <= '9') {
			intType digit = value[index] - '0';
			result = result * 10 + digit;
		}

		if(isNegative) {
			result *= -1;
		}

		return result;
	}

	template<typename Arg>
	void _convertAndAppend(std::vector<std::string> &argStrings, Arg arg)
	{
		std::ostringstream stream;
		stream << arg;
		argStrings.push_back(stream.str());
	}

	template<typename FirstArg>
	void _convertToString(std::vector<std::string> &argStrings, FirstArg firstArg)
	{
		_convertAndAppend(argStrings, firstArg);
	}

	template<typename FirstArg, typename... Args>
	void _convertToString(std::vector<std::string> &argStrings, FirstArg firstArg, Args... args)
	{
		_convertAndAppend(argStrings, firstArg);
		_convertToString(argStrings, args...);
	}

	template<typename... Args>
	std::string format(std::string formatString, Args... args)
	{
		std::vector<std::string> argStrings;

		_convertToString(argStrings, args...);

		std::string result;

		enum Mode {
			Verbatim,
			ArgIndex
		};

		Mode mode = Verbatim;
		std::string argIndexString;

		for (size_t i = 0; i < formatString.length(); i++) {
			switch(mode) {
			case Verbatim:
				if(formatString[i] == '{') {
					if(i + 1 < formatString.length()) {
						if(formatString[i + 1] == '{') {
							result += "{";
							i++;
						}
					}
				} else {
					result += formatString[i];
				}
				break;
			case ArgIndex:
				if(formatString[i] == '}') {
					const int argIndex = parseInt<int>(argIndexString);

					argIndexString = "";

					result += argStrings[argIndex];

					mode = Verbatim;
				} else {
					argIndexString += formatString[i];
				}
				break;
			}
		}

		return result;
	}
}

#endif /* GLTB_STRINGUTILS_H_ */