/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#define FORBIDDEN_SYMBOL_ALLOW_ALL

#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#undef ARRAYSIZE // winnt.h defines ARRAYSIZE, but we want our own one...
#endif

#include "backends/platform/sdl/sdl.h"
#include "common/config-manager.h"
#include "gui/EventRecorder.h"
#include "common/taskbar.h"
#include "common/textconsole.h"

#include "backends/saves/default/default-saves.h"

// Audio CD support was removed with SDL 2.0
#if SDL_VERSION_ATLEAST(2, 0, 0)
#include "backends/audiocd/default/default-audiocd.h"
#else
#include "backends/audiocd/sdl/sdl-audiocd.h"
#endif

#include "backends/events/sdl/sdl-events.h"
#include "backends/mutex/sdl/sdl-mutex.h"
#include "backends/timer/sdl/sdl-timer.h"
#include "backends/timer/default/default-timer.h"	// __VMS: plain, untriggered manager
#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
#ifdef KYRA_STANDALONE
#include "backends/mixer/nullmixer/nullsdl-mixer.h"
#endif
#ifdef USE_OPENGL
#include "backends/graphics/openglsdl/openglsdl-graphics.h"
#include "graphics/cursorman.h"
#endif

#include <time.h>	// for getTimeAndDate()
#if defined(__VMS)
#include <sys/time.h>	// for gettimeofday() in getMillis() - see the note there
#endif

#ifdef USE_DETECTLANG
#ifndef WIN32
#include <locale.h>
#endif // !WIN32
#endif

OSystem_SDL::OSystem_SDL()
	:
#ifdef USE_OPENGL
	_desktopWidth(0),
	_desktopHeight(0),
	_graphicsModes(),
	_graphicsMode(0),
	_firstGLMode(0),
	_defaultSDLMode(0),
	_defaultGLMode(0),
#endif
	_inited(false),
	_initedSDL(false),
	_logger(0),
	_mixerManager(0),
	_eventSource(0),
	_window(0) {

}

OSystem_SDL::~OSystem_SDL() {
	SDL_ShowCursor(SDL_ENABLE);

#if defined(__VMS)
	// OpenVMS PORT FIX - kill the timer manager FIRST.
	//
	// Upstream deletes it near the END of this destructor (see below), which is
	// backwards: SdlTimerManager's destructor is the only thing that calls
	// SDL_RemoveTimer, so with the upstream order the 10ms timer callback is
	// STILL LIVE while _savefileManager, _graphicsManager, _window, _eventManager,
	// _eventSource, _audiocdManager and _mixerManager are being destroyed
	// underneath it - and that callback re-enters this object
	// (g_system->getMillis(), g_system->lockMutex()).  quit() is
	// "delete this; exit(0)", so this runs on EVERY normal exit; a timer thread
	// looping inside a half-destroyed OSystem_SDL is a direct explanation for
	// "Exit to DOS" never returning to DCL.
	//
	// initBackend() now installs a plain DefaultTimerManager (no thread), so this
	// is belt-and-braces, but the ordering is wrong on its own merits and must
	// stay correct if the SDL manager is ever restored.  Deleting early is safe:
	// nothing destroyed below uses the timer manager.
	//
	// ENABLE_EVENTRECORDER is defined here, so the manager is owned by the
	// recorder, NOT by _timerManager (which stays NULL) - hence the same call the
	// upstream #ifdef makes below.  It is then NULLed so the later
	// "delete g_eventRec.getTimerManager()" is a no-op double-delete guard rather
	// than an actual double delete.  ~EventRecorder also deletes it, and that too
	// is guarded by the NULL.
#ifdef ENABLE_EVENTRECORDER
	delete g_eventRec.getTimerManager();
	g_eventRec.registerTimerManager(0);
#else
	delete _timerManager;
	_timerManager = 0;
#endif
#endif

	// Delete the various managers here. Note that the ModularBackend
	// destructor would also take care of this for us. However, various
	// of our managers must be deleted *before* we call SDL_Quit().
	// Hence, we perform the destruction on our own.
	delete _savefileManager;
	_savefileManager = 0;
	if (_graphicsManager) {
		dynamic_cast<SdlGraphicsManager *>(_graphicsManager)->deactivateManager();
	}
	delete _graphicsManager;
	_graphicsManager = 0;
	delete _window;
	_window = 0;
	delete _eventManager;
	_eventManager = 0;
	delete _eventSource;
	_eventSource = 0;
	delete _audiocdManager;
	_audiocdManager = 0;
	delete _mixerManager;
	_mixerManager = 0;

#ifdef ENABLE_EVENTRECORDER
	// HACK HACK HACK
	// This is nasty.
	delete g_eventRec.getTimerManager();
#else
	delete _timerManager;
#endif

	_timerManager = 0;
	delete _mutexManager;
	_mutexManager = 0;

	delete _logger;
	_logger = 0;

	SDL_Quit();
}

