/* $Id$ */

/** @file

 * All actions handling saving and loading of the settings/configuration goes on in this file.

 * The file consists of four parts:

 * <ol>

 * <li>Parsing the configuration file (openttd.cfg). This is achieved with the ini_ functions which

 *     handle various types, such as normal 'key = value' pairs, lists and value combinations of

 *     lists, strings, integers, 'bit'-masks and element selections.

 * <li>Defining the data structures that go into the configuration. These include for example

 *     the _patches struct, but also network-settings, banlists, newgrf, etc. There are a lot

 *     of helper macros available for the various types, and also saving/loading of these settings

 *     in a savegame is handled inside these structures.

 * <li>Handle reading and writing to the setting-structures from inside the game either from

 *     the console for example or through the gui with CMD_ functions.

 * <li>Handle saving/loading of the PATS chunk inside the savegame.

 * </ol>

 * @see SettingDesc

 * @see SaveLoad

 */

#include "stdafx.h"

#include "openttd.h"

#include "currency.h"

#include "functions.h"

#include "macros.h"

#include "screenshot.h"

#include "sound.h"

#include "string.h"

#include "variables.h"

#include "network/network.h"

#include "settings.h"

#include "command.h"

#include "console.h"

#include "saveload.h"

#include "npf.h"

#include "yapf/yapf.h"

#include "newgrf.h"

#include "newgrf_config.h"

#include "genworld.h"

#include "date.h"

#include "rail.h"

#ifdef WITH_FREETYPE

#include "gfx.h"

#include "fontcache.h"

#endif

/** The patch values that are used for new games and/or modified in config file */

Patches _patches_newgame;

typedef struct IniFile IniFile;

typedef struct IniItem IniItem;

typedef struct IniGroup IniGroup;

typedef struct SettingsMemoryPool SettingsMemoryPool;

typedef const char *SettingListCallbackProc(const IniItem *item, uint index);

typedef void SettingDescProc(IniFile *ini, const SettingDesc *desc, const char *grpname, void *object);

typedef void SettingDescProcList(IniFile *ini, const char *grpname, char **list, uint len, SettingListCallbackProc proc);

static void pool_init(SettingsMemoryPool **pool);

static void *pool_alloc(SettingsMemoryPool **pool, uint size);

static void *pool_strdup(SettingsMemoryPool **pool, const char *mem, uint size);

static void pool_free(SettingsMemoryPool **pool);

static bool IsSignedVarMemType(VarType vt);

struct SettingsMemoryPool {

	uint pos,size;

	SettingsMemoryPool *next;

	byte mem[1];

};

static SettingsMemoryPool *pool_new(uint minsize)

{

	SettingsMemoryPool *p;

	if (minsize < 4096 - 12) minsize = 4096 - 12;

	p = malloc(sizeof(SettingsMemoryPool) - 1 + minsize);

	p->pos = 0;

	p->size = minsize;

	p->next = NULL;

	return p;

}

static void pool_init(SettingsMemoryPool **pool)

{

	*pool = pool_new(0);

}

static void *pool_alloc(SettingsMemoryPool **pool, uint size)

{

	uint pos;

	SettingsMemoryPool *p = *pool;

	size = ALIGN(size, sizeof(void*));

	// first check if there's memory in the next pool

	if (p->next && p->next->pos + size <= p->next->size) {

		p = p->next;

	// then check if there's not memory in the cur pool

	} else if (p->pos + size > p->size) {

		SettingsMemoryPool *n = pool_new(size);

		*pool = n;

		n->next = p;

		p = n;

	}

	pos = p->pos;

	p->pos += size;

	return p->mem + pos;

}

static void *pool_strdup(SettingsMemoryPool **pool, const char *mem, uint size)

{

	byte *p = pool_alloc(pool, size + 1);

	p[size] = 0;

	memcpy(p, mem, size);

	return p;

}

static void pool_free(SettingsMemoryPool **pool)

{

	SettingsMemoryPool *p = *pool, *n;

	*pool = NULL;

	while (p) {

		n = p->next;

		free(p);

		p = n;

	}

}

// structs describing the ini format.

struct IniItem {

	char *name;

	char *value;

	char *comment;

	IniItem *next;

};

struct IniGroup {

	char *name; // name of group

