std::string Mission::getDescription(Player* player) const
{
	int32_t value;
	player->getStorageValue(storageID, value);

	if (!mainDescription.empty()) {
		std::string desc = mainDescription;
		replaceString(desc, "|STATE|", std::to_string(value));
		replaceString(desc, "\\n", "\n");
		return desc;
	}

	if (ignoreEndValue) {
		for (int32_t current = endValue; current >= startValue; current--) {
			if (value >= current) {
				auto sit = descriptions.find(current);
				if (sit != descriptions.end()) {
					return sit->second;
				}
			}
		}
	} else {
		for (int32_t current = endValue; current >= startValue; current--) {
			if (value == current) {
				auto sit = descriptions.find(current);
				if (sit != descriptions.end()) {
					return sit->second;
				}
			}
		}
	}
	return "An error has occurred, please contact a gamemaster.";
}

static int textAlreadyAdded(char *text)
{
	int i;
	char *clean;

	if (strcmpignorecase("msgid \"\"", text) == 0)
	{
		return TRUE;
	}

	clean = replaceString(text, "msgid \"", "");
	clean[strlen(clean) - 1] = '\0';
	clean = replaceString(clean, "\\", "");
	clean = replaceString(clean, "\\", "");

	for (i=0;i<poIndex;i++)
	{
		if (strcmpignorecase(added[i], text) == 0)
		{
			return TRUE;
		}
	}

	if (checkExists(clean) == FALSE)
	{
		return TRUE;
	}

	STRNCPY(added[poIndex], text, MAX_LINE_LENGTH);

	poIndex++;

	return FALSE;
}

	std::ofstream &exportSubScript(std::ofstream &stream, Script &script, const std::string &subName)
	{
		SubScript &subScript = script.subScripts[subName];

		if(subName == "execute"  && subScript.script.empty())
			return stream;

		// HACK: special sub is not actually a sub... -jpk
		if (subName != "special")
		{
			stream << "sub " << subName << std::endl;
		}

		if(subName == "main")
		{
			stream << "   call createpaths" << std::endl;

			for(unsigned int i = 0; i < script.initialization.size(); ++i)
				stream << "   " << replaceString(script.initialization[i], script.properties.strings, script.stringProperties.defaults) << std::endl;
		}

		for(unsigned int i = 0; i < subScript.script.size(); ++i)
			stream << "   " << replaceString(subScript.script[i], script.properties.strings, script.stringProperties.defaults) << std::endl;

		// HACK: special sub is not actually a sub... -jpk
		if (subName != "special")
		{
			stream << "endSub" << std::endl;
		}

		return stream;
	}

std::string Mission::getDescription(Player* player)
{
	std::string value;
	player->getStorage(storageId, value);
	if(state.size())
	{
		std::string ret = state;
		replaceString(ret, "|STATE|", value);
		return ret;
	}

	if(atoi(value.c_str()) >= endValue)
	{
		std::string ret = states.rbegin()->second;
		replaceString(ret, "|STATE|", value);
		return ret;
	}

	for(int32_t i = endValue; i >= startValue; --i)
	{
		player->getStorage(storageId, value);
		if(atoi(value.c_str()) != i)
			continue;
 
		std::string ret = states[i - startValue];
		replaceString(ret, "|STATE|", value);
		return ret;
 
	}
 
	return "Couldn't retrieve any mission description, please report to a gamemaster.";
}

	/**@brief A function to start a runLog in the named directory
	 * @param dirName The name of the directory to start the runLog, runLog name
	 *will be runLog_[NAME_OF_PROGRAM]
	 *
	 */
	void startARunLog(const std::string &dirName) {
		rLog_.setFilenameAndOpen(
				files::make_path(dirName,"runLog_"
						+ replaceString(replaceString(commands_.getProgramName(), "./", ""),
								" ", "-")+ "_" + getCurrentDate() + ".txt").string(), timer_.start_);
		rLog_.startRunLog(commands_);
	}

	string trimString(string const &text)
	{
		string ret = replaceString(text, " ", "");
		ret = replaceString(ret, "\t", "");
		ret = replaceString(ret, "\r", "");
		ret = replaceString(ret, "\n", "");
		return ret;
	}

	SLAString getSharedLibSuffix()	{
		SLAString libSuffix(Poco::SharedLibrary::suffix());
#if defined(_DEBUG)
		libSuffix = replaceString(libSuffix, "d.", "_Debug.");
#else
		libSuffix = replaceString(libSuffix, ".", "_Release.");
#endif
		return libSuffix;
	}