void OSystem_SDL::init() {
	// Initialize SDL
	initSDL();

#if !SDL_VERSION_ATLEAST(2, 0, 0)
	// Enable unicode support if possible
	SDL_EnableUNICODE(1);
#endif

	// Disable OS cursor
	SDL_ShowCursor(SDL_DISABLE);

	if (!_logger)
		_logger = new Backends::Log::Log(this);

	if (_logger) {
		Common::WriteStream *logFile = createLogFile();
		if (logFile)
			_logger->open(logFile);
	}


	// Creates the early needed managers, if they don't exist yet
	// (we check for this to allow subclasses to provide their own).
	if (_mutexManager == 0)
		_mutexManager = new SdlMutexManager();

	if (_window == 0)
		_window = new SdlWindow();

#if defined(USE_TASKBAR)
	if (_taskbarManager == 0)
		_taskbarManager = new Common::TaskbarManager();
#endif

}

void OSystem_SDL::initBackend() {
	// Check if backend has not been initialized
	assert(!_inited);

#if SDL_VERSION_ATLEAST(2, 0, 0)
	const char *sdlDriverName = SDL_GetCurrentVideoDriver();
#else
	const int maxNameLen = 20;
	char sdlDriverName[maxNameLen];
	sdlDriverName[0] = '\0';
	SDL_VideoDriverName(sdlDriverName, maxNameLen);
#endif
	// Using printf rather than debug() here as debug()/logging
	// is not active by this point.
	debug(1, "Using SDL Video Driver \"%s\"", sdlDriverName);

	// Create the default event source, in case a custom backend
	// manager didn't provide one yet.
	if (_eventSource == 0)
		_eventSource = new SdlEventSource();

#ifdef USE_OPENGL
#if SDL_VERSION_ATLEAST(2, 0, 0)
	SDL_DisplayMode displayMode;
	if (!SDL_GetDesktopDisplayMode(0, &displayMode)) {
		_desktopWidth  = displayMode.w;
		_desktopHeight = displayMode.h;
	}
#else
	// Query the desktop resolution. We simply hope nothing tried to change
	// the resolution so far.
	const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
	if (videoInfo && videoInfo->current_w > 0 && videoInfo->current_h > 0) {
		_desktopWidth  = videoInfo->current_w;
		_desktopHeight = videoInfo->current_h;
	}
#endif
#endif

	if (_graphicsManager == 0) {
#ifdef USE_OPENGL
		// Setup a list with both SDL and OpenGL graphics modes. We only do
		// this whenever the subclass did not already set up an graphics
		// manager yet. This is because we don't know the type of the graphics
		// manager of the subclass, thus we cannot easily switch between the
		// OpenGL one and the set up one. It also is to be expected that the
		// subclass does not want any switching of graphics managers anyway.
		setupGraphicsModes();

		if (ConfMan.hasKey("gfx_mode")) {
			// If the gfx_mode is from OpenGL, create the OpenGL graphics manager
			Common::String gfxMode(ConfMan.get("gfx_mode"));
			for (uint i = _firstGLMode; i < _graphicsModeIds.size(); ++i) {
				if (!scumm_stricmp(_graphicsModes[i].name, gfxMode.c_str())) {
					_graphicsManager = new OpenGLSdlGraphicsManager(_desktopWidth, _desktopHeight, _eventSource, _window);
					_graphicsMode = i;
					break;
				}
			}
		}
#endif

		if (_graphicsManager == 0) {
			_graphicsManager = new SurfaceSdlGraphicsManager(_eventSource, _window);
		}
	}

	if (_savefileManager == 0)
		_savefileManager = new DefaultSaveFileManager();

	if (_mixerManager == 0) {
#ifdef KYRA_STANDALONE
		// Standalone Kyra loader: no sound support. Use the null mixer so no
		// SDL audio device is opened (matches the FreeSCI/Sarien OpenVMS ports).
		_mixerManager = new NullSdlMixerManager();
#else
		_mixerManager = new SdlMixerManager();
#endif
		// Setup and start mixer
		_mixerManager->init();
	}

#ifdef ENABLE_EVENTRECORDER
	g_eventRec.registerMixerManager(_mixerManager);

	// OpenVMS PORT FIX - do NOT start the SDL timer THREAD in this build.
	// NOTE: ENABLE_EVENTRECORDER *IS* DEFINED HERE (config.h:44), so THIS is the
	// live branch, and the #else below is dead code.  Do not "fix" the #else and
	// expect any effect.
	//
	// SdlTimerManager's only job is to call DefaultTimerManager::handler() from an
	// SDL_AddTimer(10ms) callback, which SDL 1.2 runs on a SEPARATE thread (hence
	// the PTHREAD$RTL frames at the foot of every traceback).  That handler does
	// two things from that thread:
	//     g_system->getMillis(true)      -> SDL_GetTicks()
	//     Common::StackLock lock(_mutex) -> g_system->lockMutex()
	// i.e. it re-enters OSystem_SDL concurrently with the main thread, which calls
	// getMillis() continuously from every runLoop.  Nothing in this build needs
	// it: the ONLY installTimerProc() callers in the whole tree are
	// audio/fmopl.cpp (RealOPL - hardware OPL, never selected: the OPL factory
	// returns MAME/DOSBox EmulatedOPL, which is driven by the mixer, not the
	// timer), audio/mpu401.cpp (reached only via a MidiDriver, and no MidiDriver
	// is ever built here: eobcommon.cpp:386 hardwires SoundAdLibPC, and for
	// LoK/HoF/MR/LoL detectDevice() falls through to MT_ADLIB because
	// mt32_device/gm_device both default to "null" (commandLine.cpp:221), so
	// kyra_v1.cpp takes the SoundAdLibPC branch too) and audio/softsynth/mt32.cpp
	// (USE_MT32EMU is undefined in config.h, so that whole TU compiles away).  So
	// the TimerSlot queue is ALWAYS empty and the callback is pure overhead - it
	// walks an empty list 100x/sec while touching shared state.
	//
	// A plain DefaultTimerManager is a complete, valid TimerManager on its own:
	// installTimerProc() still works, the slots just never fire (already the case
	// here, as there are none), and it satisfies initBackend()'s "Backend failed
	// to instantiate timer manager" check - which under ENABLE_EVENTRECORDER goes
	// through OSystem_SDL::getTimerManager() -> g_eventRec.getTimerManager(), so
	// the recorder's pointer is the one that must be non-NULL, not _timerManager.
	// Removing the thread removes both an unsynchronised concurrent reader of
	// SDL's tick state (the intermittent ACCVIO whose traceback is
	//     SDL_GetTicks <- getMillis <- [updateWallOfForceTimers <-] runLoop
	// with a nonsense PC: 0x4C, 0x20000000, 0x0) and a callback that keeps
	// running during teardown - see the destructor note above.
#if defined(__VMS)
	g_eventRec.registerTimerManager(new DefaultTimerManager());
#else
	g_eventRec.registerTimerManager(new SdlTimerManager());
#endif
#else
	if (_timerManager == 0)
		_timerManager = new SdlTimerManager();
#endif

	if (_audiocdManager == 0) {
		// Audio CD support was removed with SDL 2.0
#if SDL_VERSION_ATLEAST(2, 0, 0)
		_audiocdManager = new DefaultAudioCDManager();
#else
		_audiocdManager = new SdlAudioCDManager();
#endif

	}

	// Setup a custom program icon.
	_window->setupIcon();

	_inited = true;

	ModularBackend::initBackend();

	// We have to initialize the graphics manager before the event manager
	// so the virtual keyboard can be initialized, but we have to add the
	// graphics manager as an event observer after initializing the event
	// manager.
	dynamic_cast<SdlGraphicsManager *>(_graphicsManager)->activateManager();
}

