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

#include "fsCProfileManager.h"

#include <fsCore/src/debug/fsAssert.h>
#include <fsCore/src/fsCAppSettings.h>
#include <fsCore/fsIFile.h>
#include <fsCore/fsIHardware.h>
#include <fsCore/src/fsCGlobalSavedData.h>
#include <fsCore/src/fsCUserSavedData.h>

#include <fsAudio/fsIAudioManager.h>

#include "../fsIDisplay.h"
#include "fsCGuiMessageDispatcher.h"
#include "fsCSoftwareCursor.h"

// Remove this when the auto test is moved into app core or more likely these checks are moved into a HOG specific profile manager
#include <gfHogCore/components/test/gfCAutoTestManager.h>

fsCProfileManager* fsCProfileManager::mInstance = nullptr;

const fsCUniqueId fsCProfileManager::mProfilesHaveChangedMsg("ProfileSlotsHaveChanged");
const fsCUniqueId fsCProfileManager::mProfileCreationCompleteMsg("ProfileCreationComplete");
const fsCUniqueId fsCProfileManager::mPayWallBreachedMsg("payWallBreached");

const fsStr fsCProfileManager::mReleaseTesterName("0cslrts0");
const fsStr fsCProfileManager::mDevTesterName("1cslrts1");


#if defined fsInAppPurchaseProcess

void fsCProfileManager::currPlayerFreeLevelCountSet(const fsStr& pPlayerName )
{
	mCurrPlayerNumFreeScenes = mNumFreeScenes;
	if( pPlayerName == gfCAutoTestManager::mAutoLoadTestName || pPlayerName == gfCAutoTestManager::mAutoPlayTestName)
	{
		mCurrPlayerNumFreeScenes = 0;
	}
}

void fsCProfileManager::freeLevelCountSet( fsS32 pLevelCount )
{
#if defined fsInAppPurchaseProcess
	mNumFreeScenes = pLevelCount;
	currPlayerFreeLevelCountSet(mSavedData->strGet(fsCGlobalSavedData::mProfileNameKey +
		mSavedData->strGet( fsCGlobalSavedData::mCurrentProfileIndexKey)));
#endif
}

fsBool fsCProfileManager::progressBlockedByPaywallGet()
{
	if (fullGamePurchasedGet())<--- Condition 'fullGamePurchasedGet()' is always true<--- Calling function 'fullGamePurchasedGet' returns 1
	{
		return false;
	}

#if defined fsInAppPurchase
	if (mCurrPlayerNumFreeScenes > 0)
	{
		const fsS32 visitedLevels = mUserSavedData->levelsVisitedCountGet();
		if (visitedLevels > mCurrPlayerNumFreeScenes)
		{
			return true;
		}
	}
#endif
	return false;
}

void fsCProfileManager::fullGamePurchasedHandle()
{
#if defined fsInAppPurchase
	mSavedData->boolSet( fsCGlobalSavedData::mPurchasedPayWallKey, true );
#endif
 	allDataSave( false );
	fsCGuiMessageDispatcher::instanceGet()->messageDispatch( mPayWallBreachedMsg, fsIMessageDispatcher::mNullParam );
}

void fsCProfileManager::fullGamePurchaseRevokeHandle()
{
#if defined fsInAppPurchase
	mSavedData->boolSet(fsCGlobalSavedData::mPurchasedPayWallKey, false);
#endif
	allDataSave(false);
}

fsBool fsCProfileManager::fullGamePurchasedGet()
{
#if defined fsInAppPurchase
    return mSavedData->boolGet( fsCGlobalSavedData::mPurchasedPayWallKey ) || 0 == mCurrPlayerNumFreeScenes;
#else
    return true;
#endif
}

fsBool fsCProfileManager::fullGamePurchasedPersistedGet()
{
#if defined fsInAppPurchase
	return mSavedData->boolGet( fsCGlobalSavedData::mPurchasedPayWallKey );
#else
	return true;
#endif
}
#endif

fsStr fsCProfileManager::chapterGet()
{
	return mChapter;
}

