Cppcheck report - Fission: libs/fsAppCore/src/fsCInputSession.cpp

#include "fsCInputSession.h"

#include <algorithm>

#include <fsCore/fsIFileListBuilder.h>
#include <fsCore/src/fsNRnd.h>
#include <fsCore/src/fsCAppSettings.h>

#include <fsAppCore/src/fsCProfileManager.h>



const fsStr fsCInputSession::mMessageLogFileName("messages");
const fsStr fsCInputSession::mMessageLogFileNameExt(".txt");
const fsStr fsCInputSession::mReplayFolder("replay/");

const fsStr fsCInputSession::mGlobalStateFile("global.txt");


fsCInputSession::sRecordedMessage::sRecordedMessage(fsS64 pTime, fsCUniqueId pId,
                                                    const fsIInputManager::sClonableMessageParameters& pParams) :
	mTime(pTime),
	mId(pId),
	mParams(pParams.clone())
{
}

fsCInputSession::sRecordedMessage::sRecordedMessage(const sRecordedMessage& pCopy) :
	mTime(pCopy.mTime),
	mId(pCopy.mId),
	mParams(pCopy.mParams->clone())
{
}

fsCInputSession::sRecordedMessage& fsCInputSession::sRecordedMessage::operator=(const sRecordedMessage& pCopy)
{
	if (this != &pCopy)
	{
		mTime = pCopy.mTime;
		mId = pCopy.mId;
		delete mParams;
		mParams = pCopy.mParams->clone();
	}
	return *this;
}

fsCInputSession::sRecordedMessage::~sRecordedMessage()
{
	delete mParams;
}

fsCInputSession::sRecordedMessage::sRecordedMessage(fsStr& pSaveStr) :
	mTime(pSaveStr.chomp(",").toS64())
{
	mId.load(pSaveStr);
	mParams = fsIInputManager::sClonableMessageParameters::create(pSaveStr);
	pSaveStr.chomp("\r\n");
}

void fsCInputSession::sRecordedMessage::saveStr(fsStr& pSaveStr) const
{
	pSaveStr += fsStr(mTime) + fsStr(",");
	mId.save(pSaveStr);
	mParams->saveStr(pSaveStr);
	pSaveStr += fsStr("\r\n");
}

void fsCInputSession::update(fsS32 pTimeDeltaMS)
{
	mRunningTime += pTimeDeltaMS;
}

fsBool fsCInputSession::recordingGet() const
{
	return !mSessionName.emptyGet();
}

fsCInputSession::sRecordedMessage fsCInputSession::messagePop()
{
	sRecordedMessage message = mMessages.back();
	mMessages.pop_back();
	if (mMessages.empty())
	{
		nextBatchOfMessagesRead();
	}
	return message;
}

fsBool fsCInputSession::messageReady() const
{
	return !mMessages.empty()
		&& mMessages.back().mId != fsIInputManager::mFrameUpdateMsg
		&& mMessages.back().mTime <= mRunningTime;
}

fsBool fsCInputSession::frameUpdateMessageReady()
{
	mRunningTime += fsCAppCoreMain::instanceGet()->timeStepGet();
	return !mMessages.empty()
		&& mMessages.back().mId == fsIInputManager::mFrameUpdateMsg
		&& mMessages.back().mTime - dynamic_cast<fsIInputManager::sFrameUpdateParam*>(mMessages.back().mParams)->
			mFrameDelta <= mRunningTime;
}

void fsCInputSession::messageAdd(const fsCUniqueId& pMessageType,
                                 const fsIInputManager::sClonableMessageParameters& pParam)
{
	mMessages.push_back(sRecordedMessage(mRunningTime, pMessageType, pParam));
	if (mMessages.size() == mMessages.capacity())
	{
		messagesSave();
		mMessages.clear();
	}
}