#if defined(USE_TASKBAR)
void OSystem_SDL::engineInit() {
	// Add the started engine to the list of recent tasks
	_taskbarManager->addRecent(ConfMan.getActiveDomainName(), ConfMan.get("description"));

	// Set the overlay icon the current running engine
	_taskbarManager->setOverlayIcon(ConfMan.getActiveDomainName(), ConfMan.get("description"));
}

void OSystem_SDL::engineDone() {
	// Remove overlay icon
	_taskbarManager->setOverlayIcon("", "");
}
#endif

void OSystem_SDL::initSDL() {
	// Check if SDL has not been initialized
	if (!_initedSDL) {
		// We always initialize the video subsystem because we will need it to
		// be initialized before the graphics managers to retrieve the desktop
		// resolution, for example. WebOS also requires this initialization
		// or otherwise the application won't start.
		uint32 sdlFlags = SDL_INIT_VIDEO;

		// OpenVMS PORT NOTE - DO NOT ADD SDL_INIT_TIMER HERE.
		//
		// An earlier revision of this port did exactly that, on the theory that
		// SDL_GetTicks() needs the TIMER subsystem initialised.  That theory was
		// WRONG and the change was actively harmful.  Read
		// LIBSDL:[SRC.TIMER.UNIX]SDL_systimer.c: this SDL is built with
		// SDL_TIMER_UNIX and *without* SDL_THREADS_DISABLED, so USE_ITIMER is NOT
		// defined and SDL_SYS_TimerInit() takes the threaded branch:
		//     timer_alive = 1;
		//     timer = SDL_CreateThread(RunTimer, NULL);
		// where RunTimer is "while (timer_alive) { if (SDL_timer_running)
		// SDL_ThreadedTimerCheck(); SDL_Delay(1); }".  So requesting SDL_INIT_TIMER
		// SPAWNS A THREAD that wakes ~1000 times a second, and SDL_ThreadedTimerCheck()
		// calls SDL_GetTicks() -> gettimeofday() from that thread while the main
		// thread calls getMillis() -> SDL_GetTicks() -> gettimeofday() continuously.
		//
		// That is why removing SdlTimerManager (see initBackend) did not stop the
		// crashes: the two changes cancelled out.  Upstream only ever initialises
		// the TIMER subsystem from SdlTimerManager's constructor, so dropping that
		// manager while ADDING this flag left the SDL timer thread running anyway.
		// With both gone, no SDL timer thread is created at all.
		//
		// getMillis() below no longer calls SDL_GetTicks(), so nothing in this build
		// needs the TIMER subsystem.

		if (ConfMan.hasKey("disable_sdl_parachute"))
			sdlFlags |= SDL_INIT_NOPARACHUTE;

		// Initialize SDL (SDL Subsystems are initiliazed in the corresponding sdl managers)
		if (SDL_Init(sdlFlags) == -1)
			error("Could not initialize SDL: %s", SDL_GetError());

		_initedSDL = true;
	}
}