	char *comment; //comment for group

	IniItem *item, **last_item;

	IniGroup *next;

	IniFile *ini;

	IniGroupType type; // type of group

};

struct IniFile {

	SettingsMemoryPool *pool;

	IniGroup *group, **last_group;

	char *comment; // last comment in file

};

// allocate an inifile object

static IniFile *ini_alloc(void)

{

	IniFile *ini;

	SettingsMemoryPool *pool;

	pool_init(&pool);

	ini = (IniFile*)pool_alloc(&pool, sizeof(IniFile));

	ini->pool = pool;

	ini->group = NULL;

	ini->last_group = &ini->group;

	ini->comment = NULL;

	return ini;

}

// allocate an ini group object

static IniGroup *ini_group_alloc(IniFile *ini, const char *grpt, int len)

{

	IniGroup *grp = pool_alloc(&ini->pool, sizeof(IniGroup));

	grp->ini = ini;

	grp->name = pool_strdup(&ini->pool, grpt, len);

	if (!strcmp(grp->name, "newgrf") || !strcmp(grp->name, "servers") || !strcmp(grp->name, "bans")) {

		grp->type = IGT_LIST;

	} else {

		grp->type = IGT_VARIABLES;

	}

	grp->next = NULL;

	grp->item = NULL;

	grp->comment = NULL;

	grp->last_item = &grp->item;

	*ini->last_group = grp;

	ini->last_group = &grp->next;

	return grp;

}

static IniItem *ini_item_alloc(IniGroup *group, const char *name, int len)

{

	IniItem *item = pool_alloc(&group->ini->pool, sizeof(IniItem));

	item->name = pool_strdup(&group->ini->pool, name, len);

	item->next = NULL;

	item->comment = NULL;

	item->value = NULL;

	*group->last_item = item;

	group->last_item = &item->next;

	return item;

}

// load an ini file into the "abstract" format

static IniFile *ini_load(const char *filename)

{

	char buffer[1024], c, *s, *t, *e;

	FILE *in;

	IniFile *ini;

	IniGroup *group = NULL;

	IniItem *item;

	char *comment = NULL;

	uint comment_size = 0;

	uint comment_alloc = 0;

	ini = ini_alloc();

	in = fopen(filename, "r");

	if (in == NULL) return ini;

	// for each line in the file

	while (fgets(buffer, sizeof(buffer), in)) {

		// trim whitespace from the left side

		for (s = buffer; *s == ' ' || *s == '\t'; s++);

		// trim whitespace from right side.

		e = s + strlen(s);

		while (e > s && ((c=e[-1]) == '\n' || c == '\r' || c == ' ' || c == '\t')) e--;

		*e = '\0';

		// skip comments and empty lines

		if (*s == '#' || *s == ';' || *s == '\0') {

			uint ns = comment_size + (e - s + 1);

			uint a = comment_alloc;

			uint pos;

			// add to comment

			if (ns > a) {

				a = max(a, 128);

				do a*=2; while (a < ns);

				comment = realloc(comment, comment_alloc = a);

			}

			pos = comment_size;

			comment_size += (e - s + 1);

			comment[pos + e - s] = '\n'; // comment newline

			memcpy(comment + pos, s, e - s); // copy comment contents

			continue;

		}

		// it's a group?

		if (s[0] == '[') {

			if (e[-1] != ']') {

				ShowInfoF("ini: invalid group name '%s'", buffer);

			} else {

				e--;

			}

			s++; // skip [

			group = ini_group_alloc(ini, s, e - s);

			if (comment_size) {

				group->comment = pool_strdup(&ini->pool, comment, comment_size);

				comment_size = 0;

			}

		} else if (group) {

			// find end of keyname

			for (t = s; *t != '\0' && *t != '=' && *t != '\t' && *t != ' '; t++);

			// it's an item in an existing group

			item = ini_item_alloc(group, s, t-s);

			if (comment_size) {

				item->comment = pool_strdup(&ini->pool, comment, comment_size);

				comment_size = 0;

			}

			// find start of parameter

			while (*t == '=' || *t == ' ' || *t == '\t') t++;

			// remove starting quotation marks

			if (*t == '\"') t++;

			// remove ending quotation marks

			e = t + strlen(t);

			if (e > t && e[-1] == '\"') e--;

			*e = '\0';

			item->value = pool_strdup(&ini->pool, t, e - t);

		} else {

			// it's an orphan item

			ShowInfoF("ini: '%s' outside of group", buffer);

		}

	}

	if (comment_size > 0) {

		ini->comment = pool_strdup(&ini->pool, comment, comment_size);

		comment_size = 0;

	}

	free(comment);

	fclose(in);

	return ini;

}