void fsCProfileManager::chapterSet(const fsStr& pChapter)
{
	if (mChapter == pChapter)
	{
		return;
	}

	userDataSave();

	mChapter = pChapter;

	if (!mChapter.emptyGet()
		&& fsCGlobalSavedData::mNoProfileLoaded != mSavedData->currentProfileIndexGet()
		&& !profileMatchesCurrentChapterGet(mSavedData->currentProfileIndexGet()))
	{
		mSavedData->currentProfileIndexSet(fsCGlobalSavedData::mNoProfileLoaded);
		mUserSavedData->resetToDefaults();
	}

	if (!mChapter.emptyGet()
		&& fsCGlobalSavedData::mNoProfileLoaded == mSavedData->currentProfileIndexGet()
		&& chapterProfileCountGet() > 0)
	{
		profileLoad(chapterProfileIndexToGlobalIndex(0));
		return;
	}

	globalDataSave();
}

fsCUserSavedData* fsCProfileManager::userSavedDataGet() const
{
	return mUserSavedData.get();
}

fsCGlobalSavedData* fsCProfileManager::savedDataGet() const
{
	return mSavedData.get();
}

fsBool fsCProfileManager::profileMatchesCurrentChapterGet(fsS32 pProfileIndex) const
{
	if (mChapter.emptyGet())
	{
		return true;
	}

	return mSavedData->profileChapterGet(pProfileIndex) == mChapter;
}

fsS32 fsCProfileManager::chapterProfileCountGet() const
{
	if (mChapter.emptyGet())
	{
		return mSavedData->numProfilesGet();
	}

	fsS32 count = 0;
	for (fsS32 profileInd = 0; profileInd < mSavedData->numProfilesGet(); ++profileInd)
	{
		if (profileMatchesCurrentChapterGet(profileInd))
		{
			++count;
		}
	}
	return count;
}

fsS32 fsCProfileManager::chapterProfileIndexToGlobalIndex(fsS32 pProfileIndex) const
{
	if (mChapter.emptyGet())
	{
		return pProfileIndex;
	}

	fsS32 chapterProfileInd = 0;
	for (fsS32 globalProfileInd = 0; globalProfileInd < mSavedData->numProfilesGet(); ++globalProfileInd)
	{
		if (profileMatchesCurrentChapterGet(globalProfileInd))
		{
			if (chapterProfileInd == pProfileIndex)
			{
				return globalProfileInd;
			}
			++chapterProfileInd;
		}
	}

	fsAssert(false, "Chapter profile index is out of range.\n");
	return fsCGlobalSavedData::mNoProfileLoaded;
}

fsS32 fsCProfileManager::currentChapterProfileIndexGet() const
{
	const fsS32 currentProfile = mSavedData->currentProfileIndexGet();
	if (fsCGlobalSavedData::mNoProfileLoaded == currentProfile)
	{
		return fsCGlobalSavedData::mNoProfileLoaded;
	}

	if (mChapter.emptyGet())
	{
		return currentProfile;
	}

	fsS32 chapterProfileInd = 0;
	for (fsS32 globalProfileInd = 0; globalProfileInd < mSavedData->numProfilesGet(); ++globalProfileInd)
	{
		if (profileMatchesCurrentChapterGet(globalProfileInd))
		{
			if (globalProfileInd == currentProfile)
			{
				return chapterProfileInd;
			}
			++chapterProfileInd;
		}
	}

	return fsCGlobalSavedData::mNoProfileLoaded;
}

fsStr fsCProfileManager::chapterProfileNameGet(fsS32 pProfileIndex) const
{
	return mSavedData->profileNameGet(chapterProfileIndexToGlobalIndex(pProfileIndex));
}

fsS32 fsCProfileManager::chapterProfileGameModeGet(fsS32 pProfileIndex) const
{
	return mSavedData->profileGameModeGet(chapterProfileIndexToGlobalIndex(pProfileIndex));
}

void fsCProfileManager::allDataSave(fsBool /*pIsAutoSave*/) const
{
	globalDataSave();
	userDataSave();
}

