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

#include "common/str.h"
#include "m4/adv_r/adv_inv.h"
#include "m4/core/cstring.h"
#include "m4/core/errors.h"
#include "m4/mem/mem.h"
#include "m4/vars.h"

namespace M4 {

#define MAX_NAME_LENGTH 40

static char *inv_get_name(const Common::String &itemName);

InventoryBase::~InventoryBase() {
	for (int i = 0; i < _tail; i++) {
		mem_free(_objects[i]->name);
		mem_free(_objects[i]->verbs);

		mem_free_to_stash((void *)_objects[i], _G(inv_obj_mem_type));
	}
}

void InventoryBase::syncGame(Common::Serializer &s) {
	char invName[MAX_NAME_LENGTH];

	uint32 inv_size = _tail * (MAX_NAME_LENGTH + sizeof(uint32));
	s.syncAsUint32LE(inv_size);
	if (s.isLoading()) {
		assert((inv_size % (MAX_NAME_LENGTH + sizeof(uint32))) == 0);
		_tail = inv_size / (MAX_NAME_LENGTH + sizeof(uint32));
	}

	for (int32 i = 0; i < _tail; ++i) {
		char *objName = _G(inventory)->_objects[i]->name;
		uint32 scene = _G(inventory)->_objects[i]->scene;

		if (s.isLoading()) {
			s.syncBytes((byte *)invName, MAX_NAME_LENGTH);
			char *item = inv_get_name(invName);
			assert(item);

			s.syncAsUint32LE(scene);
			inv_put_thing_in(item, scene);

		} else {
			Common::strcpy_s(invName, MAX_NAME_LENGTH, objName);
			s.syncBytes((byte *)invName, MAX_NAME_LENGTH);
			s.syncAsUint32LE(scene);
		}

	}
}

bool inv_init(int32 num_objects) {
	term_message("Fluffing up the backpack", nullptr);
	_G(inventory)->_objects.resize(num_objects);

	if (!mem_register_stash_type(&_G(inv_obj_mem_type), sizeof(InvObj), num_objects, "obj"))
		error_show(FL, 'OOM!', "fail to mem_register_stash_type for inv_obj");

	for (int i = 0; i < num_objects; i++) {
		_G(inventory)->_objects[i] = (InvObj *)mem_get_from_stash(_G(inv_obj_mem_type), "obj");
		if (!_G(inventory)->_objects[i])
			error_show(FL, 'OOM!', "%d bytes", (int32)sizeof(InvObj));
	}

	_G(inventory)->_tail = 0;
	return true;
}

bool inv_register_thing(const Common::String &itemName, const Common::String &itemVerbs,
		int32 scene, int32 cel, int32 cursor) {
	char *s_name = mem_strdup(itemName.c_str());
	char *s_verbs = mem_strdup(itemVerbs.c_str());

	_G(inventory)->_objects[_G(inventory)->_tail]->name = nullptr;
	_G(inventory)->_objects[_G(inventory)->_tail]->verbs = nullptr;

	if (s_name) {
		cstrupr(s_name);
		_G(inventory)->_objects[_G(inventory)->_tail]->name = s_name;
	}

	if (s_verbs) {
		cstrupr(s_verbs);
		_G(inventory)->_objects[_G(inventory)->_tail]->verbs = s_verbs;
	}

	_G(inventory)->_objects[_G(inventory)->_tail]->scene = scene;
	_G(inventory)->_objects[_G(inventory)->_tail]->cel = cel;
	_G(inventory)->_objects[_G(inventory)->_tail]->cursor = cursor;

	_G(inventory)->_tail++;

	if (scene == BACKPACK) {
		_G(inventory)->add(s_name, s_verbs, cel, cursor);
	}

	return true;
}

//-------------------------------------------------------------------

int32 inv_where_is(const Common::String &itemName) {
	Common::String name = itemName;
	name.toUppercase();

	for (int i = 0; i < _G(inventory)->_tail; i++) {
		if (_G(inventory)->_objects[i]->name) {
			if (name.equals(_G(inventory)->_objects[i]->name)) {
				return _G(inventory)->_objects[i]->scene;
			}
		}
	}

	return UNKNOWN_OBJECT;
}

bool inv_player_has(const Common::String &itemName) {
	return (inv_where_is(itemName) == BACKPACK);
}

bool inv_put_thing_in(const Common::String &itemName, int32 scene) {
	Common::String name = itemName;
	name.toUppercase();

	for (int i = 0; i < _G(inventory)->_tail; i++) {
		if (_G(inventory)->_objects[i]->name) {
			if (name.equals(_G(inventory)->_objects[i]->name)) {
				// Remove object from backpack?
				if (_G(inventory)->_objects[i]->scene == BACKPACK && scene != BACKPACK) {
					_G(inventory)->remove(name);
				}
				_G(inventory)->_objects[i]->scene = scene;

				// Put object in backpack?
				if (scene == BACKPACK) {
					_G(inventory)->add(name, _G(inventory)->_objects[i]->verbs, _G(inventory)->_objects[i]->cel, _G(inventory)->_objects[i]->cursor);
				}
				return true;
			}
		}
	}

	return false;
}

int32 inv_get_cursor(const Common::String &itemName) {
	Common::String name = itemName;
	name.toUppercase();

	for (int i = 0; i < _G(inventory)->_tail; i++) {
		if (_G(inventory)->_objects[i]->name) {
			if (name.equals(_G(inventory)->_objects[i]->name)) {
				return _G(inventory)->_objects[i]->cursor;
			}
		}
	}

	return UNKNOWN_OBJECT;
}

int32 inv_get_cel(const Common::String &itemName) {
	Common::String name = itemName;
	name.toUppercase();

	for (int i = 0; i < _G(inventory)->_tail; i++) {
		if (_G(inventory)->_objects[i]->name) {
			if (name.equals(_G(inventory)->_objects[i]->name)) {
				return _G(inventory)->_objects[i]->cel;
			}
		}
	}
	return UNKNOWN_OBJECT;
}

const char *inv_get_verbs(const Common::String &itemName) {
	Common::String name = itemName;
	name.toUppercase();

	for (int i = 0; i < _G(inventory)->_tail; i++) {
		if (_G(inventory)->_objects[i]->name) {
			if (name.equals(_G(inventory)->_objects[i]->name)) {
				return _G(inventory)->_objects[i]->verbs;
			}
		}
	}

	return nullptr;
}

// This is provided so that when restoring a game from a save file,
// we store a pointer to the registered name, not to an unmanaged
// memory pointer.

static char *inv_get_name(const Common::String &itemName) {
	Common::String name = itemName;
	name.toUppercase();

	for (int i = 0; i < _G(inventory)->_tail; i++) {
		if (_G(inventory)->_objects[i]->name) {
			if (name.equals(_G(inventory)->_objects[i]->name)) {
				return _G(inventory)->_objects[i]->name;
			}
		}
	}

	return nullptr;
}

void inv_give_to_player(const Common::String &itemName) {
	inv_put_thing_in(itemName, BACKPACK);
}

void inv_move_object(const Common::String &itemName, int32 scene) {
	inv_put_thing_in(itemName, scene);
}

bool inv_object_is_here(const Common::String &itemName) {
	return (inv_where_is(itemName) == _G(game).room_id);
}

bool inv_object_in_scene(const Common::String &itemName, int32 scene) {
	return (inv_where_is(itemName) == scene);
}

} // End of namespace M4