// lookup a group or make a new one

static IniGroup *ini_getgroup(IniFile *ini, const char *name, int len)

{

	IniGroup *group;

	if (len == -1) len = strlen(name);

	// does it exist already?

	for (group = ini->group; group; group = group->next)

		if (!memcmp(group->name, name, len) && group->name[len] == 0)

			return group;

	// otherwise make a new one

	group = ini_group_alloc(ini, name, len);

	group->comment = pool_strdup(&ini->pool, "\n", 1);

	return group;

}

// lookup an item or make a new one

static IniItem *ini_getitem(IniGroup *group, const char *name, bool create)

{

	IniItem *item;

	uint len = strlen(name);

	for (item = group->item; item; item = item->next)

		if (strcmp(item->name, name) == 0) return item;

	if (!create) return NULL;

	// otherwise make a new one

	return ini_item_alloc(group, name, len);

}

// save ini file from the "abstract" format.

static bool ini_save(const char *filename, IniFile *ini)

{

	FILE *f;

	IniGroup *group;

	IniItem *item;

	f = fopen(filename, "w");

	if (f == NULL) return false;

	for (group = ini->group; group != NULL; group = group->next) {

		if (group->comment) fputs(group->comment, f);

		fprintf(f, "[%s]\n", group->name);

		for (item = group->item; item != NULL; item = item->next) {

			assert(item->value != NULL);

			if (item->comment != NULL) fputs(item->comment, f);

			/* Don't give an equal sign to list items that don't have a parameter */

			if (group->type == IGT_LIST && *item->value == '\0') {

				fprintf(f, "%s\n", item->name);

			} else {

				fprintf(f, "%s = %s\n", item->name, item->value);

			}

		}

	}

	if (ini->comment) fputs(ini->comment, f);

	fclose(f);

	return true;

}

static void ini_free(IniFile *ini)

{

	pool_free(&ini->pool);

}

/** Find the index value of a ONEofMANY type in a string seperated by |

 * @param many full domain of values the ONEofMANY setting can have

 * @param one the current value of the setting for which a value needs found

 * @param onelen force calculation of the *one parameter

 * @return the integer index of the full-list, or -1 if not found */

static int lookup_oneofmany(const char *many, const char *one, int onelen)

{

	const char *s;

	int idx;

	if (onelen == -1) onelen = strlen(one);

	// check if it's an integer

	if (*one >= '0' && *one <= '9')

		return strtoul(one, NULL, 0);

	idx = 0;

	for (;;) {

		// find end of item

		s = many;

		while (*s != '|' && *s != 0) s++;

		if (s - many == onelen && !memcmp(one, many, onelen)) return idx;

		if (*s == 0) return -1;

		many = s + 1;

		idx++;

	}

}

/** Find the set-integer value MANYofMANY type in a string

 * @param many full domain of values the MANYofMANY setting can have

 * @param str the current string value of the setting, each individual

 * of seperated by a whitespace\tab or | character

 * @return the 'fully' set integer, or -1 if a set is not found */

static uint32 lookup_manyofmany(const char *many, const char *str)

{

	const char *s;

	int r;

	uint32 res = 0;

	for (;;) {

		// skip "whitespace"

		while (*str == ' ' || *str == '\t' || *str == '|') str++;

		if (*str == 0) break;

		s = str;

		while (*s != 0 && *s != ' ' && *s != '\t' && *s != '|') s++;

		r = lookup_oneofmany(many, str, s - str);

		if (r == -1) return (uint32)-1;

		SETBIT(res, r); // value found, set it

		if (*s == 0) break;

		str = s + 1;

	}

	return res;

}

/** Parse an integerlist string and set each found value

 * @param p the string to be parsed. Each element in the list is seperated by a

 * comma or a space character

 * @param items pointer to the integerlist-array that will be filled with values

 * @param maxitems the maximum number of elements the integerlist-array has

 * @return returns the number of items found, or -1 on an error */