char * handSanitizer(char *fix) {//returns a string that is dynamically alcolated.
		fix = replaceString("--","+",fix);
		fix = replaceString(" ","",fix);
		fix = replaceString("-", "+-",fix);
		fix = replaceString("X", "x",fix);
		fix = replaceString("^+-", "^-",fix);
		fix = replaceString("++-", "+-", fix);
		fix = replaceString("*+-", "*-",fix);
		fix = replaceString("(+-", "(-",fix);
		fix = replaceString(")(",")*(",fix);
		
		if(strncmp(fix,"+-",2)==0){
			size_t len = strlen(fix);//original length
			memcpy(fix,&fix[1],len);//cpy to fix starting at fix[1], for orig len-1
			fix = (char *) realloc(fix,len);//realloc space to be smaller
		}
		if(strncmp(fix,"+",1)==0){//same as above
			size_t len = strlen(fix);
			memcpy(fix,&fix[1],len);
			fix = (char *) realloc(fix,len);
		}
	
		printf("Reformatted Equation: %s",fix);
		return fix;
		
}

std::string getExporterFileName( std::string const& fileName ) {
	std::string sourceName = "Exported from: ";
	sourceName += fileName;

	// these symbols can't be in the meta data
	replaceString( sourceName, "=", "_" );
	replaceString( sourceName, ";", "_" );
  replaceString( sourceName, "\\", "/" );
	
	return sourceName;
}

qpid::types::Variant::Map getConfigTree() {
    qpid::types::Variant::Map tree;
    if (augeas==NULL) augeas_init();
    if (augeas == NULL) {
        AGO_ERROR() << "cannot initialize augeas";
        return tree;
    }
    char **matches;
    std::stringstream path;
    path << "/files";
    path << getConfigPath(MODULE_CONFDIR).string();
    path << "/";
    std::string prefix = path.str();
    path << "/*";
    int num = aug_match(augeas, path.str().c_str(), &matches);
    for (int i=0; i < num; i++) {
        const char *val;
        aug_get(augeas, matches[i], &val);
        if (val != NULL) {
            std::vector<std::string> elements;
            std::string match = matches[i];
            AGO_TRACE() << "getConfigTree:augeas match result[" << i << "]:" << match << ": " << val;
            replaceString(match, prefix, "");
            replaceString(match, ".conf", "");
            elements = split(match, '/');
            if (elements.size() != 3) {
                AGO_ERROR() << "augeas match ignored: does not split by / in three parts: " << match;
                continue;
            }
            std::string file = elements[0];
            std::string section = elements[1];
            std::string option = elements[2];
            AGO_TRACE() << "File: " << file << " Section: " << section << " Option: " << option;

            qpid::types::Variant::Map fileMap;
            qpid::types::Variant::Map sectionMap;
            if (!(tree[file].isVoid())) {
                fileMap = tree[file].asMap();
            }
            if (!(fileMap[section].isVoid())) {
                sectionMap = fileMap[section].asMap();
            }
            sectionMap[option] = val;
            fileMap[section] = sectionMap;
            tree[file] = fileMap;
        }
        free((void *) matches[i]);
    }
    free(matches);
    return tree;

}

//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
std::string
DatabaseConnection::escapeString(const std::string& _string)
{
    std::string str(_string);

    // Escape the project name
    std::string searchString("\'"); 
    std::string replaceString("\'\'");

    std::string::size_type pos = 0;
    while ((pos = str.find(searchString, pos)) != std::string::npos) 
    {
        str.replace(pos, searchString.size(), replaceString);
        pos += replaceString.size();
    }

    searchString = "\"\"";
    pos = 0;

    while ((pos = str.find(searchString, pos)) != std::string::npos) 
    {
        str.replace(pos, searchString.size(), replaceString);
        pos += replaceString.size();
    }

    return str;
}

void
replaceStringInFile(const char *filename, const string &toFind, const string &replaceWith) {
	FILE *f = fopen(filename, "r");
	if (f == NULL) {
		int e = errno;
		string message = "Cannot open file '";
		message.append(filename);
		message.append("' for reading");
		throw FileSystemException(message, e, filename);
	}
	string content(readAll(fileno(f)));
	fclose(f);
	
	f = fopen(filename, "w");
	if (f == NULL) {
		int e = errno;
		string message = "Cannot open file '";
		message.append(filename);
		message.append("' for writing");
		throw FileSystemException(message, e, filename);
	}
	content = replaceString(content, toFind, replaceWith);
	fwrite(content.data(), 1, content.size(), f);
	fclose(f);
}

bool CHostTracker::isNavigatedToBadLink()
{
	bool isBadLink = true;
	rho::StringW navUrl = replaceString(m_szNavigatedUrl, L"%20", L" ");
	//replace back slash in badlink url to front slash
	rho::StringW badUrl = replaceString(m_szBadLinkUrl, L"\\", L"/");

	LOG(INFO)  + "CHostTracker::run navigated url"+  navUrl.c_str(); 
	LOG(INFO)  + "CHostTracker::run badlink url"+  badUrl.c_str();

	if(std::string::npos == navUrl.find(badUrl))
	{		
		isBadLink = false;
	}
	return isBadLink;
}

void convert::replaceStringInFile(const std::string& oldfilename, const std::string& newfilename, const std::string& oldstring, const std::string& newstring)
{
    std::string s = readStringFromFile(oldfilename);
    if (s.length() <= 0) { return; }
    replaceString(s, oldstring, newstring);
    writeStringToFile(s, newfilename);
}

void nameFunction(t_tree node)
{
	if (node == NULL)
		return;

	if (nameCurrentPrimitive != NULL)
	{
		if (strcmp(node->Node.Function.Name, "main") == 0)
		{
			replaceString(&node->Node.Function.Name, nameCurrentPrimitive->Node.Primitive.Name);
			node->Node.Function.Variables = nameCurrentPrimitive->Node.Primitive.Variables;
			nameCurrentPrimitive->Node.Primitive.Variables = NULL;
			namePrimitiveVariables(node->Node.Function.Variables);
		}
		else
			joinStrings(&node->Node.Function.Name, nameCurrentPrimitive->Node.Primitive.Name, node->Node.Function.Name);			
	}
	
	checkIdExists(node->Node.Function.Name, node->LineNr, node->Node.Function.Type, NAME_TABLE_FUNCTION);
	scope = FindId(node->Node.Function.Name, scope);
		
	nameVariable(node->Node.Function.Variables);

	nameStmnt(node->Node.Function.Stmnts);

	scope = scope->parent;
	namePrimitive(node->Node.Function.Next);
}

	std::string FileCacheExt::createCacheFileName(const std::string& originalFileName) const
	{
		std::string serverAddress = osgDB::getServerAddress(originalFileName);
		std::string cacheFileName(_fileCachePath);
		cacheFileName.append("/");
		if (serverAddress.empty())
		{
			cacheFileName.append(originalFileName);
			osg::notify(osg::NOTICE) << "FileCache::_fileCachePath ==" << _fileCachePath << std::endl;
		}
		else
		{
			int size = _serverAddress.size();
			std::string rFile = originalFileName.substr(size + 1, originalFileName.size() - size - 1);
			replaceString(rFile,"/", "%2F", -1);
			std::string eName = tryConvertStringFromEscapeToUTF8(rFile);
			std::string localFile = cacheFileName;
			localFile.append(eName);
			if (osgDB::fileExists(localFile))
				return localFile;
			std::string gbkString("");
			tryConvertStringFromUTF8ToGB2312(localFile, gbkString);
			if (osgDB::fileExists(gbkString))
				return gbkString;
			return originalFileName;
		}
		osg::notify(osg::NOTICE) << "FileCache::createCacheFileName(" << originalFileName << ") = " << cacheFileName << std::endl;
		return cacheFileName;
	}

std::string ModelMaker::replaceAllString(std::string& fullString, std::string toReplace, std::string replaceWith){
	std::string returnString = fullString;
	while(returnString.find(toReplace) != std::string::npos)	{
		returnString = replaceString(returnString, toReplace, replaceWith);
	}

	return returnString;
}

	/**@brief Construct the setUp with the generic argc and argv
	 *
	 * @param argc The number of arguments
	 * @param argv The array of char pointers of the arguments
	 *
	 */
	programSetUp(int argc, char *argv[]) :
			commands_(commandLineArguments(argc, argv)) {
		commands_.arguments_["-program"] = argv[0];
		// get rid of the ./ if program is being called from current dir, it can
		// mess things up latter
		programName_ = replaceString(argv[0], "./", "");
		init();
	}

string
replaceAll(const string &str, const string &toFind, const string &replaceWith) {
	string result = str;
	while (result.find(toFind) != string::npos) {
		result = replaceString(result, toFind, replaceWith);
	}
	return result;
}

int main(void)
{
    char text[] = "I have a dream and have 1 dreame * ding word.";

    printf("%s\n", text);

    replaceString(text, "1", "one");
    printf("%s\n", text);

    replaceString(text, "a", "");
    printf("%s\n", text);

    replaceString(text, " ", "");
    printf("%s\n", text);

    return 0;

}