void OSystem_SDL::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {

#ifdef DATA_PATH
	// Add the global DATA_PATH to the directory search list
	// FIXME: We use depth = 4 for now, to match the old code. May want to change that
	Common::FSNode dataNode(DATA_PATH);
	if (dataNode.exists() && dataNode.isDirectory()) {
		s.add(DATA_PATH, new Common::FSDirectory(dataNode, 4), priority);
	}
#endif

}

void OSystem_SDL::setWindowCaption(const char *caption) {
	Common::String cap;
	byte c;

	// The string caption is supposed to be in LATIN-1 encoding.
	// SDL expects UTF-8. So we perform the conversion here.
	while ((c = *(const byte *)caption++)) {
		if (c < 0x80)
			cap += c;
		else {
			cap += 0xC0 | (c >> 6);
			cap += 0x80 | (c & 0x3F);
		}
	}

	_window->setWindowCaption(cap);
}

void OSystem_SDL::quit() {
	delete this;
	exit(0);
}

void OSystem_SDL::fatalError() {
	delete this;
	exit(1);
}


void OSystem_SDL::logMessage(LogMessageType::Type type, const char *message) {
	// First log to stdout/stderr
	FILE *output = 0;

	if (type == LogMessageType::kInfo || type == LogMessageType::kDebug)
		output = stdout;
	else
		output = stderr;

	fputs(message, output);
	fflush(output);

	// Then log into file (via the logger)
	if (_logger)
		_logger->print(message);

	// Finally, some Windows / WinCE specific logging code.
#if defined( USE_WINDBG )
#if defined( _WIN32_WCE )
	TCHAR buf_unicode[1024];
	MultiByteToWideChar(CP_ACP, 0, message, strlen(message) + 1, buf_unicode, sizeof(buf_unicode));
	OutputDebugString(buf_unicode);

	if (type == LogMessageType::kError) {
#ifndef DEBUG
		drawError(message);
#else
		int cmon_break_into_the_debugger_if_you_please = *(int *)(message + 1);	// bus error
		printf("%d", cmon_break_into_the_debugger_if_you_please);			// don't optimize the int out
#endif
	}

#else
	OutputDebugString(message);
#endif
#endif
}