static int parse_intlist(const char *p, int *items, int maxitems)

{

	int n = 0, v;

	char *end;

	for (;;) {

		v = strtol(p, &end, 0);

		if (p == end || n == maxitems) return -1;

		p = end;

		items[n++] = v;

		if (*p == '\0') break;

		if (*p != ',' && *p != ' ') return -1;

		p++;

	}

	return n;

}

/** Load parsed string-values into an integer-array (intlist)

 * @param str the string that contains the values (and will be parsed)

 * @param array pointer to the integer-arrays that will be filled

 * @param nelems the number of elements the array holds. Maximum is 64 elements

 * @param type the type of elements the array holds (eg INT8, UINT16, etc.)

 * @return return true on success and false on error */

static bool load_intlist(const char *str, void *array, int nelems, VarType type)

{

	int items[64];

	int i, nitems;

	if (str == NULL) {

		memset(items, 0, sizeof(items));

		nitems = nelems;

	} else {

		nitems = parse_intlist(str, items, lengthof(items));

		if (nitems != nelems) return false;

	}

	switch (type) {

	case SLE_VAR_BL:

	case SLE_VAR_I8:

	case SLE_VAR_U8:

		for (i = 0; i != nitems; i++) ((byte*)array)[i] = items[i];

		break;

	case SLE_VAR_I16:

	case SLE_VAR_U16:

		for (i = 0; i != nitems; i++) ((uint16*)array)[i] = items[i];

		break;

	case SLE_VAR_I32:

	case SLE_VAR_U32:

		for (i = 0; i != nitems; i++) ((uint32*)array)[i] = items[i];

		break;

	default: NOT_REACHED();

	}

	return true;

}

/** Convert an integer-array (intlist) to a string representation. Each value

 * is seperated by a comma or a space character

 * @param buf output buffer where the string-representation will be stored

 * @param array pointer to the integer-arrays that is read from

 * @param nelems the number of elements the array holds.

 * @param type the type of elements the array holds (eg INT8, UINT16, etc.) */

static void make_intlist(char *buf, const void *array, int nelems, VarType type)

{

	int i, v = 0;

	const byte *p = (const byte*)array;

	for (i = 0; i != nelems; i++) {

		switch (type) {

		case SLE_VAR_BL:

		case SLE_VAR_I8:  v = *(int8*)p;   p += 1; break;

		case SLE_VAR_U8:  v = *(byte*)p;   p += 1; break;

		case SLE_VAR_I16: v = *(int16*)p;  p += 2; break;

		case SLE_VAR_U16: v = *(uint16*)p; p += 2; break;

		case SLE_VAR_I32: v = *(int32*)p;  p += 4; break;

		case SLE_VAR_U32: v = *(uint32*)p; p += 4; break;

		default: NOT_REACHED();

		}

		buf += sprintf(buf, (i == 0) ? "%d" : ",%d", v);

	}

}

/** Convert a ONEofMANY structure to a string representation.

 * @param buf output buffer where the string-representation will be stored

 * @param many the full-domain string of possible values

 * @param id the value of the variable and whose string-representation must be found */

static void make_oneofmany(char *buf, const char *many, int id)

{

	int orig_id = id;

	// Look for the id'th element

	while (--id >= 0) {

		for (; *many != '|'; many++) {

			if (*many == '\0') { // not found

				sprintf(buf, "%d", orig_id);

				return;

			}

		}

		many++; // pass the |-character

	}

	// copy string until next item (|) or the end of the list if this is the last one

	while (*many != '\0' && *many != '|') *buf++ = *many++;

	*buf = '\0';

}

/** Convert a MANYofMANY structure to a string representation.

 * @param buf output buffer where the string-representation will be stored

 * @param many the full-domain string of possible values

 * @param x the value of the variable and whose string-representation must

 *        be found in the bitmasked many string */

static void make_manyofmany(char *buf, const char *many, uint32 x)