void fsCProfileManager::cheatModeActivate(const fsStr& pPlayerName)
{
#if defined fsRELEASE
	if (pPlayerName == mReleaseTesterName)
	{
		mUserSavedData->strSet(fsCUserSavedData::mCheatModeKey, "release");
	}
	else if (pPlayerName == mDevTesterName)
#endif
	{
		mUserSavedData->strSet(fsCUserSavedData::mCheatModeKey, "dev");
	}
}

void fsCProfileManager::settingsCache()
{
	if (savedDataGet()->numProfilesGet())
	{
		mMusicVol = mUserSavedData->f32Get(fsCUserSavedData::mMusicVolumeKey);
		mEffectsVol = mUserSavedData->f32Get(fsCUserSavedData::mEffectsVolumeKey);
		mMute = mUserSavedData->boolGet(fsCUserSavedData::mMuteAllKey);
		mCustomCursor = mUserSavedData->boolGet(fsCUserSavedData::mCustomCursorsKey);
		mFullScreen = mUserSavedData->boolGet(fsCUserSavedData::mFullScreenKey);
	}
}

void fsCProfileManager::initalUserSettingsApply() const
{
	mUserSavedData->resetForNewPlayer();
	mUserSavedData->strSet(fsCUserSavedData::mGameChapter, mInstance->chapterGet());

	if (mMusicVol)
	{
		mUserSavedData->f32Set(fsCUserSavedData::mMusicVolumeKey, mMusicVol);
		mUserSavedData->f32Set(fsCUserSavedData::mEffectsVolumeKey, mEffectsVol);
		mUserSavedData->boolSet(fsCUserSavedData::mMuteAllKey, mMute);
		mUserSavedData->boolSet(fsCUserSavedData::mCustomCursorsKey, mCustomCursor);
		mUserSavedData->boolSet(fsCUserSavedData::mFullScreenKey, mFullScreen);
	}
}

void fsCProfileManager::newProfileCreate(const fsStr& pPlayerName)
{
	userDataSave();

	settingsCache();

	const fsStr indexStr(mSavedData->numProfilesGet());
	mSavedData->strSet(fsCGlobalSavedData::mProfileNameKey + indexStr, pPlayerName);
	mSavedData->strSet(fsCGlobalSavedData::mProfileFileNameKey + indexStr, newUserFileNameGenerate());
	mSavedData->strSet(fsCGlobalSavedData::mProfileChapterKey + indexStr, chapterGet());

	initalUserSettingsApply();

	mSavedData->currentProfileIndexSet(mSavedData->numProfilesGet());
	mSavedData->numProfilesSet(mSavedData->numProfilesGet() + 1);

	cheatModeActivate(pPlayerName);

#if defined fsInAppPurchaseProcess
	currPlayerFreeLevelCountSet(pPlayerName);
#endif

	userDataSave();
	globalDataSave();

	settingsCache();

	fsCGuiMessageDispatcher::instanceGet()->messageDispatch(mProfileCreationCompleteMsg,
	                                                        fsIMessageDispatcher::mNullParam);
	fsCGuiMessageDispatcher::instanceGet()->messageDispatch(mProfilesHaveChangedMsg, fsIMessageDispatcher::mNullParam);
}