Common::String OSystem_SDL::getSystemLanguage() const {
#if defined(USE_DETECTLANG) && !defined(_WIN32_WCE)
#ifdef WIN32
	// We can not use "setlocale" (at least not for MSVC builds), since it
	// will return locales like: "English_USA.1252", thus we need a special
	// way to determine the locale string for Win32.
	char langName[9];
	char ctryName[9];

	const LCID languageIdentifier = GetThreadLocale();

	if (GetLocaleInfo(languageIdentifier, LOCALE_SISO639LANGNAME, langName, sizeof(langName)) != 0 &&
		GetLocaleInfo(languageIdentifier, LOCALE_SISO3166CTRYNAME, ctryName, sizeof(ctryName)) != 0) {
		Common::String localeName = langName;
		localeName += "_";
		localeName += ctryName;

		return localeName;
	} else {
		return ModularBackend::getSystemLanguage();
	}
#else // WIN32
	// Activating current locale settings
	const Common::String locale = setlocale(LC_ALL, "");

	// Restore default C locale to prevent issues with
	// portability of sscanf(), atof(), etc.
	// See bug #3615148
	setlocale(LC_ALL, "C");

	// Detect the language from the locale
	if (locale.empty()) {
		return ModularBackend::getSystemLanguage();
	} else {
		int length = 0;

		// Strip out additional information, like
		// ".UTF-8" or the like. We do this, since
		// our translation languages are usually
		// specified without any charset information.
		for (int size = locale.size(); length < size; ++length) {
			// TODO: Check whether "@" should really be checked
			// here.
			if (locale[length] == '.' || locale[length] == ' ' || locale[length] == '@')
				break;
		}

		return Common::String(locale.c_str(), length);
	}
#endif // WIN32
#else // USE_DETECTLANG
	return ModularBackend::getSystemLanguage();
#endif // USE_DETECTLANG
}

uint32 OSystem_SDL::getMillis(bool skipRecord) {
#if defined(__VMS)
	// OpenVMS PORT FIX - read the clock DIRECTLY instead of via SDL_GetTicks().
	//
	// This is the hottest call in the program (every runLoop, every TIM script
	// step, every wait loop) and it was the innermost named frame in EVERY crash
	// dump from this port:
	//     PC=0x4C / 0x0 / 0x20000000 / 0x7ADD80A0   (four different bogus PCs)
	//     DECC$SHR_EV56                    ?  ?
	//     sdl_systimer  SDL_GetTicks  +0x54
	//     sdl           getMillis
	//     <varying: runLoop / updateWallOfForceTimers / kyra timer update>
	// The game, engine and call site all varied; those two frames never did.
	//
	// LIBSDL:[SRC.TIMER.UNIX]SDL_systimer.c shows SDL_GetTicks() is a thin wrapper
	// that calls gettimeofday() (HAVE_CLOCK_GETTIME is undefined) and subtracts a
	// file-static "start" timeval saved by SDL_StartTicks().  +0x54 is that
	// gettimeofday() call - hence the unresolvable DECC$SHR frame beneath it.
	// Calling gettimeofday() ourselves does the identical work with identical
	// semantics (ms since first call, wrapping at 2^32 exactly as SDL's uint32
	// does), minus SDL's static and minus that cross-image call.
	//
	// This is the same idiom the sibling OpenVMS ports use for their clock
	// (freesci/src/scicore/tools.c, sarien/src/graphics/x11/x11.c), and it is
	// deliberately NOT sys$gettim: gettimeofday() is plain C RTL, needs no
	// starlet.h or 64-bit VMS-time conversion, and keeps this file portable.
	static bool haveStart = false;
	static struct timeval start;
	struct timeval now;

	gettimeofday(&now, NULL);
	if (!haveStart) {
		start = now;
		haveStart = true;
	}
	uint32 millis = (uint32)((now.tv_sec - start.tv_sec) * 1000 +
	                        (now.tv_usec - start.tv_usec) / 1000);
#else
	uint32 millis = SDL_GetTicks();
#endif

#ifdef ENABLE_EVENTRECORDER
	g_eventRec.processMillis(millis, skipRecord);
#endif

	return millis;
}

void OSystem_SDL::delayMillis(uint msecs) {
#ifdef ENABLE_EVENTRECORDER
	if (!g_eventRec.processDelayMillis())
#endif
		SDL_Delay(msecs);
}

void OSystem_SDL::getTimeAndDate(TimeDate &td) const {
	time_t curTime = time(0);
	struct tm t = *localtime(&curTime);
	td.tm_sec = t.tm_sec;
	td.tm_min = t.tm_min;
	td.tm_hour = t.tm_hour;
	td.tm_mday = t.tm_mday;
	td.tm_mon = t.tm_mon;
	td.tm_year = t.tm_year;
	td.tm_wday = t.tm_wday;
}

Audio::Mixer *OSystem_SDL::getMixer() {
	assert(_mixerManager);
	return getMixerManager()->getMixer();
}

SdlMixerManager *OSystem_SDL::getMixerManager() {
	assert(_mixerManager);

#ifdef ENABLE_EVENTRECORDER
	return g_eventRec.getMixerManager();
#else
	return _mixerManager;
#endif
}

Common::TimerManager *OSystem_SDL::getTimerManager() {
#ifdef ENABLE_EVENTRECORDER
	return g_eventRec.getTimerManager();
#else
	return _timerManager;
#endif
}

#ifdef USE_OPENGL

const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
	if (_graphicsModes.empty()) {
		return _graphicsManager->getSupportedGraphicsModes();
	} else {
		return _graphicsModes.begin();
	}
}

int OSystem_SDL::getDefaultGraphicsMode() const {
	if (_graphicsModes.empty()) {
		return _graphicsManager->getDefaultGraphicsMode();
	} else {
		// Return the default graphics mode from the current graphics manager
		if (_graphicsMode < _firstGLMode)
			return _defaultSDLMode;
		else
			return _defaultGLMode;
	}
}