{

	const char *start;

	int i = 0;

	bool init = true;

	for (; x != 0; x >>= 1, i++) {

		start = many;

		while (*many != 0 && *many != '|') many++; // advance to the next element

		if (HASBIT(x, 0)) { // item found, copy it

			if (!init) *buf++ = '|';

			init = false;

			if (start == many) {

				buf += sprintf(buf, "%d", i);

			} else {

				memcpy(buf, start, many - start);

				buf += many - start;

			}

		}

		if (*many == '|') many++;

	}

	*buf = '\0';

}

/** Convert a string representation (external) of a setting to the internal rep.

 * @param desc SettingDesc struct that holds all information about the variable

 * @param str input string that will be parsed based on the type of desc

 * @return return the parsed value of the setting */

static const void *string_to_val(const SettingDescBase *desc, const char *str)

{

	switch (desc->cmd) {

	case SDT_NUMX: {

		char *end;

		unsigned long val = strtoul(str, &end, 0);

		if (*end != '\0') ShowInfoF("ini: trailing characters at end of setting '%s'", desc->name);

		return (void*)val;

	}

	case SDT_ONEOFMANY: {

		long r = lookup_oneofmany(desc->many, str, -1);

		if (r != -1) return (void*)r;

		ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name);

		return 0;

	}

	case SDT_MANYOFMANY: {

		unsigned long r = lookup_manyofmany(desc->many, str);

		if (r != (unsigned long)-1) return (void*)r;

		ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name);

		return 0;

	}

	case SDT_BOOLX:

		if (strcmp(str, "true")  == 0 || strcmp(str, "on")  == 0 || strcmp(str, "1") == 0)

			return (void*)true;

		if (strcmp(str, "false") == 0 || strcmp(str, "off") == 0 || strcmp(str, "0") == 0)

			return (void*)false;

		ShowInfoF("ini: invalid setting value '%s' for '%s'", str, desc->name);

		break;

	case SDT_STRING:

	case SDT_INTLIST: return str;

	}

	return NULL;

}

/** Set the value of a setting and if needed clamp the value to

 * the preset minimum and maximum.

 * @param ptr the variable itself

 * @param sd pointer to the 'information'-database of the variable

 * @param val signed long version of the new value

 * @pre SettingDesc is of type SDT_BOOLX, SDT_NUMX,

 * SDT_ONEOFMANY or SDT_MANYOFMANY. Other types are not supported as of now */

static void Write_ValidateSetting(void *ptr, const SettingDesc *sd, int32 val)

{

	const SettingDescBase *sdb = &sd->desc;

	if (sdb->cmd != SDT_BOOLX &&

			sdb->cmd != SDT_NUMX &&

			sdb->cmd != SDT_ONEOFMANY &&

			sdb->cmd != SDT_MANYOFMANY) {

		return;

	}

	/* We cannot know the maximum value of a bitset variable, so just have faith */

	if (sdb->cmd != SDT_MANYOFMANY) {

		/* We need to take special care of the uint32 type as we receive from the function

		 * a signed integer. While here also bail out on 64-bit settings as those are not

		 * supported. Unsigned 8 and 16-bit variables are safe since they fit into a signed

		 * 32-bit variable

		 * TODO: Support 64-bit settings/variables */

		switch (GetVarMemType(sd->save.conv)) {

			case SLE_VAR_BL:

			case SLE_VAR_I8:

			case SLE_VAR_U8:

			case SLE_VAR_I16:

			case SLE_VAR_U16:

			case SLE_VAR_I32: {

				/* Override the minimum value. No value below sdb->min, except special value 0 */

				int32 min = ((sdb->flags & SGF_0ISDISABLED) && val <= sdb->min) ? 0 : sdb->min;

				val = clamp(val, min, sdb->max);

			} break;

			case SLE_VAR_U32: {

				/* Override the minimum value. No value below sdb->min, except special value 0 */

				uint min = ((sdb->flags & SGF_0ISDISABLED) && (uint)val <= (uint)sdb->min) ? 0 : sdb->min;

				WriteValue(ptr, SLE_VAR_U32, (int64)clampu(val, min, sdb->max));

				return;

			}

			case SLE_VAR_I64:

			case SLE_VAR_U64:

			default: NOT_REACHED(); break;

		}

	}

	WriteValue(ptr, sd->save.conv, (int64)val);

}

/** Load values from a group of an IniFile structure into the internal representation

 * @param ini pointer to IniFile structure that holds administrative information

 * @param sd pointer to SettingDesc structure whose internally pointed variables will

 *        be given values

 * @param grpname the group of the IniFile to search in for the new values */