void fsCProfileManager::profileDelete(fsS32 pProfileIndex)
{
	settingsCache();

	fsIFile::fileDelete(mSavedData->profileFileNameGet(pProfileIndex));

	if (mSavedData->currentProfileIndexGet() == pProfileIndex)
	{
		mSavedData->currentProfileIndexSet(fsCGlobalSavedData::mNoProfileLoaded);
		mUserSavedData->resetToDefaults();
	}
	else if (mSavedData->currentProfileIndexGet() > pProfileIndex)
	{
		mSavedData->currentProfileIndexSet(mSavedData->currentProfileIndexGet() - 1);
	}

	mSavedData->numProfilesSet(mSavedData->numProfilesGet() - 1);

	while (pProfileIndex < mSavedData->numProfilesGet())
	{
		const fsStr myIndStr(pProfileIndex);
		const fsStr nextIndStr(pProfileIndex + 1);
		mSavedData->strSet(fsCGlobalSavedData::mProfileNameKey + myIndStr,
		                   mSavedData->strGet(fsCGlobalSavedData::mProfileNameKey + nextIndStr));
		mSavedData->strSet(fsCGlobalSavedData::mProfileFileNameKey + myIndStr,
		                   mSavedData->strGet(fsCGlobalSavedData::mProfileFileNameKey + nextIndStr));
		mSavedData->strSet(fsCGlobalSavedData::mProfileChapterKey + myIndStr,
		                   mSavedData->strGet(fsCGlobalSavedData::mProfileChapterKey + nextIndStr));
		mSavedData->s32Set(fsCGlobalSavedData::mProfileGameModeKey + myIndStr,
		                   mSavedData->s32GetWithDefault(fsCGlobalSavedData::mProfileGameModeKey + nextIndStr, 0));

		++pProfileIndex;
	}

	globalDataSave();

	fsCGuiMessageDispatcher::instanceGet()->messageDispatch(mProfilesHaveChangedMsg, fsIMessageDispatcher::mNullParam);
}

void fsCProfileManager::chapterProfileDelete(fsS32 pProfileIndex)
{
	profileDelete(chapterProfileIndexToGlobalIndex(pProfileIndex));
}

void fsCProfileManager::currentProfileLoad()
{
	profileLoad(mSavedData->currentProfileIndexGet());
}

void fsCProfileManager::profileLoad(fsS32 pProfileIndex)
{
	if (fsCGlobalSavedData::mNoProfileLoaded == pProfileIndex)
	{
		return;
	}

	if (!profileMatchesCurrentChapterGet(pProfileIndex))
	{
		mSavedData->currentProfileIndexSet(fsCGlobalSavedData::mNoProfileLoaded);
		mUserSavedData->resetToDefaults();
		globalDataSave();
		return;
	}

	userDataSave();

	mSavedData->currentProfileIndexSet(pProfileIndex);

	mUserSavedData->mEntries.clear();
	mUserSavedData->load(mSavedData->profileFileNameGet(pProfileIndex));

	globalDataSave();

	settingsApply();

#if defined fsInAppPurchaseProcess
	currPlayerFreeLevelCountSet(mSavedData->strGet(fsCGlobalSavedData::mProfileNameKey + pProfileIndex));
#endif
}

void fsCProfileManager::chapterProfileLoad(fsS32 pProfileIndex)
{
	profileLoad(chapterProfileIndexToGlobalIndex(pProfileIndex));
}

fsStr fsCProfileManager::newUserFileNameGenerate()
{
	fsStr newFileName;
	fsBool allGood = false;
	fsS32 newIndex = 0;

	while (!allGood)
	{
		allGood = true;

		newFileName = "user" + fsStr(newIndex++) + ".txt";
		for (fsS32 ind = 0; ind < mSavedData->numProfilesGet() && allGood; ++ind)
		{
			if (newFileName == mSavedData->strGet(fsCGlobalSavedData::mProfileFileNameKey + fsStr(ind)))
			{
				allGood = false;
			}
		}
	}
	return newFileName;
}

fsBool fsCProfileManager::isValidNameGet(const fsStr& pPotentialName)
{
	fsStr potentialNameLower = pPotentialName;
#if defined fsDownCaseFilename
	potentialNameLower.downcase();
#endif
	for (fsS32 profileInd = 0; profileInd < mSavedData->numProfilesGet(); ++profileInd)
	{
		if (!profileMatchesCurrentChapterGet(profileInd))
		{
			continue;
		}

		fsStr profileNameLower = mSavedData->profileNameGet(profileInd);
#if defined fsDownCaseFilename
		profileNameLower.downcase();
#endif
		if (potentialNameLower == profileNameLower)
		{
			return false;
		}
	}
	return true;
}