bool OSystem_SDL::setGraphicsMode(int mode) {
	if (_graphicsModes.empty()) {
		return _graphicsManager->setGraphicsMode(mode);
	}

	// Check whether a invalid mode is requested.
	if (mode < 0 || (uint)mode >= _graphicsModeIds.size()) {
		return false;
	}

	// Very hacky way to set up the old graphics manager state, in case we
	// switch from SDL->OpenGL or OpenGL->SDL.
	//
	// This is a probably temporary workaround to fix bugs like #3368143
	// "SDL/OpenGL: Crash when switching renderer backend".
	SdlGraphicsManager *sdlGraphicsManager = dynamic_cast<SdlGraphicsManager *>(_graphicsManager);
	SdlGraphicsManager::State state = sdlGraphicsManager->getState();

	bool switchedManager = false;

	// If the new mode and the current mode are not from the same graphics
	// manager, delete and create the new mode graphics manager
	if (_graphicsMode >= _firstGLMode && mode < _firstGLMode) {
		debug(1, "switching to plain SDL graphics");
		sdlGraphicsManager->deactivateManager();
		delete _graphicsManager;
		_graphicsManager = sdlGraphicsManager = new SurfaceSdlGraphicsManager(_eventSource, _window);

		switchedManager = true;
	} else if (_graphicsMode < _firstGLMode && mode >= _firstGLMode) {
		debug(1, "switching to OpenGL graphics");
		sdlGraphicsManager->deactivateManager();
		delete _graphicsManager;
		_graphicsManager = sdlGraphicsManager = new OpenGLSdlGraphicsManager(_desktopWidth, _desktopHeight, _eventSource, _window);

		switchedManager = true;
	}

	_graphicsMode = mode;

	if (switchedManager) {
		sdlGraphicsManager->activateManager();

		// This failing will probably have bad consequences...
		if (!sdlGraphicsManager->setState(state)) {
			return false;
		}

		// Next setup the cursor again
		CursorMan.pushCursor(0, 0, 0, 0, 0, 0);
		CursorMan.popCursor();

		// Next setup cursor palette if needed
		if (_graphicsManager->getFeatureState(kFeatureCursorPalette)) {
			CursorMan.pushCursorPalette(0, 0, 0);
			CursorMan.popCursorPalette();
		}

		_graphicsManager->beginGFXTransaction();
		// Oh my god if this failed the client code might just explode.
		return _graphicsManager->setGraphicsMode(_graphicsModeIds[mode]);
	} else {
		return _graphicsManager->setGraphicsMode(_graphicsModeIds[mode]);
	}
}

int OSystem_SDL::getGraphicsMode() const {
	if (_graphicsModes.empty()) {
		return _graphicsManager->getGraphicsMode();
	} else {
		return _graphicsMode;
	}
}

void OSystem_SDL::setupGraphicsModes() {
	_graphicsModes.clear();
	_graphicsModeIds.clear();
	_defaultSDLMode = _defaultGLMode = -1;

	// Count the number of graphics modes
	const OSystem::GraphicsMode *srcMode;
	int defaultMode;

	GraphicsManager *manager = new SurfaceSdlGraphicsManager(_eventSource, _window);
	srcMode = manager->getSupportedGraphicsModes();
	defaultMode = manager->getDefaultGraphicsMode();
	while (srcMode->name) {
		if (defaultMode == srcMode->id) {
			_defaultSDLMode = _graphicsModes.size();
		}
		_graphicsModes.push_back(*srcMode);
		srcMode++;
	}
	delete manager;
	assert(_defaultSDLMode != -1);

	_firstGLMode = _graphicsModes.size();
	manager = new OpenGLSdlGraphicsManager(_desktopWidth, _desktopHeight, _eventSource, _window);
	srcMode = manager->getSupportedGraphicsModes();
	defaultMode = manager->getDefaultGraphicsMode();
	while (srcMode->name) {
		if (defaultMode == srcMode->id) {
			_defaultGLMode = _graphicsModes.size();
		}
		_graphicsModes.push_back(*srcMode);
		srcMode++;
	}
	delete manager;
	manager = nullptr;
	assert(_defaultGLMode != -1);

	// Set a null mode at the end
	GraphicsMode nullMode;
	memset(&nullMode, 0, sizeof(nullMode));
	_graphicsModes.push_back(nullMode);

	// Set new internal ids for all modes
	int i = 0;
	OSystem::GraphicsMode *mode = _graphicsModes.begin();
	while (mode->name) {
		_graphicsModeIds.push_back(mode->id);
		mode->id = i++;
		mode++;
	}
}
#endif

#if SDL_VERSION_ATLEAST(2, 0, 0)
int SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors) {
	if (surface->format->palette) {
		return !SDL_SetPaletteColors(surface->format->palette, colors, firstcolor, ncolors) ? 1 : 0;
	} else {
		return 0;
	}
}

int SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha) {
	if (SDL_SetSurfaceAlphaMod(surface, alpha)) {
		return -1;
	}

	if (alpha == 255 || !flag) {
		if (SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_NONE)) {
			return -1;
		}
	} else {
		if (SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)) {
			return -1;
		}
	}

	return 0;
}

#undef SDL_SetColorKey
int SDL_SetColorKey_replacement(SDL_Surface *surface, Uint32 flag, Uint32 key) {
	return SDL_SetColorKey(surface, SDL_TRUE, key) ? -1 : 0;
}
#endif

