/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2005 John Fitzgibbons and others
Copyright (C) 2007-2008 Kristian Duske
Copyright (C) 2010-2014 QuakeSpasm developers

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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include <SDL.h>
#include <stdio.h>

/* need at least SDL_2.0.0 */
#define SDL_MIN_X       2
#define SDL_MIN_Y       0
#define SDL_MIN_Z       0
#define SDL_REQUIREDVERSION     (SDL_VERSIONNUM(SDL_MIN_X,SDL_MIN_Y,SDL_MIN_Z))
#define SDL_NEW_VERSION_REJECT  (SDL_VERSIONNUM(3,0,0))

static void Sys_AtExit(void)
{
	SDL_Quit();
}

static void Sys_InitSDL(void)
{
	SDL_version v;
	SDL_version *sdl_version = &v;
	SDL_GetVersion(&v);

	Sys_Printf("Found SDL version %" PRIi32 ".%" PRIi32 ".%" PRIi32 "\n", sdl_version->major, sdl_version->minor, sdl_version->patch);
	if(SDL_VERSIONNUM(sdl_version->major, sdl_version->minor, sdl_version->patch) < SDL_REQUIREDVERSION)
	{
		/*reject running under older SDL versions */
		Sys_Error("You need at least v%" PRIi32 ".%" PRIi32 ".%" PRIi32 " of SDL to run this game.", SDL_MIN_X, SDL_MIN_Y, SDL_MIN_Z);
	}
	if(SDL_VERSIONNUM(sdl_version->major, sdl_version->minor, sdl_version->patch) >= SDL_NEW_VERSION_REJECT)
	{
		/*reject running under newer (1.3.x) SDL */
		Sys_Error("Your version of SDL library is incompatible with me.\n"
		          "You need a library version in the line of %" PRIi32 ".%" PRIi32 ".%" PRIi32 "\n", SDL_MIN_X, SDL_MIN_Y, SDL_MIN_Z);
	}

	if(SDL_Init(0) < 0)
	{
		Sys_Error("Couldn't init SDL: %s", SDL_GetError());
	}
	atexit(Sys_AtExit);
}

#define DEFAULT_MEMORY (256 * 1024 * 1024) // ericw -- was 72MB (64-bit) / 64MB (32-bit)

static quakeparms_t     parms;

// On OS X we call SDL_main from the launcher, but SDL2 doesn't redefine main
// as SDL_main on OS X anymore, so we do it ourselves.
#if defined(__APPLE__)
#define main SDL_main
#endif

int32_t main(int32_t argc, char *argv[])
{
	int32_t         t;
	double          time, oldtime, newtime;

	host_parms = &parms;
	parms.basedir = ".";

	parms.argc = argc;
	parms.argv = argv;

	parms.errstate = 0;

	COM_InitArgv(parms.argc, parms.argv);

	isDedicated = (COM_CheckParm("-dedicated") != 0);

	Sys_InitSDL();

	Sys_Init();

	parms.memsize = DEFAULT_MEMORY;
	if(COM_CheckParm("-heapsize"))
	{
		t = COM_CheckParm("-heapsize") + 1;
		if(t < com_argc)
			parms.memsize = Q_atoi(com_argv[t]) * 1024;
	}

	parms.membase = malloc(parms.memsize);

	if(!parms.membase)
		Sys_Error("Not enough memory free; check disk space\n");

	Sys_Printf("Quake " VERSION " (c) id Software\n");
	Sys_Printf("FitzQuake " FITZQUAKE_VERSION " (c) John Fitzgibbons\n");
	Sys_Printf("FitzQuake SDL port (c) SleepwalkR, Baker\n");
	Sys_Printf("QuakeSpasm " QUAKESPASM_VERSION " (c) Ozkan Sezer, Eric Wasylishen & others\n");

	Sys_Printf("Host_Init\n");
	Host_Init();

	oldtime = Sys_DoubleTime();
	if(isDedicated)
	{
		while(1)
		{
			newtime = Sys_DoubleTime();
			time = newtime - oldtime;

			while(time < sys_ticrate.value)
			{
				SDL_Delay(1);
				newtime = Sys_DoubleTime();
				time = newtime - oldtime;
			}

			Host_Frame(time);
			oldtime = newtime;
		}
	}
	else
		while(1)
		{
			/* If we have no input focus at all, sleep a bit */
			if(!VID_HasMouseOrInputFocus() || cl.paused)
			{
				SDL_Delay(16);
			}
			/* If we're minimised, sleep a bit more */
			if(VID_IsMinimized())
			{
				scr_skipupdate = 1;
				SDL_Delay(32);
			}
			else
			{
				scr_skipupdate = 0;
			}
			newtime = Sys_DoubleTime();
			time = newtime - oldtime;

			Host_Frame(time);

			if(time < sys_throttle.value && !cls.timedemo)
				SDL_Delay(1);

			oldtime = newtime;
		}

	return 0;
}