static void ini_load_settings(IniFile *ini, const SettingDesc *sd, const char *grpname, void *object)

{

	IniGroup *group;

	IniGroup *group_def = ini_getgroup(ini, grpname, -1);

	IniItem *item;

	const void *p;

	void *ptr;

	const char *s;

	for (; sd->save.cmd != SL_END; sd++) {

		const SettingDescBase *sdb = &sd->desc;

		const SaveLoad        *sld = &sd->save;

		if (!SlIsObjectCurrentlyValid(sld->version_from, sld->version_to)) continue;

		// XXX - wtf is this?? (group override?)

		s = strchr(sdb->name, '.');

		if (s != NULL) {

			group = ini_getgroup(ini, sdb->name, s - sdb->name);

			s++;

		} else {

			s = sdb->name;

			group = group_def;

		}

		item = ini_getitem(group, s, false);

		p = (item == NULL) ? sdb->def : string_to_val(sdb, item->value);

		ptr = GetVariableAddress(object, sld);

		switch (sdb->cmd) {

		case SDT_BOOLX: /* All four are various types of (integer) numbers */

		case SDT_NUMX:

		case SDT_ONEOFMANY:

		case SDT_MANYOFMANY:

			Write_ValidateSetting(ptr, sd, (unsigned long)p); break;

		case SDT_STRING:

			switch (GetVarMemType(sld->conv)) {

				case SLE_VAR_STRB:

				case SLE_VAR_STRBQ:

					if (p != NULL) ttd_strlcpy((char*)ptr, p, sld->length);

					break;

				case SLE_VAR_STR:

				case SLE_VAR_STRQ:

					if (p != NULL) {

						free(*(char**)ptr);

						*(char**)ptr = strdup((const char*)p);

					}

					break;

				case SLE_VAR_CHAR: *(char*)ptr = *(char*)p; break;

				default: NOT_REACHED(); break;

			}

			break;

		case SDT_INTLIST: {

			if (!load_intlist(p, ptr, sld->length, GetVarMemType(sld->conv)))

				ShowInfoF("ini: error in array '%s'", sdb->name);

			break;

		}

		default: NOT_REACHED(); break;

		}

	}

}

/** Save the values of settings to the inifile.

 * @param ini pointer to IniFile structure

 * @param sd read-only SettingDesc structure which contains the unmodified,

 *        loaded values of the configuration file and various information about it

 * @param grpname holds the name of the group (eg. [network]) where these will be saved

 * The function works as follows: for each item in the SettingDesc structure we

 * have a look if the value has changed since we started the game (the original

 * values are reloaded when saving). If settings indeed have changed, we get

 * these and save them.

 */

static void ini_save_settings(IniFile *ini, const SettingDesc *sd, const char *grpname, void *object)

{

	IniGroup *group_def = NULL, *group;

	IniItem *item;

	char buf[512];

	const char *s;

	void *ptr;

	for (; sd->save.cmd != SL_END; sd++) {

		const SettingDescBase *sdb = &sd->desc;

		const SaveLoad        *sld = &sd->save;

		/* If the setting is not saved to the configuration

		 * file, just continue with the next setting */

		if (!SlIsObjectCurrentlyValid(sld->version_from, sld->version_to)) continue;

		if (sld->conv & SLF_CONFIG_NO) continue;

		// XXX - wtf is this?? (group override?)

		s = strchr(sdb->name, '.');

		if (s != NULL) {

			group = ini_getgroup(ini, sdb->name, s - sdb->name);

			s++;

		} else {

			if (group_def == NULL) group_def = ini_getgroup(ini, grpname, -1);

			s = sdb->name;

			group = group_def;

		}

		item = ini_getitem(group, s, true);

		ptr = GetVariableAddress(object, sld);

		if (item->value != NULL) {

			// check if the value is the same as the old value

			const void *p = string_to_val(sdb, item->value);

			/* The main type of a variable/setting is in bytes 8-15

			 * The subtype (what kind of numbers do we have there) is in 0-7 */

			switch (sdb->cmd) {

			case SDT_BOOLX:

			case SDT_NUMX:

			case SDT_ONEOFMANY:

			case SDT_MANYOFMANY: