GameManager.cpp

#include "GameManager.h"

#include "i18n.h"
#include "iregistry.h"
#include "itextstream.h"
#include "ifiletypes.h"
#include "ifilesystem.h"
#include "settings/PreferenceSystem.h"
#include "ui/prefdialog/PrefDialog.h"
#include "ui/prefdialog/GameSetupDialog.h"

#include "os/file.h"
#include "os/dir.h"
#include "os/path.h"
#include "os/fs.h"
#include "string/trim.h"
#include "string/convert.h"
#include "string/replace.h"
#include "string/predicate.h"
#include "string/split.h"

#include "GameFileLoader.h"
#include "wxutil/dialog/MessageBox.h"
#include "modulesystem/StaticModule.h"
#include "modulesystem/ApplicationContextImpl.h"

#include <sigc++/bind.h>

#include <iostream>

namespace game
{

namespace
{
	const char* const GKEY_PREFAB_FOLDER = "/mapFormat/prefabFolder";
	const char* const GKEY_MAPS_FOLDER = "/mapFormat/mapFolder";
}

Manager::Manager()
{}

const std::string& Manager::getName() const
{
	static std::string _name(MODULE_GAMEMANAGER);
	return _name;
}

const StringSet& Manager::getDependencies() const 
{
	static StringSet _dependencies;

	if (_dependencies.empty()) 
	{
		_dependencies.insert(MODULE_XMLREGISTRY);
		_dependencies.insert(MODULE_PREFERENCESYSTEM);
		_dependencies.insert(MODULE_FILETYPES);
		_dependencies.insert(MODULE_VIRTUALFILESYSTEM);
		_dependencies.insert(MODULE_COMMANDSYSTEM);
	}

	return _dependencies;
}

void Manager::initialiseModule(const ApplicationContext& ctx)
{
	// Read command line parameters, these override any existing preference setting
	const ApplicationContext::ArgumentList& args = ctx.getCmdLineArgs();

	for (const std::string& arg : args)
	{
		if (string::istarts_with(arg, "fs_game="))
		{
			GlobalRegistry().set(RKEY_FS_GAME, arg.substr(8));
		}
		else if (string::istarts_with(arg, "fs_game_base="))
		{
			GlobalRegistry().set(RKEY_FS_GAME_BASE, arg.substr(13));
		}
	}

	GlobalCommandSystem().addCommand("ProjectSettings", std::bind(&Manager::showGameSetupDialog, this, std::placeholders::_1));

	initialise(ctx.getRuntimeDataPath());

	initEnginePath();
}

const std::string& Manager::getFSGame() const
{
	return GlobalRegistry().get(RKEY_FS_GAME);
}

const std::string& Manager::getFSGameBase() const 
{
	return GlobalRegistry().get(RKEY_FS_GAME_BASE);
}

const std::string& Manager::getModPath() const
{
	// Return the fs_game path if available
	return (!_config.modPath.empty()) ? _config.modPath : _config.modBasePath;
}

const std::string& Manager::getModBasePath() const
{
	return _config.modBasePath;
}

IGamePtr Manager::currentGame()
{
	if (_config.gameType.empty())
	{
		// No game type selected, bail out, the program will crash anyway on module load
		wxutil::Messagebox::ShowFatalError(_("GameManager: No game type selected, can't continue."), NULL);
	}

	return _games[_config.gameType];
}

const Manager::GameList& Manager::getSortedGameList()
{
	return _sortedGames;
}

void Manager::constructPreferences()
{
#if 0
	IPreferencePage& page = GetPreferenceSystem().getPage(_("Game"));

	ComboBoxValueList gameList;

	for (const IGamePtr& game : _sortedGames)
	{
		gameList.push_back(game->getKeyValue("name"));
	}

	page.appendCombo(_("Select a Game:"), RKEY_GAME_TYPE, gameList, true);
	page.appendPathEntry(_("Engine Path"), RKEY_ENGINE_PATH, true);
	page.appendEntry(_("Mod (fs_game)"), RKEY_FS_GAME);
	page.appendEntry(_("Mod Base (fs_game_base, optional)"), RKEY_FS_GAME_BASE);
#endif
}

void Manager::initialise(const std::string& appPath)
{
	// Scan the <applicationpath>/games folder for .game files
	loadGameFiles(appPath);

	if (_games.empty())
	{
		// No game types available, bail out, the program would crash anyway on
		// module load
		wxutil::Messagebox::ShowFatalError(
			_("GameManager: No valid game files found, can't continue."), nullptr
		);
	}

	// Add the settings widgets to the Preference Dialog, we might need it
	constructPreferences();

	// Find the user's selected game from the XML registry, and attempt to find
	// it in the set of available games.
	std::string gameType = GlobalRegistry().get(RKEY_GAME_TYPE);
	GameMap::iterator i = _games.find(gameType);

	if (gameType.empty() || i == _games.end())
   {
		// We have at least one game type available, select the first
		// Store the name of the only game into the Registry
		rMessage() << "No game selected, will choose the highest ranked one." << std::endl;

		if (_sortedGames.empty())
		{
			wxutil::Messagebox::ShowFatalError(
				"GameManager: Sorted game list is empty, can't continue.", nullptr
			);
		}

		GlobalRegistry().set(RKEY_GAME_TYPE, _sortedGames.front()->getKeyValue("name"));
	}

	// Load the value from the registry, there should be one selected at this point
	_config.gameType = GlobalRegistry().get(RKEY_GAME_TYPE);

	// The game type should be selected now
	if (!_config.gameType.empty())
    {
		rMessage() << "GameManager: Selected game type: " << _config.gameType << std::endl;
	}
	else 
	{
		// No game type selected, bail out, the program would crash anyway on module load
		wxutil::Messagebox::ShowFatalError(_("No game type selected."));
	}
}

std::string Manager::getUserEnginePath()
{
#if defined(POSIX)

    // First check for a local copy of the game tree, e.g. ~/.doom3
    std::string localGamePrefix = currentGame()->getKeyValue("prefix");
    if (!localGamePrefix.empty())
    {
        std::string homeDir = getenv("HOME");
        fs::path localPath = fs::path(homeDir) / localGamePrefix;

        if (fs::exists(localPath))
        {
            return os::standardPathWithSlash(localPath);
        }
    }

#endif

    // Otherwise (Windows, or no local mod path found) return the regular engine path
    return _config.enginePath;
}

void Manager::initEnginePath()
{
	// Try to retrieve a saved value for the game setup
	_config.loadFromRegistry();

	if (!settingsValid())
	{
		showGameSetupDialog(cmd::ArgumentList());
	}

	// Extract the fs_game / fs_game_base settings from the mod path
	std::string fsGame = os::getRelativePath(_config.modPath, _config.enginePath);
	string::trim_right(fsGame, "/");

	std::string fsGameBase = os::getRelativePath(_config.modBasePath, _config.enginePath);
	string::trim_right(fsGameBase, "/");

	registry::setValue(RKEY_FS_GAME, fsGame);
	registry::setValue(RKEY_FS_GAME_BASE, fsGameBase);

	// Register as observer, to get notified about future engine path changes
	observeKey(RKEY_ENGINE_PATH);
	observeKey(RKEY_FS_GAME);
	observeKey(RKEY_FS_GAME_BASE);

	// Force an update ((re-)initialises the VFS)
	updateEnginePath(true);

#if 0
	// Add the note to the preference page
	IPreferencePage& page = GetPreferenceSystem().getPage(_("Game"));
	page.appendLabel(_("<b>Note</b>: You will have to restart DarkRadiant\nfor the changes to take effect."));
#endif
}

void Manager::showGameSetupDialog(const cmd::ArgumentList& args)
{
	// Paths not valid, ask the user to select something
	ui::GameSetupDialog::Result result = ui::GameSetupDialog::Show(cmd::ArgumentList());

	if (!result.enginePath.empty())
	{
		_config.gameType = result.gameName;
		_config.enginePath = result.enginePath;
		_config.modBasePath = result.modBasePath;
		_config.modPath = result.modPath;

		_config.saveToRegistry();
	}
}

void Manager::observeKey(const std::string& key)
{
    // Hide std::string signal argument, replace with bound false value for
    // updateEnginePath().
	GlobalRegistry().signalForKey(key).connect(
        sigc::bind(sigc::mem_fun(this, &Manager::updateEnginePath), false)
    );
}

bool Manager::settingsValid() const
{
	if (os::fileOrDirExists(_config.enginePath)) 
	{
		// Check the mod base path, if appropriate
		if (!_config.modBasePath.empty() && !os::fileOrDirExists(_config.modBasePath))
		{
			// Mod base name is not empty, but folder doesnt' exist
			return false;
		}

		// Check the mod path, if appropriate
		if (!_config.modPath.empty() && !os::fileOrDirExists(_config.modPath))
		{
			// Mod name is not empty, but mod folder doesnt' exist
			return false;
		}

		return true; // all settings there
	}

	// Engine path doesn't exist
	return false;
}

void Manager::setMapAndPrefabPaths(const std::string& baseGamePath)
{
   // Construct the map path and make sure the folder exists
   std::string mapPath;

   // Get the maps folder (e.g. "maps/")
   std::string mapFolder = currentGame()->getLocalXPath(GKEY_MAPS_FOLDER)[0].getAttributeValue("value");
   if (mapFolder.empty()) {
      mapFolder = "maps/";
   }

   if (_config.modPath.empty() && _config.modBasePath.empty()) 
   {
      mapPath = baseGamePath + mapFolder;
   }
   else if (!_config.modPath.empty())
   {
      mapPath = _config.modPath + mapFolder;
   }
   else // _config.modBasePath is not empty
   { 
      mapPath = _config.modBasePath + mapFolder;
   }

   rMessage() << "GameManager: Map path set to " << mapPath << std::endl;
   os::makeDirectory(mapPath);

   // Save the map path to the registry
   GlobalRegistry().set(RKEY_MAP_PATH, mapPath);

   // Setup the prefab path
   std::string prefabPath = mapPath;
   std::string pfbFolder = currentGame()->getLocalXPath(GKEY_PREFAB_FOLDER)[0].getAttributeValue("value");

   // Replace the "maps/" with "prefabs/"
   string::replace_last(prefabPath, mapFolder, pfbFolder);
   // Store the path into the registry
   rMessage() << "GameManager: Prefab path set to " << prefabPath << std::endl;
   GlobalRegistry().set(RKEY_PREFAB_PATH, prefabPath);
}

void Manager::updateEnginePath(bool forced)
{
	// Clean the new path
	std::string newEnginePath = os::standardPathWithSlash(registry::getValue<std::string>(RKEY_ENGINE_PATH));
	std::string newModPath = os::standardPathWithSlash(registry::getValue<std::string>(RKEY_MOD_PATH));
	std::string newModBasePath = os::standardPathWithSlash(registry::getValue<std::string>(RKEY_MOD_BASE_PATH));

	// Only update if any settings were changed, or if this is a "forced" update
	if (forced || newEnginePath != _config.enginePath || newModPath != _config.modPath || newModBasePath != _config.modBasePath)
	{
		// The list of paths which will be passed to the VFS init method
		vfs::SearchPaths vfsSearchPaths;

		vfs::VirtualFileSystem::ExtensionSet extensions;
		string::split(extensions, currentGame()->getKeyValue("archivetypes"), " ");

		// Set the new mod and engine paths
		_config.modPath = newModPath;
		_config.modBasePath = newModBasePath;
		_config.enginePath = newEnginePath;

		if (!_config.modPath.empty())
		{
			// We have a MOD, register this directory first
			vfsSearchPaths.insertIfNotExists(_config.modPath);

#ifdef POSIX
			std::string fsGame = os::getRelativePath(_config.modPath, _config.enginePath);

			// On Linux, the above was in ~/.doom3/, search the engine mod path as well
			std::string baseModPath = os::standardPathWithSlash(_config.enginePath + fsGame);
			vfsSearchPaths.insertIfNotExists(baseModPath);
#endif
		}

		if (!_config.modBasePath.empty())
		{
			// We have a MOD base, register this directory as second
			vfsSearchPaths.insertIfNotExists(_config.modBasePath);

#ifdef POSIX
			std::string fsGameBase = os::getRelativePath(_config.modBasePath, _config.enginePath);

			// On Linux, the above was in ~/.doom3/, search the engine mod base path as well
			std::string baseModPath = os::standardPathWithSlash(_config.enginePath + fsGameBase);
			vfsSearchPaths.insertIfNotExists(baseModPath);
#endif
		}

		// On UNIX this is the user-local enginepath, e.g. ~/.doom3/base/
		// On Windows this will be the same as global engine path
		std::string userBasePath = os::standardPathWithSlash(
			getUserEnginePath() + // ~/.doom3
			currentGame()->getKeyValue("basegame") // base
		);
		vfsSearchPaths.insertIfNotExists(userBasePath);

		// Register the base game folder (/usr/local/games/doom3/<basegame>) last
		// This will always be searched, but *after* the other paths
		std::string baseGame = os::standardPathWithSlash(
			_config.enginePath + currentGame()->getKeyValue("basegame")
		);
		vfsSearchPaths.insertIfNotExists(baseGame);

		// Update map and prefab paths
		setMapAndPrefabPaths(userBasePath);

		// Initialise the filesystem, if we were initialised before
		GlobalFileSystem().initialise(vfsSearchPaths, extensions);
	}
}

const Manager::PathList& Manager::getVFSSearchPaths() const 
{
	return GlobalFileSystem().getVfsSearchPaths();
}

const std::string& Manager::getEnginePath() const {
	return _config.enginePath;
}

void Manager::loadGameFiles(const std::string& appPath)
{
	std::string gamePath = appPath + "games/";
	rMessage() << "GameManager: Scanning for game description files: " << gamePath << std::endl;

	// Invoke a GameFileLoader functor on every file in the games/ dir.
	GameFileLoader gameFileLoader(_games, gamePath);
    
    try
    {
        os::foreachItemInDirectory(gamePath, gameFileLoader);

        rMessage() << "GameManager: Found game definitions: " << std::endl;

        for (GameMap::value_type& pair : _games)
        {
            rMessage() << "  " << pair.first << std::endl;
        }

		// Populate the sorted games list
		_sortedGames.clear();
		
		// Sort the games by their index
		std::multimap<int, GamePtr> sortedGameMap;

		for (const GameMap::value_type& pair : _games)
		{
			int index = string::convert<int>(pair.second->getKeyValue("index"), 9999);
			sortedGameMap.insert(std::make_pair(index, pair.second));
		}

		for (const auto& pair : sortedGameMap)
		{
			_sortedGames.push_back(pair.second);
		}

        rMessage() << std::endl;
    }
    catch (os::DirectoryNotFoundException&)
    {
        rError() << "Could not find directory with game files in " << gamePath << std::endl;
    }
}

} // namespace game

// The static module definition (self-registers)
module::StaticModule<game::Manager> gameManagerModule;