/**

  * vim: set ts=4 :

  * =============================================================================

  * SourceMod

  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

  * =============================================================================

  *

  * This program is free software; you can redistribute it and/or modify it under

  * the terms of the GNU General Public License, version 3.0, as published by the

  * Free Software Foundation.

  * 

  * 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, see <http://www.gnu.org/licenses/>.

  *

  * As a special exception, AlliedModders LLC gives you permission to link the

  * code of this program (as well as its derivative works) to "Half-Life 2," the

  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

  * by the Valve Corporation.  You must obey the GNU General Public License in

  * all respects for all other code used.  Additionally, AlliedModders LLC grants

  * this exception to all derivative works.  AlliedModders LLC defines further

  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

  * or <http://www.sourcemod.net/license.php>.

  *

  * Version: $Id$

  */

 #include <string.h>

 #include <stdlib.h>

 #include "GameConfigs.h"

 #define PSTATE_NONE						0

 #define PSTATE_GAMES					1

 #define PSTATE_GAMEDEFS					2

 #define PSTATE_GAMEDEFS_OFFSETS			3

 #define PSTATE_GAMEDEFS_OFFSETS_OFFSET	4

 #define PSTATE_GAMEDEFS_KEYS			5

 #define PSTATE_GAMEDEFS_SUPPORTED		6

 #define PSTATE_GAMEDEFS_SIGNATURES		7

 #define PSTATE_GAMEDEFS_SIGNATURES_SIG	8

 #define PSTATE_GAMEDEFS_CRC				9

 #define PSTATE_GAMEDEFS_CRC_BINARY		10

 #define PSTATE_GAMEDEFS_CUSTOM			11

 #define PSTATE_GAMEDEFS_OPTIONS			12

 #define WIN 0

 #define LIN 1

 #define PLATFORM_NAME				"linux"

 #define PLATFORM_SERVER_BINARY		"server_i486.so"

 Offset *tempOffset;

 Sig *tempSig;

 unsigned int s_ServerBinCRC;

 bool s_ServerBinCRC_Ok = false;

 bool DoesGameMatch(const char *value)

 {

 	if (strcmp(value, game) == 0)

 	{

 		return true;

 	}

 	return false;

 }

 bool DoesEngineMatch(const char *value)

 {

 	if (strcmp(value, engine) == 0)

 	{

 		return true;

 	}

 	return false;

 }

 CGameConfig::CGameConfig()

 {

 	m_pStrings = new BaseStringTable(512);

 	m_RefCount = 0;

 	m_CustomLevel = 0;

 	m_CustomHandler = NULL;

 }

 CGameConfig::~CGameConfig()

 {

 	delete m_pStrings;

 }

 SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *name)

 {

 	if (m_IgnoreLevel)

 	{

 		m_IgnoreLevel++;

 		return SMCResult_Continue;

 	}

 	switch (m_ParseState)

 	{

 	case PSTATE_NONE:

 		{

 			if (strcmp(name, "Games") == 0)

 			{

 				m_ParseState = PSTATE_GAMES;

 			} else {

 				m_IgnoreLevel++;

 			}

 			break;

 		}

 	case PSTATE_GAMES:

 		{

 			if (strcmp(name, "*") == 0 ||

 				strcmp(name, "#default") == 0 ||

 				DoesGameMatch(name))

 			{

 				bShouldBeReadingDefault = true;

 				m_ParseState = PSTATE_GAMEDEFS;

 				strncopy(m_Game, name, sizeof(m_Game));

 			} else {

 				m_IgnoreLevel++;

 			}

 			break;

 		}

 	case PSTATE_GAMEDEFS:

 		{

 			if (strcmp(name, "Offsets") == 0)

 			{

 				m_ParseState = PSTATE_GAMEDEFS_OFFSETS;

 			}

 			else if (strcmp(name, "Keys") == 0)

 			{

 				m_ParseState = PSTATE_GAMEDEFS_KEYS;

 			}

 			else if (strcmp(name, "Options") == 0)

 			{

 				m_ParseState = PSTATE_GAMEDEFS_OPTIONS;

 			}

 			else if ((strcmp(name, "#supported") == 0) && (strcmp(m_Game, "#default") == 0))

 			{

 				m_ParseState = PSTATE_GAMEDEFS_SUPPORTED;

 				/* Ignore this section unless we get a game. */

 				bShouldBeReadingDefault = false;

 				had_game = false;

 				matched_game = false;

 				had_engine = false;

 				matched_engine = false;

 			}

 			else if (strcmp(name, "Signatures") == 0)

 			{

 				m_ParseState = PSTATE_GAMEDEFS_SIGNATURES;

 			}

 			break;

 		}

 	case PSTATE_GAMEDEFS_OFFSETS:

 		{

 			m_Prop[0] = '\0';

 			m_Class[0] = '\0';

 			tempOffset = new Offset();

 			tempOffset->setName(name);

 			m_ParseState = PSTATE_GAMEDEFS_OFFSETS_OFFSET;

 			break;

 		}

 	case PSTATE_GAMEDEFS_SIGNATURES:

 		{

 			tempSig = new Sig();

 			tempSig->setName(name);

 			m_ParseState = PSTATE_GAMEDEFS_SIGNATURES_SIG;

 			break;

 		}

 	/* No sub-sections allowed:

 	 case PSTATE_GAMEDEFS_OFFSETS_OFFSET:

 	 case PSTATE_GAMEDEFS_KEYS:

 	 case PSTATE_GAMEDEFS_SUPPORTED:

 	 case PSTATE_GAMEDEFS_SIGNATURES_SIG:

 	 case PSTATE_GAMEDEFS_CRC_BINARY:

 	 */

 	default:

 		{

 			/* If we don't know what we got, start ignoring */

 			m_IgnoreLevel++;

 			break;

 		}

 	}

 	return SMCResult_Continue;

 }

 SMCResult CGameConfig::ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)

 {

 	if (m_IgnoreLevel)

 	{

 		return SMCResult_Continue;

 	}

 	if (m_ParseState == PSTATE_GAMEDEFS_OFFSETS_OFFSET)

 	{

 		if (strcmp(key, "class") == 0)

 		{

 			strncopy(m_Class, value, sizeof(m_Class));

 		} else if (strcmp(key, "prop") == 0) {

 			strncopy(m_Prop, value, sizeof(m_Prop));

 		} else {

 			int val = atoi(value);

 			if (strcmp(key, "windows") == 0) tempOffset->setWin(val);

 			else if (strcmp(key, "linux") == 0) tempOffset->setLin(val);

 		}

 	} else if (m_ParseState == PSTATE_GAMEDEFS_KEYS) {

 		m_Keys.replace(key, m_pStrings->AddString(value));

 	} else if (m_ParseState == PSTATE_GAMEDEFS_OPTIONS) {

 		m_Options.replace(key, m_pStrings->AddString(value));

 	} else if (m_ParseState == PSTATE_GAMEDEFS_SUPPORTED) {

 		if (strcmp(key, "game") == 0)

 		{

 			had_game = true;

 			if (DoesGameMatch(value))

 			{

 				matched_game = true;

 			}

 			if ((!had_engine && matched_game) || (matched_engine && matched_game))

 			{

 				bShouldBeReadingDefault = true;

 			}

 		}

 		else if (strcmp(key, "engine") == 0)

 		{

 			had_engine = true;

 			if (DoesEngineMatch(value))

 			{

 				matched_engine = true;

 			}

 			if ((!had_game && matched_engine) || (matched_game && matched_engine))

 			{

 				bShouldBeReadingDefault = true;

 			}

 		}

 	} else if (m_ParseState == PSTATE_GAMEDEFS_SIGNATURES_SIG) {

 		if (strcmp(key, "windows") == 0) tempSig->setWin(value);

 		else if (strcmp(key, "linux") == 0) tempSig->setLin(value);

 		else if (strcmp(key, "library") == 0) tempSig->setLib(value);

 	} else if (m_ParseState == PSTATE_GAMEDEFS_CRC_BINARY) {

 		if (strcmp(key, PLATFORM_NAME) == 0 

 			&& s_ServerBinCRC_Ok

 			&& !bShouldBeReadingDefault)

 		{

 			unsigned int crc = 0;

 			sscanf(value, "%08X", &crc);

 			if (s_ServerBinCRC == crc)

 			{

 				bShouldBeReadingDefault = true;

 			}

 		}

 	} else if (m_ParseState == PSTATE_GAMEDEFS_CUSTOM) {

 		return m_CustomHandler->ReadSMC_KeyValue(states, key, value);

 	}

 	return SMCResult_Continue;

 }

 SMCResult CGameConfig::ReadSMC_LeavingSection(const SMCStates *states)

 {

 	if (m_IgnoreLevel)

 	{

 		m_IgnoreLevel--;

 		return SMCResult_Continue;

 	}

 	if (m_CustomLevel)

 	{

 		m_CustomLevel--;

 		m_CustomHandler->ReadSMC_LeavingSection(states);

 		return SMCResult_Continue;

 	}

 	switch (m_ParseState)

 	{

 	case PSTATE_GAMES:

 		{

 			m_ParseState = PSTATE_NONE;

 			break;

 		}

 	case PSTATE_GAMEDEFS:

 		{

 			m_ParseState = PSTATE_GAMES;

 			break;

 		}

 	case PSTATE_GAMEDEFS_CUSTOM:

 		{

 			m_ParseState = PSTATE_GAMEDEFS;

 			m_CustomHandler->ReadSMC_ParseEnd(false, false);

 			break;

 		}

 	case PSTATE_GAMEDEFS_KEYS:

 	case PSTATE_GAMEDEFS_OFFSETS:

 	case PSTATE_GAMEDEFS_OPTIONS:

 		{

 			m_ParseState = PSTATE_GAMEDEFS;

 			break;

 		}

 	case PSTATE_GAMEDEFS_OFFSETS_OFFSET:

 		{

 			for (list<Offset>::iterator it = m_Offsets.begin(); it != m_Offsets.end(); it++)

 			{

 				if (strcmp(it->name, tempOffset->name) == 0)

 				{

 					m_Offsets.erase(it);

 					break;

 				}

 			}

 			m_Offsets.push_back(*tempOffset);

 			m_ParseState = PSTATE_GAMEDEFS_OFFSETS;

 			break;

 		}

 	case PSTATE_GAMEDEFS_CRC:

 	case PSTATE_GAMEDEFS_SUPPORTED:

 		{

 			if (!bShouldBeReadingDefault)

 			{

 				/* If we shouldn't read the rest of this section, set the ignore level. */

 				m_IgnoreLevel = 1;

 				m_ParseState = PSTATE_GAMES;

 			} else {

 				m_ParseState = PSTATE_GAMEDEFS;

 			}

 			break;

 		}

 	case PSTATE_GAMEDEFS_CRC_BINARY:

 		{

 			m_ParseState = PSTATE_GAMEDEFS_CRC;

 			break;

 		}

 	case PSTATE_GAMEDEFS_SIGNATURES:

 		{

 			m_ParseState = PSTATE_GAMEDEFS;

 			break;

 		}

 	case PSTATE_GAMEDEFS_SIGNATURES_SIG:

 		{

 			m_Sigs.push_back(*tempSig);

 			m_ParseState = PSTATE_GAMEDEFS_SIGNATURES;

 			break;

 		}

 	}

 	return SMCResult_Continue;

 }

 #define MSTATE_NONE		0

 #define MSTATE_MAIN		1

 #define MSTATE_FILE		2

 class MasterReader : public ITextListener_SMC

 {

 public:

 	virtual void ReadSMC_ParseStart()

 	{

 		state = MSTATE_NONE;

 		ignoreLevel = 0;

 	}

 	virtual SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name)

 	{

 		if (ignoreLevel)

 		{

 			return SMCResult_Continue;

 		}

 		if (state == MSTATE_NONE)

 		{

 			if (strcmp(name, "Game Master") == 0)

 			{

 				state = MSTATE_MAIN;

 			}

 			else

 			{

 				ignoreLevel++;

 			}

 		}

 		else if (state == MSTATE_MAIN)

 		{

 			strncopy(cur_file, name, sizeof(cur_file));

 			had_engine = false;

 			matched_engine = false;

 			had_game = false;

 			matched_game = false;

 			state = MSTATE_FILE;

 		}

 		else if (state == MSTATE_FILE)

 		{

 			ignoreLevel++;

 		}

 		return SMCResult_Continue;

 	}

 	virtual SMCResult ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)

 	{

 		if (ignoreLevel || state != MSTATE_FILE)

 		{

 			return SMCResult_Continue;

 		}

 		if (strcmp(key, "engine") == 0)

 		{

 			had_engine = true;

 			if (DoesEngineMatch(value))

 			{

 				matched_engine = true;

 			}

 		}

 		else if (strcmp(key, "game") == 0)

 		{

 			had_game = true;

 			if (DoesGameMatch(value))

 			{

 				matched_game = true;

 			}

 		}

 		return SMCResult_Continue;

 	}

 	virtual SMCResult ReadSMC_LeavingSection(const SMCStates *states)

 	{

 		if (ignoreLevel)

 		{

 			ignoreLevel--;

 			return SMCResult_Continue;

 		}

 		if (state == MSTATE_FILE)

 		{

 			/* The four success conditions:

 			 * 1. Needed nothing.

 			 * 2. Needed game only.

 			 * 3. Needed engine only.

 			 * 4. Needed both engine and game.

 			 * Final result is minimized via k-map.

 			 */

 			if ((!had_engine && !had_game) ||

 				(!had_engine && matched_game) ||

 				(!had_game && matched_engine) ||

 				(matched_engine && matched_game))

 			{

 				fileList->push_back(cur_file);

 			}

 			state = MSTATE_MAIN;

 		}

 		else if (state == MSTATE_MAIN)

 		{

 			state = MSTATE_NONE;

 		}

 		return SMCResult_Continue;

 	}

 public:

 	list<char*> *fileList;

 	unsigned int state;

 	unsigned int ignoreLevel;

 	char cur_file[PLATFORM_MAX_PATH];

 	bool had_engine;

 	bool matched_engine;

 	bool had_game;

 	bool matched_game;

 };

 static MasterReader master_reader;

 bool CGameConfig::Reparse(char *error, size_t maxlength)

 {

 	/* Reset cached data */

 	m_pStrings->Reset();

 	m_Offsets.clear();

 	m_Sigs.clear();

 	m_Keys.clear();

 	m_Options.clear();

 	char path[PLATFORM_MAX_PATH];

 	/* See if we can use the extended gamedata format. */

 	//TODO pass in path to gamedata somehow

 	/* Otherwise, it's time to parse the master. */

 	SMCError err;

 	SMCStates state = {0, 0};

 	list<char*> fileList;

 	master_reader.fileList = &fileList;

 	err = textparsers->ParseSMCFile(path, &master_reader, &state, error, maxlength);

 	if (err != SMCError_Okay)

 	{

 		const char *msg = textparsers->GetSMCErrorString(err);

 		printf("[SM] Error parsing master gameconf file \"%s\":", path);

 		printf("[SM] Error %d on line %d, col %d: %s", 

 			err,

 			state.line,

 			state.col,

 			msg ? msg : "Unknown error");

 		exit(PARSE_ERROR);

 	}

 	/* Go through each file we found and parse it. */

 	list<char*>::iterator iter;

 	for (iter = fileList.begin(); iter != fileList.end(); iter++)

 	{

 		UTIL_Format(path, sizeof(path), "%s/%s", m_File, *iter);

 		if (!EnterFile(path, error, maxlength))

 		{

 			return false;

 		}

 	}

 	return true;

 }

 bool CGameConfig::EnterFile(const char *file, char *error, size_t maxlength)

 {

 	SMCError err;

 	SMCStates state = {0, 0};

 	/* Initialize parse states */

 	m_IgnoreLevel = 0;

 	bShouldBeReadingDefault = true;

 	m_ParseState = PSTATE_NONE;

 	if ((err=textparsers->ParseSMCFile(file, this, &state, error, maxlength))

 		!= SMCError_Okay)

 	{

 		const char *msg;

 		msg = textparsers->GetSMCErrorString(err);

 		printf("[SM] Error parsing gameconfig file \"%s\":\n", file);

 		printf("[SM] Error %d on line %d, col %d: %s\n", 

 			err,

 			state.line,

 			state.col,

 			msg ? msg : "Unknown error");

 		if (m_ParseState == PSTATE_GAMEDEFS_CUSTOM)

 		{

 			//error occurred while parsing a custom section

 			m_CustomHandler->ReadSMC_ParseEnd(true, true);

 			m_CustomHandler = NULL;

 			m_CustomLevel = 0;

 		}

 		exit(PARSE_ERROR);

 	}

 	return true;

 }

 const char *CGameConfig::GetKeyValue(const char *key)

 {

 	int *pkey;

 	if ((pkey = m_Keys.retrieve(key)) == NULL)

 		return NULL;

 	return m_pStrings->GetString(*pkey);

 }

 const char *CGameConfig::GetOptionValue(const char *key)

 {

 	int *pkey;

 	if ((pkey = m_Options.retrieve(key)) == NULL)

 		return NULL;

 	return m_pStrings->GetString(*pkey);

 }

 list<Offset> CGameConfig::GetOffsets() { return m_Offsets; }

 list<Sig> CGameConfig::GetSigs() { return m_Sigs; }