void fsCProfileManager::userDataSave() const
{
	const fsS32 idx = mSavedData->currentProfileIndexGet();
	if (fsCGlobalSavedData::mNoProfileLoaded != idx)
	{
		mSavedData->s32Set(fsCGlobalSavedData::mProfileGameModeKey + fsStr(idx),
		                   static_cast<fsS32>(mUserSavedData->difficultyGet()));
		mUserSavedData->save(mSavedData->profileFileNameGet(idx));
	}
}

void fsCProfileManager::globalDataSave() const
{
	mSavedData->save(mGlobalDataFileName);
}

void fsCProfileManager::settingsApply()
{
	fsIAudioManager::instanceGet()->musicVolumeSet(mUserSavedData->f32Get(fsCUserSavedData::mMusicVolumeKey));
	fsIAudioManager::instanceGet()->effectsVolumeSet(mUserSavedData->f32Get(fsCUserSavedData::mEffectsVolumeKey));
	fsIAudioManager::instanceGet()->globalVolumeSet(
		mUserSavedData->boolGet(fsCUserSavedData::mMuteAllKey) ? 0.0f : 1.0f);

	fsICursor::customCursorActiveSet(mUserSavedData->boolGet(fsCUserSavedData::mCustomCursorsKey));

	if (fsIDisplay::instanceGet())
	{
		fsIDisplay::instanceGet()->screenModeSet(
			mUserSavedData->boolGet(fsCUserSavedData::mFullScreenKey));
	}
}

void fsCProfileManager::initialise()
{
	mSavedData->load(mGlobalDataFileName);

#if defined fsInAppPurchaseProcess
	mNumFreeScenes = fsCAppCoreMain::instanceGet()->settingsGet()->s32GetWithDefault("inGameAdsInitialFreeLevels", 3);
#endif

	if (mSavedData->uniqueIDGet().emptyGet())
	{
		mSavedData->uniqueIDSet(fsCUniqueId::idCalculate(fsCAppCoreMain::instanceGet()->hardwareGet()->utcTimeGet()));
	}

	const fsS32 prevProfile = mSavedData->currentProfileIndexGet();
	if (fsCGlobalSavedData::mNoProfileLoaded == prevProfile)
	{
		settingsApply();
	}
	else
	{
		mSavedData->currentProfileIndexSet(fsCGlobalSavedData::mNoProfileLoaded);
		profileLoad(prevProfile);
	}
}

void fsCProfileManager::create(std::unique_ptr<fsCGlobalSavedData> pGlobalSavedData,
                               std::unique_ptr<fsCUserSavedData> pUserSavedData)
{
	fsTrace("fsCProfileManager::create");
	fsAssert(mInstance == nullptr, "Already created fsCProfileManager.\n");
	mInstance = new fsCProfileManager();

	mInstance->mSavedData = std::move(pGlobalSavedData);
	mInstance->mUserSavedData = std::move(pUserSavedData);

	mInstance->mSavedData->load(mInstance->mGlobalDataFileName);

	const fsS32 prevProfile = mInstance->mSavedData->currentProfileIndexGet();
	if (fsCGlobalSavedData::mNoProfileLoaded != prevProfile)
	{
		mInstance->mSavedData->currentProfileIndexSet(prevProfile);
		mInstance->mUserSavedData->load(mInstance->mSavedData->profileFileNameGet(prevProfile));
	}
}

fsCProfileManager* fsCProfileManager::instanceGet()
{
	return mInstance;
}

void fsCProfileManager::destroy()
{
	fsAssert(mInstance != nullptr, "Not created.\n");
	mInstance->allDataSave(false);
	delete mInstance;
	mInstance = nullptr;
}

fsCProfileManager::fsCProfileManager() :
	mGlobalDataFileName("global.txt", fsCResourceName::eRES_LOCATION_USER_SETTINGS),
#if defined fsInAppPurchaseProcess
	mNumFreeScenes(0),
	mCurrPlayerNumFreeScenes(0),
#endif
	mMusicVol(0),
	mEffectsVol(0),
	mMute(false),
	mCustomCursor(true),
	mFullScreen(true),
	mChapter("")
{
}

fsCProfileManager::~fsCProfileManager()
{
}