/*
===========================================================================

IceTech GPL Source Code
Copyright (C) 2026 Justin Marshall 

This file is part of the IceTech GPL Source Code (?IceTech Source Code?).  

IceTech Source Code 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 3 of the License, or
(at your option) any later version.

IceTech Source Code 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 IceTech Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the IceTech Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the IceTech Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing Justin Marshall, justinmarshall20@gmail.com

===========================================================================
*/

#ifndef __COMMON_H__
#define __COMMON_H__

/*
==============================================================

  Common

==============================================================
*/

#ifdef PREY
class idKeyInput;
#endif

#ifdef QUAKE4
// RAVEN BEGIN
// mekberg: added more save types
typedef enum {
	ST_REGULAR,
	ST_QUICK,
	ST_AUTO,
	ST_CHECKPOINT,
} saveType_t;
// RAVEN END

#define MAX_OUTPUT_HISTORY		16

class idInterpreter;
class idProgram;
class rvISourceControl;

// converted to a class so the idStr gets constructed
class MemInfo {
public:
					MemInfo( void );

	idStr			filebase;

	int				total;
	int				assetTotals;

	// asset totals
	int				imageAssetsTotal;
	int				modelAssetsTotal;
	int				soundAssetsTotal;
	int				collAssetsTotal;
	int				animsAssetsTotal;
	int				aasAssetsTotal;

	int				imageAssetsCount;
	int				modelAssetsCount;
	int				soundAssetsCount;
	int				collAssetsCount;
	int				animsAssetsCount;
	int				aasAssetsCount;
};
#endif

typedef enum {
	EDITOR_NONE					= 0,
	EDITOR_RADIANT				= BIT(1),
	EDITOR_GUI					= BIT(2),
	EDITOR_DEBUGGER				= BIT(3),
	EDITOR_SCRIPT				= BIT(4),
	EDITOR_LIGHT				= BIT(5),
	EDITOR_SOUND				= BIT(6),
	EDITOR_DECL					= BIT(7),
	EDITOR_AF					= BIT(8),
#ifndef QUAKE4
	EDITOR_PARTICLE				= BIT(9),
	EDITOR_PDA					= BIT(10),
	EDITOR_AAS					= BIT(11),
	EDITOR_MATERIAL				= BIT(12)
#else
	EDITOR_PDA					= BIT(9),
	EDITOR_FX					= BIT(10),
	EDITOR_REVERB				= BIT(11),
	EDITOR_PLAYBACKS			= BIT(12),
	EDITOR_MODVIEW				= BIT(13),
	EDITOR_LOGVIEW				= BIT(14),
	EDITOR_ENTVIEW				= BIT(15),
	EDITOR_MATERIAL				= BIT(16),

	// Doom 3 tool path is intentionally preserved. This alias keeps the
	// old in-game particle editor code buildable when QUAKE4 is defined.
	EDITOR_PARTICLE				= BIT(21),

	// Just flags to prevent caching of unneeded assets
	EDITOR_AAS					= BIT(17),
	EDITOR_RENDERBUMP			= BIT(18),
	EDITOR_SPAWN_GUI			= BIT(19),

	// Specifies that a decl validation run is happening
	EDITOR_DECL_VALIDATING		= BIT(20),

	EDITOR_ALL					= -1
#endif
} toolFlag_t;

#define STRTABLE_ID				"#str_"
#define STRTABLE_ID_LENGTH		5

extern idCVar		com_version;
extern idCVar		com_skipRenderer;
extern idCVar		com_asyncInput;
extern idCVar		com_asyncSound;
extern idCVar		com_machineSpec;
extern idCVar		com_purgeAll;
extern idCVar		com_developer;
extern idCVar		com_allowConsole;
extern idCVar		com_speeds;
extern idCVar		com_showFPS;
extern idCVar		com_showMemoryUsage;
extern idCVar		com_showAsyncStats;
extern idCVar		com_showSoundDecoders;
extern idCVar		com_makingBuild;
extern idCVar		com_updateLoadSize;
extern idCVar		com_videoRam;

#ifdef QUAKE4
extern idCVar		com_skipUltraQuality;
extern idCVar		com_Bundler;
#ifndef _XENON
extern idCVar		com_MakeLoadScreens;
#endif
extern idCVar		com_QuickLoad;
extern idCVar		com_Limits;
extern idCVar		com_BinaryWrite;
extern idCVar		com_BinaryRead;
#ifdef RV_BINARYDECLS
extern idCVar		com_BinaryDeclRead;
#endif
#ifdef RV_SINGLE_DECL_FILE
extern idCVar		com_SingleDeclFile;
extern idCVar		com_WriteSingleDeclFIle;
#endif
extern idCVar		com_uniqueWarnings;
extern idCVar		com_showMemAllocTags;
#if defined(_XENON)
extern idCVar		com_showXenTexCacheStats;
extern idCVar		com_showXenHardwareTimers;
extern idCVar		com_showXenThreadUsage;
#endif
extern idCVar		sys_lang;
#endif

extern int			time_gameFrame;			// game logic time
extern int			time_gameDraw;			// game present time
extern int			time_frontend;			// renderer frontend time
extern int			time_backend;			// renderer backend time
extern float		com_lastGameFrameMsec;	// last displayed game CPU time
extern float		com_lastRenderFrameMsec;// last displayed render CPU time
extern float		com_pathTracingGpuMsec;	// last completed path tracing GPU time
#ifdef QUAKE4
extern int			time_waiting;			// time spent waiting
#endif

extern int			com_frameTime;			// time for the current frame in milliseconds
extern volatile int	com_ticNumber;			// 60 hz tics, incremented by async function
extern int			com_editors;			// current active editor(s)
extern bool			com_editorActive;		// true if an editor has focus
#ifdef QUAKE4
extern bool			com_debugHudActive;	// the debug hud is active in the game
#endif

#ifdef _WIN32
const char			DMAP_MSGID[] = "DMAPOutput";
const char			DMAP_DONE[] = "DMAPDone";
extern HWND			com_hwndMsg;
extern bool			com_outputMsg;
#endif

struct MemInfo_t {
	idStr			filebase;

	int				total;
	int				assetTotals;

	// memory manager totals
	int				memoryManagerTotal;

	// subsystem totals
	int				gameSubsystemTotal;
	int				renderSubsystemTotal;

	// asset totals
	int				imageAssetsTotal;
	int				modelAssetsTotal;
	int				soundAssetsTotal;
};

class idCommon {
public:
	virtual						~idCommon( void ) {}

								// Initialize everything.
								// if the OS allows, pass argc/argv directly (without executable name)
								// otherwise pass the command line in a single string (without executable name)
	virtual void				Init( int argc, const char **argv, const char *cmdline ) = 0;

								// Shuts down everything.
	virtual void				Shutdown( void ) = 0;

								// Shuts down everything.
	virtual void				Quit( void ) = 0;

								// Returns true if common initialization is complete.
	virtual bool				IsInitialized( void ) const = 0;

								// Called repeatedly as the foreground thread for rendering and game logic.
	virtual void				Frame( void ) = 0;

								// Called repeatedly by blocking function calls with GUI interactivity.
	virtual void				GUIFrame( bool execCmd, bool network ) = 0;

								// Checks for and removes command line "+set var arg" constructs.
								// If match is NULL, all set commands will be executed, otherwise
								// only a set with the exact name.  Only used during startup.
								// set once to clear the cvar from +set for early init code
	virtual void				StartupVariable( const char *match, bool once ) = 0;

#ifdef QUAKE4
	virtual int					GetUserCmdHz( void ) const = 0;
	virtual int					GetUserCmdMSec( void ) const = 0;
	virtual int					GetFrameTime( void ) const = 0;
	virtual bool				IsRenderableGameFrame( void ) const = 0;
	virtual void				SetRenderableGameFrame( bool in ) = 0;
	virtual const char *		GetErrorMessage( void ) const = 0;
	virtual bool				IsToolActive( void ) const = 0;
#ifdef _RV_MEM_SYS_SUPPORT
	virtual void				InitHeaps( void ) = 0;
	virtual void				ShutdownHeaps( void ) = 0;
#endif
	virtual void				RunAlwaysThinkGUIs( int time ) = 0;
	virtual bool				DoingDeclValidation( void ) = 0;
	virtual void				SetCrashReportAutoSendString( const char *psString ) = 0;
#endif

								// Initializes a tool with the given dictionary.
	virtual void				InitTool( const toolFlag_t tool, const idDict *dict ) = 0;

								// Activates or deactivates a tool.
	virtual void				ActivateTool( bool active ) = 0;

								// Writes the user's configuration to a file
	virtual void				WriteConfigToFile( const char *filename ) = 0;

								// Writes cvars with the given flags to a file.
	virtual void				WriteFlaggedCVarsToFile( const char *filename, int flags, const char *setCmd ) = 0;

								// Begins redirection of console output to the given buffer.
#ifdef QUAKE4
	virtual void				BeginRedirect( char *buffer, int buffersize, void (*flush)( const char * ), bool rcon = false ) = 0;
#else
	virtual void				BeginRedirect( char *buffer, int buffersize, void (*flush)( const char * ) ) = 0;
#endif

								// Stops redirection of console output.
	virtual void				EndRedirect( void ) = 0;

								// Update the screen with every message printed.
	virtual void				SetRefreshOnPrint( bool set ) = 0;

								// Prints message to the console, which may cause a screen update if com_refreshOnPrint is set.
	virtual void				Printf( const char *fmt, ... )id_attribute((format(printf,2,3))) = 0;

								// Same as Printf, with a more usable API - Printf pipes to this.
	virtual void				VPrintf( const char *fmt, va_list arg ) = 0;

								// Prints message that only shows up if the "developer" cvar is set,
								// and NEVER forces a screen update, which could cause reentrancy problems.
	virtual void				DPrintf( const char *fmt, ... ) id_attribute((format(printf,2,3))) = 0;

								// Prints WARNING %s message and adds the warning message to a queue for printing later on.
	virtual void				Warning( const char *fmt, ... ) id_attribute((format(printf,2,3))) = 0;

								// Prints WARNING %s message in yellow that only shows up if the "developer" cvar is set.
	virtual void				DWarning( const char *fmt, ...) id_attribute((format(printf,2,3))) = 0;

								// Prints all queued warnings.
	virtual void				PrintWarnings( void ) = 0;

								// Removes all queued warnings.
	virtual void				ClearWarnings( const char *reason ) = 0;

								// Issues a C++ throw. Normal errors just abort to the game loop,
								// which is appropriate for media or dynamic logic errors.
	virtual void				Error( const char *fmt, ... ) id_attribute((format(printf,2,3))) = 0;

								// Fatal errors quit all the way to a system dialog box, which is appropriate for
								// static internal errors or cases where the system may be corrupted.
	virtual void				FatalError( const char *fmt, ... ) id_attribute((format(printf,2,3))) = 0;

#ifdef QUAKE4
								// Brings up notepad with the warnings generated while running the game.
	virtual void				DumpWarnings( void ) = 0;
#endif

								// Returns a pointer to the dictionary with language specific strings.
	virtual const idLangDict *	GetLanguageDict( void ) = 0;

#ifdef QUAKE4
								// Returns the localised string of the token, or the token if it does not begin with #str_.
	virtual const char *		GetLocalizedString( const char *token, int langIndex = -1 ) = 0;

								// Returns the localised string at position 'index'.
	virtual const idLangKeyValue * GetLocalizedString( int index, int langIndex = -1 ) = 0;

								// Returns the number of languages the game found.
	virtual int					GetNumLanguages( void ) const = 0;

								// Returns the number of strings in the English langdict.
	virtual int					GetNumLocalizedStrings( void ) const = 0;

								// Returns the name of the language.
	virtual const char *		GetLanguage( int index ) const = 0;

								// Returns whether the language has VO.
	virtual bool				LanguageHasVO( int index ) const = 0;
#endif

								// Returns key bound to the command
	virtual const char *		KeysFromBinding( const char *bind ) = 0;

								// Returns the binding bound to the key
	virtual const char *		BindingFromKey( const char *key ) = 0; 

								// Directly sample a button.
	virtual int					ButtonState( int key ) = 0;

								// Directly sample a keystate.
	virtual int					KeyState( int key ) = 0;

#ifdef QUAKE4
	virtual int					GetRModeForMachineSpec( int machineSpec ) const = 0;
	virtual void				SetDesiredMachineSpec( int machineSpec ) = 0;
	virtual bool				IsRCon( void ) const = 0;
#endif

#ifdef PREY
	virtual void				MaterialKeyForBinding(const char* binding, char* materialName, char* keyText, bool* wideKey) = 0;
#endif

	virtual float				Get_com_engineHz_latched(void) = 0;
	virtual int64_t			Get_com_engineHz_numerator(void) = 0;
	virtual int64_t			Get_com_engineHz_denominator(void) = 0;
};

extern idCommon *		common;


// Returns the msec the frame starts on
ID_INLINE int FRAME_TO_MSEC(int64_t frame) {
	return (int)((frame * common->Get_com_engineHz_numerator()) / common->Get_com_engineHz_denominator());
}
// Rounds DOWN to the nearest frame
ID_INLINE int MSEC_TO_FRAME_FLOOR(int msec) {
	return (int)((((int64_t)msec * common->Get_com_engineHz_denominator()) + (common->Get_com_engineHz_denominator() - 1)) / common->Get_com_engineHz_numerator());
}
// Rounds UP to the nearest frame
ID_INLINE int MSEC_TO_FRAME_CEIL(int msec) {
	return (int)((((int64_t)msec * common->Get_com_engineHz_denominator()) + (common->Get_com_engineHz_numerator() - 1)) / common->Get_com_engineHz_numerator());
}
// Aligns msec so it starts on a frame bondary
ID_INLINE int MSEC_ALIGN_TO_FRAME(int msec) {
	return FRAME_TO_MSEC(MSEC_TO_FRAME_CEIL(msec));
}

#endif /* !__COMMON_H__ */