/* 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.
 *
 * $URL$
 * $Id$
 *
 */

/* Savegame handling for EngineState structs. Makes heavy use of cfsml magic. */
/* DON'T EDIT savegame.cpp ! Only modify savegame.cfsml, if something needs
** to be changed. Refer to freesci/docs/misc/cfsml.spec if you don't understand
** savegame.cfsml. If this doesn't solve your problem, contact the maintainer.
*/

#include <stdarg.h>
#include <time.h>	// FIXME: For struct tm
#include "sci/include/sci_memory.h"
#include "sci/include/gfx_operations.h"
#include "sci/include/sfx_engine.h"
#include "sci/include/engine.h"
#include "sci/engine/heap.h"
#include "common/stream.h"
#include "common/system.h"

#ifdef _MSC_VER
#include <direct.h>
#endif

#ifdef _WIN32
#pragma warning( disable : 4101 )
#endif

namespace Sci {

#define HUNK_TYPE_GFX_SNAPSHOT_STRING "g\n"

/* Missing:
** - SFXdriver
** - File input/output state (this is likely not to happen)
*/


const unsigned int PRINTFBUFLEN = 128;
int WSprintf(Common::WriteStream* str, const char *format, ...) {
	va_list args;
	char buf[PRINTFBUFLEN]; // default buffer to prevent new in common case
	char* writebuf = buf;

	unsigned int s = PRINTFBUFLEN;
	unsigned int outsize;
	while (true) {
		va_start(args, format);
		outsize = vsnprintf(writebuf, s, format, args);
		va_end(args);

		if (outsize == s) {
			if (s > 16384) { // there are limits...
				delete[] writebuf;
				warning("Saving failed: line much too long");
				return 0;
			}
			s *= 2;
			if (writebuf != buf) delete[] writebuf;
			writebuf = new char[s];
		} else {
			break;
		}
	}

	uint32 ret = str->write(writebuf, outsize);

	if (writebuf != buf) delete[] writebuf;

	return ret;
}

int SRSgetc(Common::SeekableReadStream* str) {
	char c = str->readSByte();
	if (str->err() || str->eos())
		return EOF;
	return c;
}

char* SRSgets(char* s, int size, Common::SeekableReadStream* str) {
	return str->readLine_NEW(s, size);
}



static EngineState *_global_save_state;
// Needed for some graphical stuff.
#define FILE_VERSION _global_save_state->savegame_version


void write_reg_t(Common::WriteStream *fh, reg_t *foo) {
	WSprintf(fh, PREG, PRINT_REG(*foo));
}

int read_reg_t(Common::SeekableReadStream *fh, reg_t *foo, const char *lastval, int *line, int *hiteof) {
	unsigned int segment, offset;

	if (sscanf(lastval, PREG, &segment, &offset) < 2) {
		sciprintf("Error parsing reg_t on line %d\n", *line);
		return 1;
	}

	*foo = make_reg(segment, offset);
	return 0;
}

void write_sci_version(Common::WriteStream *fh, sci_version_t *foo) {
	WSprintf(fh, "%d.%03d.%03d", SCI_VERSION_MAJOR(*foo), SCI_VERSION_MINOR(*foo), SCI_VERSION_PATCHLEVEL(*foo));
}

int read_sci_version(Common::SeekableReadStream *fh, sci_version_t *foo, const char *lastval, int *line, int *hiteof) {
	return version_parse(lastval, foo);
}

void write_PTN(Common::WriteStream *fh, parse_tree_node_t *foo) {
	if (foo->type == PARSE_TREE_NODE_LEAF)
		WSprintf(fh, "L%d", foo->content.value);
	else
		WSprintf(fh, "B(%d,%d)", foo->content.branches[0], foo->content.branches[1]);
}

int read_PTN(Common::SeekableReadStream *fh, parse_tree_node_t *foo, const char *lastval, int *line, int *hiteof) {
	if (lastval[0] == 'L') {
		const char *c = lastval + 1;
		char *strend;

		while (*c && isspace(*c))
			++c;

		if (!*c)
			return 1;

		foo->content.value = strtol(c, &strend, 0);

		return (strend == c); // Error if nothing could be read

		return 0;
	} else if (lastval[0] == 'B') {
		const char *c = lastval + 1;
		char *strend;

		while (*c && isspace(*c))
			++c;
		if (*c++ != '(') return 1;
		while (*c && isspace(*c))
			++c;

		foo->content.branches[0] = strtol(c, &strend, 0);
		if (strend == c)
			return 1;
		c = strend;

		while (*c && isspace(*c))
			++c;
		if (*c++ != ',')
			return 1;

		while (*c && isspace(*c))
			++c;

		foo->content.branches[1] = strtol(c, &strend, 0);
		if (strend == c)
			return 1;
		c = strend;

		while (*c && isspace(*c))
			++c;
		if (*c++ != ')')
			return 1;

		return 0;
	} else return 1; // failure to parse anything
}


void write_menubar_tp(Common::WriteStream *fh, menubar_t **foo);
int read_menubar_tp(Common::SeekableReadStream *fh, menubar_t **foo, const char *lastval, int *line, int *hiteof);

void write_mem_obj_tp(Common::WriteStream *fh, mem_obj_t **foo);
int read_mem_obj_tp(Common::SeekableReadStream *fh, mem_obj_t **foo, const char *lastval, int *line, int *hiteof);

void write_int_hash_map_tp(Common::WriteStream *fh, int_hash_map_t **foo);
int read_int_hash_map_tp(Common::SeekableReadStream *fh, int_hash_map_t **foo, const char *lastval, int *line, int *hiteof);

void write_songlib_t(Common::WriteStream *fh, songlib_t *foo);
int read_songlib_t(Common::SeekableReadStream *fh, songlib_t *foo, const char *lastval, int *line, int *hiteof);

void write_int_hash_map_node_tp(Common::WriteStream *fh, int_hash_map_t::node_t **foo);
int read_int_hash_map_node_tp(Common::SeekableReadStream *fh, int_hash_map_t::node_t **foo, const char *lastval, int *line, int *hiteof);

int read_song_tp(Common::SeekableReadStream *fh, song_t **foo, const char *lastval, int *line, int *hiteof);

typedef mem_obj_t *mem_obj_ptr;

// Unused types
/*
TYPE long "long" LIKE int;
TYPE gint16 "gint16" LIKE int;

RECORD synonym_t "synonym_t" {
	int replaceant;
	int replacement;
}
*/

%CFSML

TYPE byte "byte" LIKE int;
TYPE seg_id_t "seg_id_t" LIKE int;
TYPE sci_version_t "sci_version_t" USING write_sci_version read_sci_version;
TYPE menubar_tp "menubar_t *" USING write_menubar_tp read_menubar_tp;
TYPE mem_obj_t "mem_obj_t" USING write_mem_obj_t read_mem_obj_t;
TYPE mem_obj_ptr "mem_obj_t *" USING write_mem_obj_tp read_mem_obj_tp;
TYPE reg_t "reg_t" USING write_reg_t read_reg_t;
TYPE size_t "size_t" LIKE int;
TYPE int_hash_map_tp "int_hash_map_t *" USING write_int_hash_map_tp read_int_hash_map_tp;
TYPE int_hash_map_node_tp "int_hash_map_t::node_t *" USING write_int_hash_map_node_tp read_int_hash_map_node_tp;
TYPE songlib_t "songlib_t" USING write_songlib_t read_songlib_t;
TYPE song_tp "song_t *" USING write_song_tp read_song_tp;
TYPE song_iterator_t "song_iterator_t" USING write_song_iterator_t read_song_iterator_t;
TYPE song_handle_t "song_handle_t" LIKE int;

RECORD song_t "song_t" {
	song_handle_t handle;
	int resource_num;
	int priority;
	int status;
	int restore_behavior;
	int restore_time;
	int loops;
	int hold;
}
	
RECORD int_hash_map_t "int_hash_map_t" {
	int base_value;
	int_hash_map_node_tp nodes[STATIC DCS_INT_HASH_MAX+1];
}

RECORD menu_item_t "menu_item_t" {
	int type;
	string keytext;
	int keytext_size;

	int flags;
	byte said[STATIC MENU_SAID_SPEC_SIZE];
	reg_t said_pos;
	string text;
	reg_t text_pos;
	int modifiers;
	int key;
	int enabled;
	int tag;
}

RECORD menu_t "menu_t" {
	string title;
	int title_width;
	int width;

	menu_item_t items[DYNAMIC items_nr];
}

RECORD menubar_t "menubar_t" {
	menu_t menus[DYNAMIC menus_nr];
}

RECORD SegManager "SegManager" {
	int_hash_map_tp id_seg_map;
	mem_obj_ptr heap[DYNAMIC heap_size];
	int heap_size;
	int reserved_id;
	int exports_wide;
	int sci1_1;
	int gc_mark_bits;
	size_t mem_allocated;
	seg_id_t clones_seg_id;
	seg_id_t lists_seg_id;
	seg_id_t nodes_seg_id;
}

RECORD class_t "class_t" {
	int script;
	reg_t reg;
}

RECORD sfx_state_t "sfx_state_t" {
	songlib_t songlib;
}

RECORD SavegameMetadata "SavegameMetadata" {
	string savegame_name;
	int savegame_version;
	string game_version;
	sci_version_t version;
	int savegame_date;
	int savegame_time;
}

RECORD EngineState "EngineState" {
	int savegame_version;

	string game_version;
	sci_version_t version;
	menubar_tp menubar;
	int status_bar_foreground;
	int status_bar_background;
	SegManager seg_manager;
	int classtable_size;
	class_t classtable[DYNAMIC classtable_size];
	sfx_state_t sound;
}

RECORD local_variables_t "local_variables_t" {
	int script_id;
	int nr;
	reg_t locals[DYNAMIC nr];
}

RECORD object_t "object_t" {
	int flags;
	reg_t pos;
	int variables_nr;
	int variable_names_nr;
	int methods_nr;
	reg_t variables[DYNAMIC variables_nr];
}

RECORD clone_t "clone_t" {
	int flags;
	reg_t pos;
	int variables_nr;
	int variable_names_nr;
	int methods_nr;
	reg_t variables[DYNAMIC variables_nr];
}

RECORD list_t "list_t" {
	reg_t first;
	reg_t last;
}

RECORD node_t "node_t" {
	reg_t pred;
	reg_t succ;
	reg_t key;
	reg_t value;
}

RECORD clone_entry_t "clone_entry_t" {
	int next_free;
	clone_t entry;
}

RECORD clone_table_t "clone_table_t" {
	int entries_nr;
	int first_free;
	int entries_used;
	int max_entry;
	clone_entry_t table[DYNAMIC entries_nr];
}

RECORD list_entry_t "list_entry_t" {
	int next_free;
	list_t entry;
}

RECORD list_table_t "list_table_t" {
	int entries_nr;
	int first_free;
	int entries_used;
	int max_entry;
	list_entry_t table[DYNAMIC entries_nr];
}

RECORD node_entry_t "node_entry_t" {
	int next_free;
	node_t entry;
}

RECORD node_table_t "node_table_t" {
	int entries_nr;
	int first_free;
	int entries_used;
	int max_entry;
	node_entry_t table[DYNAMIC entries_nr];
}

RECORD script_t "script_t" {
	int nr;

	size_t buf_size;
	size_t script_size;
	size_t heap_size;

	int_hash_map_tp obj_indices;
	int exports_nr;
	int synonyms_nr;
	int lockers;
	int objects_allocated;
	int objects_nr;
	object_t objects[DYNAMIC objects_allocated];

	int locals_offset;
	int locals_segment;

	int marked_as_deleted;
}

RECORD sys_string_t "sys_string_t" {
	string name;
	int max_size;
	string value;
}

RECORD sys_strings_t "sys_strings_t" {
	sys_string_t strings[STATIC SYS_STRINGS_MAX];
}

RECORD dynmem_t "dynmem_t" {
	int size;
	string description;
	byte buf[DYNAMIC size];
}

%END CFSML

void write_songlib_t(Common::WriteStream *fh, songlib_t *songlib) {
	song_t *seeker = *(songlib->lib);
	int songcount = song_lib_count(*songlib);

	WSprintf(fh, "{\n");
	WSprintf(fh, "songcount = %d\n", songcount);
	WSprintf(fh, "list = \n");
	WSprintf(fh, "[\n");
	while (seeker) {
		seeker->restore_time = seeker->it->get_timepos(seeker->it);
		%CFSMLWRITE song_t seeker INTO fh;
		seeker = seeker->next;
	}
	WSprintf(fh, "]\n");
	WSprintf(fh, "}\n");
}

int read_songlib_t(Common::SeekableReadStream *fh, songlib_t *songlib, const char *lastval, int *line, int *hiteof) {
	int songcount;
	int i;
	song_t *newsong;

	if (strcmp(lastval, "{")) {
		_cfsml_error("Opening brackets expected at line %d\n", *line);
		return CFSML_FAILURE;
	}
	// FIXME: error checking
	Common::String l = fh->readLine();
	sscanf(l.c_str(), "songcount = %d", &songcount);
	l = fh->readLine(); // "list = "
	l = fh->readLine(); // "["
	*line += 4;
	song_lib_init(songlib);
	for (i = 0; i < songcount; i++) {
		%CFSMLREAD song_tp &newsong FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line;
		song_lib_add(*songlib, newsong);
	}  
	l = fh->readLine(); // "]"
	l = fh->readLine(); // "}"
	*line += 2;
	return 0;
}

static struct {
	int type;
	const char *name;
} mem_obj_string_names[] = {
	{MEM_OBJ_INVALID, "INVALID"},
	{MEM_OBJ_SCRIPT, "SCRIPT"},
	{MEM_OBJ_CLONES, "CLONES"},
	{MEM_OBJ_LOCALS, "LOCALS"},
	{MEM_OBJ_STACK, "STACK"},
	{MEM_OBJ_SYS_STRINGS,"SYS_STRINGS"},
	{MEM_OBJ_LISTS,"LISTS"},
	{MEM_OBJ_NODES,"NODES"},
	{MEM_OBJ_HUNK,"HUNK"},
	{MEM_OBJ_DYNMEM,"DYNMEM"}};

int mem_obj_string_to_enum(const char *str) {
	int i;

	for (i = 0; i <= MEM_OBJ_MAX; i++) {
		if (!scumm_stricmp(mem_obj_string_names[i].name, str))
			return i;
	}

	return -1;
}

void write_int_hash_map_tp(Common::WriteStream *fh, int_hash_map_t **foo) {
	%CFSMLWRITE int_hash_map_t *foo INTO fh;
}

void write_song_tp(Common::WriteStream *fh, song_t **foo) {
	%CFSMLWRITE song_t *foo INTO fh;
}

song_iterator_t *build_iterator(EngineState *s, int song_nr, int type, songit_id_t id);

int read_song_tp(Common::SeekableReadStream *fh, song_t **foo, const char *lastval, int *line, int *hiteof) {
	char *token;
	int assignment;
	*foo = (song_t*) malloc(sizeof(song_t));
	token = _cfsml_get_identifier(fh, line, hiteof, &assignment);
	%CFSMLREAD song_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN token LINECOUNTER *line;
	(*foo)->delay = 0;
	(*foo)->it = NULL;
	(*foo)->next_playing = (*foo)->next_stopping = (*foo)->next = NULL;
	return 0;
}

int read_int_hash_map_tp(Common::SeekableReadStream *fh, int_hash_map_t **foo, const char *lastval, int *line, int *hiteof) {
	*foo = new int_hash_map_t;
	%CFSMLREAD int_hash_map_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line;
	(*foo)->holes = NULL;
	return 0;
}

void write_int_hash_map_node_tp(Common::WriteStream *fh, int_hash_map_t::node_t **foo) {
	if (!(*foo)) {
		WSprintf(fh, "\\null");
	} else {
		WSprintf(fh,"[\n%d=>%d\n", (*foo)->name, (*foo)->value);
		if ((*foo)->next) {
			%CFSMLWRITE int_hash_map_node_tp &((*foo)->next) INTO fh;
		} else
			WSprintf(fh, "L");
		WSprintf(fh, "]");
	}
}

int read_int_hash_map_node_tp(Common::SeekableReadStream *fh, int_hash_map_t::node_t **foo, const char *lastval, int *line, int *hiteof) {
	static char buffer[80];

	if (lastval[0] == '\\') {
		*foo = NULL; // No hash map node
	} else {
		*foo = (int_hash_map_t::node_t*)malloc(sizeof(int_hash_map_t::node_t));
		if (lastval[0] != '[') {
			sciprintf("Expected opening bracket in hash_map_node_t on line %d\n", *line);
			return 1;
		}
		
		do {
			(*line)++;
			SRSgets(buffer, 80, fh);
			if (buffer[0] == 'L') {
				(*foo)->next = NULL;
				buffer[0] = buffer[1];
			} // HACK: deliberately no else clause here
			if (buffer[0] == ']')  {
				break;
			}
			else if (buffer[0] == '[') {
				if (read_int_hash_map_node_tp(fh, &((*foo)->next), buffer, line, hiteof))
					return 1;
			}
			else if (sscanf(buffer, "%d=>%d", &((*foo)->name), &((*foo)->value))<2) {
				sciprintf("Error parsing hash_map_node_t on line %d\n", *line);
				return 1;
			}
		} while (1);
	}

	return 0;
}

void write_menubar_tp(Common::WriteStream *fh, menubar_t **foo) {
	if (*foo) {
		%CFSMLWRITE menubar_t (*foo) INTO fh;
	} else { // Nothing to write
		WSprintf(fh, "\\null\\");
	}
}


int read_menubar_tp(Common::SeekableReadStream *fh, menubar_t **foo, const char *lastval, int *line, int *hiteof) {
	if (lastval[0] == '\\') {
		*foo = NULL; // No menu bar
	} else {
		*foo = (menubar_t *) sci_malloc(sizeof(menubar_t));
		%CFSMLREAD menubar_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line;
	}
	return *hiteof;
}

void write_mem_obj_t(Common::WriteStream *fh, mem_obj_t *foo) {
	WSprintf(fh, "%s\n", mem_obj_string_names[foo->type].name);	
	%CFSMLWRITE int &foo->segmgr_id INTO fh;
	switch (foo->type) {
	case MEM_OBJ_SCRIPT:
		%CFSMLWRITE script_t &foo->data.script INTO fh;
	break;
	case MEM_OBJ_CLONES:
		%CFSMLWRITE clone_table_t &foo->data.clones INTO fh;
	break;
	case MEM_OBJ_LOCALS:
		%CFSMLWRITE local_variables_t &foo->data.locals INTO fh;
	break;
	case MEM_OBJ_SYS_STRINGS:
		%CFSMLWRITE sys_strings_t &foo->data.sys_strings INTO fh;
	break;
	case MEM_OBJ_STACK:
		%CFSMLWRITE int &foo->data.stack.nr INTO fh;
	break;
	case MEM_OBJ_HUNK:
		break;
	case MEM_OBJ_LISTS:	
		%CFSMLWRITE list_table_t &foo->data.lists INTO fh;
	break;
	case MEM_OBJ_NODES:	
		%CFSMLWRITE node_table_t &foo->data.nodes INTO fh;
	break;
	case MEM_OBJ_DYNMEM:
		%CFSMLWRITE dynmem_t  &foo->data.dynmem INTO fh;
	break;
	}
}

int read_mem_obj_t(Common::SeekableReadStream *fh, mem_obj_t *foo, const char *lastval, int *line, int *hiteof) {
	foo->type = mem_obj_string_to_enum(lastval);
	if (foo->type < 0) {
		sciprintf("Unknown mem_obj_t type %s on line %d\n", lastval, *line);
		return 1;
	}

	%CFSMLREAD int &foo->segmgr_id FROM fh ERRVAR *hiteof LINECOUNTER *line;
	switch (foo->type) {
	case MEM_OBJ_SCRIPT:
		%CFSMLREAD script_t &foo->data.script FROM fh ERRVAR *hiteof LINECOUNTER *line;
	break;
	case MEM_OBJ_CLONES:
		%CFSMLREAD clone_table_t &foo->data.clones FROM fh ERRVAR *hiteof LINECOUNTER *line;
	break;
	case MEM_OBJ_LOCALS:
		%CFSMLREAD local_variables_t &foo->data.locals FROM fh ERRVAR *hiteof LINECOUNTER *line;
	break;
	case MEM_OBJ_SYS_STRINGS:
		%CFSMLREAD sys_strings_t &foo->data.sys_strings FROM fh ERRVAR *hiteof LINECOUNTER *line;
	break;
	case MEM_OBJ_LISTS:
		%CFSMLREAD list_table_t &foo->data.lists FROM fh ERRVAR *hiteof LINECOUNTER *line;
	break;
	case MEM_OBJ_NODES:
		%CFSMLREAD node_table_t &foo->data.nodes FROM fh ERRVAR *hiteof LINECOUNTER *line;
	break;
	case MEM_OBJ_STACK:
		%CFSMLREAD int &foo->data.stack.nr FROM fh ERRVAR *hiteof LINECOUNTER *line;
	foo->data.stack.entries = (reg_t *)sci_calloc(foo->data.stack.nr, sizeof(reg_t));
	break;
	case MEM_OBJ_HUNK:
		init_hunk_table(&foo->data.hunks);
		break;
	case MEM_OBJ_DYNMEM:
		%CFSMLREAD dynmem_t  &foo->data.dynmem FROM fh ERRVAR *hiteof LINECOUNTER *line;
	break;
	}

	return *hiteof;
}

void write_mem_obj_tp(Common::WriteStream *fh, mem_obj_t **foo) {
	if (*foo) {
		%CFSMLWRITE mem_obj_t (*foo) INTO fh;
	} else { // Nothing to write
		WSprintf(fh, "\\null\\");
	}
}

int read_mem_obj_tp(Common::SeekableReadStream *fh, mem_obj_t **foo, const char *lastval, int *line, int *hiteof) {
	if (lastval[0] == '\\') {
		*foo = NULL; // No menu bar
	} else {
		*foo = (mem_obj_t *)sci_malloc(sizeof(mem_obj_t));
		%CFSMLREAD mem_obj_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line;
		return *hiteof;
	}
	return 0;
}


// This function is called to undo some strange stuff done in preparation
// to writing a gamestate to disk
void _gamestate_unfrob(EngineState *s) {
}


int gamestate_save(EngineState *s, Common::WriteStream *fh, const char* savename) {
	tm curTime;
	g_system->getTimeAndDate(curTime);

	SavegameMetadata *meta = new SavegameMetadata;
	meta->savegame_version = FREESCI_CURRENT_SAVEGAME_VERSION;
	meta->savegame_name = savename;
	meta->version = s->version;
	meta->game_version = s->game_version;
	meta->savegame_date = ((curTime.tm_mday & 0xFF) << 24) | (((curTime.tm_mon + 1) & 0xFF) << 16) | ((curTime.tm_year + 1900) & 0xFFFF);
	meta->savegame_time = ((curTime.tm_hour & 0xFF) << 16) | (((curTime.tm_min) & 0xFF) << 8) | ((curTime.tm_sec) & 0xFF);
	fprintf(stderr, "date/time: %d %d\n", meta->savegame_date, meta->savegame_time);

	_global_save_state = s;
	s->savegame_version = FREESCI_CURRENT_SAVEGAME_VERSION;
	s->dyn_views_list_serial = (s->dyn_views)? s->dyn_views->serial : -2;
	s->drop_views_list_serial = (s->drop_views)? s->drop_views->serial : -2;
	s->port_serial = (s->port)? s->port->serial : -2;

	if (s->execution_stack_base) {
		sciprintf("Cannot save from below kernel function\n");
		return 1;
	}

/*
	if (s->sound_server) {
		if ((s->sound_server->save)(s, dirname)) {
			sciprintf("Saving failed for the sound subsystem\n");
			chdir("..");
			return 1;
		}
	}
*/
	// Calculate the time spent with this game
	s->game_time = g_system->getMillis() / 1000;

	%CFSMLWRITE SavegameMetadata meta INTO fh;
	%CFSMLWRITE EngineState s INTO fh;

	delete meta;

	_gamestate_unfrob(s);

	return 0;
}

static seg_id_t find_unique_seg_by_type(SegManager *self, int type) {
	int i;

	for (i = 0; i < self->heap_size; i++)
		if (self->heap[i] &&
		    self->heap[i]->type == type)
			return i;
	return -1;
}

static byte *find_unique_script_block(EngineState *s, byte *buf, int type) {
	int magic_pos_adder = s->version >= SCI_VERSION_FTU_NEW_SCRIPT_HEADER ? 0 : 2;

	buf += magic_pos_adder;
	do {
		int seeker_type = getUInt16(buf);
		int seeker_size;

		if (seeker_type == 0) break;
		if (seeker_type == type) return buf;

		seeker_size = getUInt16(buf + 2);
		buf += seeker_size;
	} while(1);

	return NULL;
}

static void reconstruct_stack(EngineState *retval) {
	seg_id_t stack_seg = find_unique_seg_by_type(&retval->seg_manager, MEM_OBJ_STACK);
	dstack_t *stack = &(retval->seg_manager.heap[stack_seg]->data.stack);

	retval->stack_segment = stack_seg;
	retval->stack_base = stack->entries;
	retval->stack_top = retval->stack_base + VM_STACK_SIZE;
}

static int clone_entry_used(clone_table_t *table, int n) {
	int backup;
	int seeker = table->first_free;
	clone_entry_t *entries = table->table;

	if (seeker == HEAPENTRY_INVALID) return 1;

	do {
		if (seeker == n) return 0;
		backup = seeker;
		seeker = entries[seeker].next_free;
	} while (entries[backup].next_free != HEAPENTRY_INVALID);

	return 1;
}

static void load_script(EngineState *s, seg_id_t seg) {
	resource_t *script, *heap = NULL;
	script_t *scr = &(s->seg_manager.heap[seg]->data.script);

	scr->buf = (byte *)malloc(scr->buf_size);

	script = scir_find_resource(s->resmgr, sci_script, scr->nr, 0);
	if (s->version >= SCI_VERSION(1,001,000))
		heap = scir_find_resource(s->resmgr, sci_heap, scr->nr, 0);

	switch (s->seg_manager.sci1_1) {
	case 0 :
		sm_mcpy_in_out(&s->seg_manager, 0, script->data, script->size, seg, SEG_ID);
		break;
	case 1 :
		sm_mcpy_in_out(&s->seg_manager, 0, script->data, script->size, seg, SEG_ID);
		sm_mcpy_in_out(&s->seg_manager, scr->script_size, heap->data, heap->size, seg, SEG_ID);
		break;
	}
}

static void reconstruct_scripts(EngineState *s, SegManager *self) {
	int i;
	mem_obj_t *mobj;
	for (i = 0; i < self->heap_size; i++) {
		if (self->heap[i]) {
			mobj = self->heap[i];
			switch (mobj->type)  {
			case MEM_OBJ_SCRIPT: {
				int j;
				script_t *scr = &mobj->data.script;

				load_script(s, i);
				scr->locals_block = scr->locals_segment == 0 ? NULL : &s->seg_manager.heap[scr->locals_segment]->data.locals;
				scr->export_table = (guint16 *) find_unique_script_block(s, scr->buf, sci_obj_exports);
				scr->synonyms = find_unique_script_block(s, scr->buf, sci_obj_synonyms);
				scr->code = NULL;
				scr->code_blocks_nr = 0;
				scr->code_blocks_allocated = 0;

				if (!self->sci1_1)
					scr->export_table += 3;
				
				for (j = 0; j < scr->objects_nr; j++) {
					byte *data = scr->buf + scr->objects[j].pos.offset;
					scr->objects[j].base = scr->buf;
					scr->objects[j].base_obj = data;
				}

			}
			}
		}
	}

	for (i = 0; i < self->heap_size; i++) {
		if (self->heap[i]) {
			mobj = self->heap[i];
			switch (mobj->type)  {
			case MEM_OBJ_SCRIPT: {
				int j;
				script_t *scr = &mobj->data.script;

				for (j = 0; j < scr->objects_nr; j++) {
					byte *data = scr->buf + scr->objects[j].pos.offset;

					if (self->sci1_1) {
						guint16 *funct_area = (guint16 *) (scr->buf + getUInt16( data + 6 ));
						guint16 *prop_area = (guint16 *) (scr->buf + getUInt16( data + 4 ));

						scr->objects[j].base_method = funct_area;
						scr->objects[j].base_vars = prop_area;
					} else {
						int funct_area = getUInt16( data + SCRIPT_FUNCTAREAPTR_OFFSET );
						object_t *base_obj;

						base_obj = obj_get(s, scr->objects[j].variables[SCRIPT_SPECIES_SELECTOR]);

						if (!base_obj) {
							sciprintf("Object without a base class: Script %d, index %d (reg address "PREG"\n",
								  scr->nr, j, PRINT_REG(scr->objects[j].variables[SCRIPT_SPECIES_SELECTOR]));
							continue;
						}
						scr->objects[j].variable_names_nr = base_obj->variables_nr;
						scr->objects[j].base_obj = base_obj->base_obj;

						scr->objects[j].base_method = (guint16 *) (data + funct_area);
						scr->objects[j].base_vars = (guint16 *) (data + scr->objects[j].variable_names_nr * 2 + SCRIPT_SELECTOR_OFFSET);
					}
				}
			}
			}
		}
	}
}

void reconstruct_clones(EngineState *s, SegManager *self) {
	int i;
	mem_obj_t *mobj;

	for (i = 0; i < self->heap_size; i++) {
		if (self->heap[i]) {
			mobj = self->heap[i];
			switch (mobj->type) {
			case MEM_OBJ_CLONES: {
				int j;
				clone_entry_t *seeker = mobj->data.clones.table;
				
				sciprintf("Free list: ");
				for (j = mobj->data.clones.first_free; j != HEAPENTRY_INVALID; j = mobj->data.clones.table[j].next_free) {
					sciprintf("%d ", j);
				}
				sciprintf("\n");

				sciprintf("Entries w/zero vars: ");
				for (j = 0; j < mobj->data.clones.max_entry; j++) {
					if (mobj->data.clones.table[j].entry.variables == NULL)
						sciprintf("%d ", j);
				}
				sciprintf("\n");

				for (j = 0; j < mobj->data.clones.max_entry; j++) {
 					object_t *base_obj;

					if (!clone_entry_used(&mobj->data.clones, j)) {
						seeker++;
						continue;
					}
					base_obj = obj_get(s, seeker->entry.variables[SCRIPT_SPECIES_SELECTOR]);
					if (!base_obj) {
						sciprintf("Clone entry without a base class: %d\n", j);
						seeker->entry.base = seeker->entry.base_obj = NULL;
						seeker->entry.base_vars = seeker->entry.base_method = NULL;
						continue;
					}
					seeker->entry.base = base_obj->base;
					seeker->entry.base_obj = base_obj->base_obj;
					seeker->entry.base_vars = base_obj->base_vars;
					seeker->entry.base_method = base_obj->base_method;

					seeker++;
				}

				break;
			}
			}
		}
	}
}

int _reset_graphics_input(EngineState *s);

song_iterator_t *new_fast_forward_iterator(song_iterator_t *it, int delta);

static void reconstruct_sounds(EngineState *s) {
	song_t *seeker;
	int it_type = s->resmgr->sci_version >= SCI_VERSION_01 ? SCI_SONG_ITERATOR_TYPE_SCI1 : SCI_SONG_ITERATOR_TYPE_SCI0;

	if (s->sound.songlib.lib)
		seeker = *(s->sound.songlib.lib);
	else {
		song_lib_init(&s->sound.songlib);
		seeker = NULL;
	}

	while (seeker) {
		song_iterator_t *base, *ff;
		int oldstatus;
		song_iterator_message_t msg;

		base = ff = build_iterator(s, seeker->resource_num, it_type, seeker->handle);
		if (seeker->restore_behavior == RESTORE_BEHAVIOR_CONTINUE)
			ff = (song_iterator_t *)new_fast_forward_iterator(base, seeker->restore_time);
		ff->init(ff);

		msg = songit_make_message(seeker->handle, SIMSG_SET_LOOPS(seeker->loops));
		songit_handle_message(&ff, msg);
		msg = songit_make_message(seeker->handle, SIMSG_SET_HOLD(seeker->hold));
		songit_handle_message(&ff, msg);

		oldstatus = seeker->status;
		seeker->status = SOUND_STATUS_STOPPED;
		seeker->it = ff;
		sfx_song_set_status(&s->sound, seeker->handle, oldstatus);
		seeker = seeker->next;
	}
}

EngineState *gamestate_restore(EngineState *s, Common::SeekableReadStream *fh) {
	int read_eof = 0;
	EngineState *retval;
	songlib_t temp;

/*
	if (s->sound_server) {
		if ((s->sound_server->restore)(s, dirname)) {
			sciprintf("Restoring failed for the sound subsystem\n");
			return NULL;
		}
	}
*/

	retval = (EngineState *) sci_malloc(sizeof(EngineState));

	memset(retval, 0, sizeof(EngineState));

	retval->savegame_version = -1;
	_global_save_state = retval;
	retval->gfx_state = s->gfx_state;

	SavegameMetadata* meta = new SavegameMetadata;
	memset(retval, 0, sizeof(SavegameMetadata));

	%CFSMLREAD-ATOMIC SavegameMetadata meta FROM fh ERRVAR read_eof;
	if ((meta->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) ||
	    (meta->savegame_version > FREESCI_CURRENT_SAVEGAME_VERSION)) {
		if (meta->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION)
			sciprintf("Old savegame version detected- can't load\n");
		else
			sciprintf("Savegame version is %d- maximum supported is %0d\n", meta->savegame_version, FREESCI_CURRENT_SAVEGAME_VERSION);

		delete meta;
		return NULL;
	}

	delete meta;

	// Backwards compatibility settings
	retval->dyn_views = NULL;
	retval->drop_views = NULL;
	retval->port = NULL;
	retval->save_dir_copy_buf = NULL;

	retval->sound_mute = s->sound_mute;
	retval->sound_volume = s->sound_volume;

	%CFSMLREAD-ATOMIC EngineState retval FROM fh ERRVAR read_eof;

	sfx_exit(&s->sound);
	_gamestate_unfrob(retval);

	// Set exec stack base to zero
	retval->execution_stack_base = 0;
	retval->execution_stack_pos = 0;

	// Now copy all current state information
	// Graphics and input state:
	retval->animation_delay = s->animation_delay;
	retval->animation_granularity = s->animation_granularity;
	retval->gfx_state = s->gfx_state;

	retval->resmgr = s->resmgr;

	temp = retval->sound.songlib;
	sfx_init(&retval->sound, retval->resmgr, s->sfx_init_flags);
	retval->sfx_init_flags = s->sfx_init_flags;
	song_lib_free(retval->sound.songlib);
	retval->sound.songlib = temp;

	_reset_graphics_input(retval);
	reconstruct_stack(retval);
	reconstruct_scripts(retval, &retval->seg_manager);
	reconstruct_clones(retval, &retval->seg_manager);
	retval->game_obj = s->game_obj;
	retval->script_000 = &retval->seg_manager.heap[script_get_segment(s, 0, SCRIPT_GET_DONT_LOAD)]->data.script;
	retval->gc_countdown = GC_INTERVAL - 1;
	retval->save_dir_copy = make_reg(s->sys_strings_segment, SYS_STRING_SAVEDIR);
	retval->save_dir_edit_offset = 0;
	retval->sys_strings_segment = find_unique_seg_by_type(&retval->seg_manager, MEM_OBJ_SYS_STRINGS);
	retval->sys_strings = &(((mem_obj_t *)(GET_SEGMENT(retval->seg_manager, retval->sys_strings_segment, MEM_OBJ_SYS_STRINGS)))->data.sys_strings);
	sys_strings_restore(retval->sys_strings, s->sys_strings);

	// Time state:
	retval->last_wait_time = g_system->getMillis();

	// File IO state:
	retval->file_handles_nr = 2;
	retval->file_handles = (FILE **)sci_calloc(2, sizeof(FILE *));

	// static parser information:
	retval->parser_rules = s->parser_rules;
	retval->parser_words_nr = s->parser_words_nr;
	retval->parser_words = s->parser_words;
	retval->parser_suffices_nr = s->parser_suffices_nr;
	retval->parser_suffices = s->parser_suffices;
	retval->parser_branches_nr = s->parser_branches_nr;
	retval->parser_branches = s->parser_branches;

	// static VM/Kernel information:
	retval->selector_names_nr = s->selector_names_nr;
	retval->selector_names = s->selector_names;
	retval->kernel_names_nr = s->kernel_names_nr;
	retval->kernel_names = s->kernel_names;
	retval->kfunct_table = s->kfunct_table;
	retval->kfunct_nr = s->kfunct_nr;
	retval->opcodes = s->opcodes;

	memcpy(&(retval->selector_map), &(s->selector_map), sizeof(selector_map_t));

	retval->max_version = retval->version;
	retval->min_version = retval->version;
	retval->parser_base = make_reg(s->sys_strings_segment, SYS_STRING_PARSER_BASE);

	// Copy breakpoint information from current game instance
	retval->have_bp = s->have_bp;
	retval->bp_list = s->bp_list;

	retval->debug_mode = s->debug_mode;

	retval->resource_dir = s->resource_dir;
	retval->work_dir = s->work_dir;
	retval->kernel_opt_flags = 0;
	retval->have_mouse_flag = 1;

	retval->successor = NULL;
	retval->pic_priority_table = (int*)gfxop_get_pic_metainfo(retval->gfx_state);
	retval->game_name = sci_strdup(obj_get_name(retval, retval->game_obj));

	retval->sound.it = NULL;
	retval->sound.flags = s->sound.flags;
	retval->sound.song = NULL;
	retval->sound.suspended = s->sound.suspended;
	retval->sound.debug = s->sound.debug;
	reconstruct_sounds(retval);

	return retval;
}

bool get_savegame_metadata(Common::SeekableReadStream* stream, SavegameMetadata* meta) {
	int read_eof = 0;

	%CFSMLREAD-ATOMIC SavegameMetadata meta FROM stream ERRVAR read_eof;

	if (read_eof)
		return false;

	if ((meta->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) ||
	    (meta->savegame_version > FREESCI_CURRENT_SAVEGAME_VERSION)) {
		if (meta->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION)
			sciprintf("Old savegame version detected- can't load\n");
		else
			sciprintf("Savegame version is %d- maximum supported is %0d\n", meta->savegame_version, FREESCI_CURRENT_SAVEGAME_VERSION);

		return false;
	}

	return true;
}

} // End of namespace Sci