fsStr fsCInputSession::sessionNameGenerate() const
{
	// 	time_t rawtime;
	// 	struct tm *timeinfo;
	// 	fsChar buffer[80];
	// 
	// 	time(&rawtime);
	// 	timeinfo = localtime(&rawtime);
	// 
	// 	strftime(buffer, 80, "%b%d-%H%M%S", timeinfo);
	// 	fsStr fName;
	// 	fName = buffer;

	const fsStr sessionStr("session");
	const fsS32 maxSaveFiles(3);
	fsS32 savedSessions(1);

	fsFileList fileList = fsIFileListBuilder::fileListGet(fsCResourceName(
		sessionStr + savedSessions, fsCResourceName::eRES_LOCATION_USER_SETTINGS), "", false);
	if (!fileList.empty())
	{
		while (!fileList.empty() && savedSessions++ < maxSaveFiles)
		{
			fileList = fsIFileListBuilder::fileListGet(
				fsCResourceName(sessionStr + savedSessions, fsCResourceName::eRES_LOCATION_USER_SETTINGS), "", false);
		}
	}

	auto rotateSavedSessions =[&]()
	{
		--savedSessions;
		fsS32 count(1);
		while (count <= maxSaveFiles)
		{
			fileList = fsIFileListBuilder::fileListGet(fsCResourceName(
				sessionStr + count, fsCResourceName::eRES_LOCATION_USER_SETTINGS), "", false);
			for (fsCFileListEntry fileEntry : fileList)
			{
				if (count > 1)
				{
					resourceCopy(sessionStr + count + "/" + fileEntry.nameGet(),
					             sessionStr + (count - 1) + "/" + fileEntry.nameGet());
				}
				resourceDelete(sessionStr + count + "/" + "/" + fileEntry.nameGet());
			}
			++count;
		}
	};

	if (savedSessions > maxSaveFiles)
	{
		rotateSavedSessions();
	}

	
	return sessionStr + savedSessions;
}

void fsCInputSession::messagesSave()
{
	fsStr saveStr;
	if (mCurrentSaveId == 0)
	{
		rndSeedSave(saveStr);
	}

	for (sRecordedMessage& message : mMessages)<--- Variable 'message' can be declared as reference to const
	{
		message.saveStr(saveStr);
	}

	mFilename = mSessionName + "/" + mMessageLogFileName + fsStr(++mCurrentSaveId) + ".txt";
	fsIFile::strWriteToFile(fsCResourceName(mFilename, fsCResourceName::eRES_LOCATION_USER_SETTINGS), saveStr);
}

void fsCInputSession::messagesLoad(fsS32 pOffset, fsS32 pLineCount, void (fsCInputSession::*pDecodceFnc)(fsStr& pStr))
{
	mFilename = mReplayFolder + "/" + mMessageLogFileName + fsStr(mCurrentSaveId) + ".txt";
	std::vector<fsStr> dataLines = fsIFile::textFileReadToVector(
		fsCResourceName(mFilename, fsCResourceName::eRES_LOCATION_USER_SETTINGS));
	if (!dataLines.empty())
	{
		auto line = dataLines.begin();
		line += pOffset;
		
		for (; line != dataLines.end() && pLineCount-- >= 0; ++line)
		{
			if (!(*line).emptyGet())
			{
				(this->*pDecodceFnc)(*line);
			}
		}
	}
}

void fsCInputSession::resourceCopy(const fsStr& pSource, const fsStr& pDestination) const<--- The member function 'fsCInputSession::resourceCopy' can be static.
{
	fsIFile::fileCopy(fsCResourceName(pSource, fsCResourceName::eRES_LOCATION_USER_SETTINGS),
						fsCResourceName(pDestination, fsCResourceName::eRES_LOCATION_USER_SETTINGS));
}

void fsCInputSession::resourceDelete(const fsStr& pSource) const<--- The member function 'fsCInputSession::resourceDelete' can be static.
{
	if (fsIFile::folderIs(fsCResourceName(pSource, fsCResourceName::eRES_LOCATION_USER_SETTINGS)))
	{
		fsIFile::folderDelete(fsCResourceName(pSource, fsCResourceName::eRES_LOCATION_USER_SETTINGS));
	}
	else
	{
		fsIFile::fileDelete(fsCResourceName(pSource, fsCResourceName::eRES_LOCATION_USER_SETTINGS));
	}
}

fsBool fsCInputSession::resourceExists(const fsStr& pSource) const<--- The member function 'fsCInputSession::resourceExists' can be static.
{
	return fsIFile::fileExistsGet(fsCResourceName(pSource, fsCResourceName::eRES_LOCATION_USER_SETTINGS));
}

fsStr fsCInputSession::userStateFileNameGet(fsS32 pId) const<--- The member function 'fsCInputSession::userStateFileNameGet' can be static.
{
	const fsStr userStateFilePrefix("user");
	const fsStr userStateFileSuffix(".txt");
	return userStateFilePrefix + pId + userStateFileSuffix;
}

void fsCInputSession::statePreserve(const fsStr& pStateFolder)
{
	fsIFile::folderCreate(fsCResourceName(pStateFolder, fsCResourceName::eRES_LOCATION_USER_SETTINGS));
	
	if (resourceExists(mGlobalStateFile))
	{
		resourceCopy(mGlobalStateFile, pStateFolder + mGlobalStateFile);
	
		fsS32 count = 0;
		while (resourceExists((userStateFileNameGet(count))))
		{
			resourceDelete(pStateFolder + userStateFileNameGet(count));
			resourceCopy(userStateFileNameGet(count), pStateFolder + userStateFileNameGet(count));
			++count;
		}
	}
}

void fsCInputSession::stateRestore(const fsStr& pStateFolder)
{
	if (resourceExists(pStateFolder + mGlobalStateFile))
	{
		resourceCopy(pStateFolder + mGlobalStateFile, mGlobalStateFile);

		fsS32 count = 0;
		while (resourceExists(pStateFolder + userStateFileNameGet(count)))
		{
			resourceDelete(userStateFileNameGet(count));
			resourceCopy(pStateFolder + userStateFileNameGet(count), userStateFileNameGet(count));
			++count;
		}
	}
}

void fsCInputSession::loadStrDecodeRecordedMessage(fsStr& pStr)
{
	mMessages.push_back(sRecordedMessage(pStr));
}

void fsCInputSession::loadStrDecodeRndSeed(fsStr& pStr)
{
	fsNRnd::seedSet(pStr.toU32());
}

void fsCInputSession::nextBatchOfMessagesRead()
{
	mMessages.clear();
	messagesLoad(1, mEventBufferSize, &fsCInputSession::loadStrDecodeRecordedMessage);
	std::reverse(mMessages.begin(), mMessages.end());
	++mCurrentSaveId;
}

void fsCInputSession::rndSeedSave(fsStr& pStr) const<--- The member function 'fsCInputSession::rndSeedSave' can be static.
{
	pStr += fsStr(fsNRnd::seedGet()) + fsStr("\r\n");
}

void fsCInputSession::rndSeedLoad()
{
	messagesLoad(0, 1, &fsCInputSession::loadStrDecodeRndSeed);
}

fsCInputSession::fsCInputSession():
	mEventBufferSize(30 * 60 * 10),
	mRunningTime(0),
	mSessionName(""),
	mCurrentSaveId(0)
{

	mMessages.reserve(mEventBufferSize);

	mFilename = mReplayFolder + mMessageLogFileName + 1 + mMessageLogFileNameExt;

	if (fsIFile::fileExistsGet(fsCResourceName(mFilename,
	                                           fsCResourceName::eRES_LOCATION_USER_SETTINGS)))
	{
		statePreserve("tmp/");
		stateRestore(mReplayFolder);
		fsCProfileManager::instanceGet()->initialise();

		++mCurrentSaveId;
		rndSeedLoad();
		nextBatchOfMessagesRead();
		fsCAppCoreMain::instanceGet()->timeStepSet(fsCAppCoreMain::instanceGet()->settingsGet()->s32Get("recordInput"));
	}
	else
	{
		mSessionName = sessionNameGenerate();
		statePreserve(mSessionName + "/");
		mFilename = mSessionName + "/" + mMessageLogFileName + mMessageLogFileNameExt;
	}
}

fsCInputSession::~fsCInputSession()
{
	if (recordingGet())
	{
		if (!mMessages.empty())
		{
			messagesSave();
		}
	}
	else
	{
		stateRestore("tmp/");
		fsIFile::folderDelete(fsCResourceName("tmp/", fsCResourceName::eRES_LOCATION_USER_SETTINGS));
	}
}