/* 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/>.
 *
 */

#ifndef NUVIE_USECODE_USECODE_H
#define NUVIE_USECODE_USECODE_H

#include "ultima/shared/std/string.h"
#include "ultima/nuvie/misc/call_back.h"
#include "ultima/nuvie/misc/map_entity.h"
#include "ultima/nuvie/core/obj_manager.h"
#include "ultima/nuvie/core/player.h"

namespace Ultima {
namespace Nuvie {

// The game triggers one of these events on an object to activate its UseCode
// function(s). The return value meaning is different for each event.
#define USE_EVENT_USE     0x01 /* return value undefined */
#define USE_EVENT_LOOK    0x02 /* true: allow search, false: disallow search */
#define USE_EVENT_PASS    0x04 /* true: do normal move, false: object blocks */
#define USE_EVENT_MESSAGE 0x08 /* internal message or data return */
#define USE_EVENT_SEARCH  0x10 /*undefined (true = had objects?); might remove*/
//#define USE_EVENT_ON      0x20 /* post-move/idle */
#define USE_EVENT_MOVE    0x40 /* true: move object, false: don't move object */
#define USE_EVENT_LOAD    0x80 /* return value undefined */
#define USE_EVENT_READY   0x0100 /* true: object may be equipped */
#define USE_EVENT_GET     0x0200 /* true: do normal get */
#define USE_EVENT_DROP    0x0400 /* true: do normal drop */
#define USE_EVENT_INPUT_CANCEL 0x501 /* note this shares a bit with USE_EVENT_USE so it can pass through uc_event(). return undefined */
//#define USE_EVENT_NEAR    0x00 /* mirrors; might use ON with distance val */
//#define USE_EVENT_ATTACK  0x00 /* doors, chests, mirrors */
//#define USE_EVENT_ENTER   0x00 /* object enters view (clocks) */
//#define USE_EVENT_LEAVE   0x00 /* object leaves view */

typedef uint16 UseCodeEvent;

/* Events:
 * USE
 * Returns: undefined
 * Use the object.
 * actor_ref - the actor using it (the player actor typically)
 *
 * PASS (Quest Barrier)
 * Returns: True if actor may move, False if object blocks
 * Called when an actor attempts to step onto an object.
 * actor_ref - actor trying to pass
 * mapcoord_ref - location the actor is trying to pass (for multi-tile objects)
 *
 * LOOK (signs)
 * Returns: True if an object can be searched
 * Called when someone looks at the object. Some objects aren't searched (books
 * for example) and should return false.
 *
 * MESSAGE (fumaroles, earthquakes?, powder kegs, clocks)
 * An internal event from the engine. It must have been previously requested.
 * Includes TIMED events, and DATA returns. Be careful that the object still
 * exists.
 *
 * MOVE (cannons)
 * Returns: True to push object to the new position
 * Use this to perform special move functions for some objects. A cannon can be
 * aimed with MOVE.
 * mapcoord_ref - target location
 *
 * (UN)LOAD unimplemented (fumaroles)
 * Returns: undefined
 * Called when the object is cached in or out (or when it would have been in the
 * original game... about 16 to 32 spaces away), and when new objects are created.
 * It can be used to start timers, or to hatch eggs.
 *
 * Actor NEAR unimplemented (mirrors)
 * Set something to happen when an actor moves close to or away from object.
 * Distance will be used.
 *
 * Actor ON (chairs, traps) unimplemented
 * Returns: undefined
 * Called each turn for any objects in the view-area with actors standing on
 * them.
 *
 * ENTER view-area unimplemented
 *
 * LEAVE view-area unimplemented
 * Enter and leave will be used to start and stop sound effects. Distance will
 * be used.
 *
 * (UN)READY (Amulet of Submission)
 * Returns: True if the object may be worn, or removed
 * This is called before the object is is equipped or removed. Check the
 * object's flags to determine if it is being equipped or not. (if its readied
 * flag is set it is being removed). Special un/ready functions can be created
 * with this.
 * actor_ref - the actor un/readying it
 *
 * ATTACK (doors, chests)
 *
 * DROP (breakables, torches)
 * Returns: True to allow normal drop at the target.
 * Special drop functions can be created with this.
 * actor_ref - the actor dropping it
 * mapcoord_ref - the desired drop target
 *
 * GET (torches, runes?)
 * Returns: True if the actor can get the object.
 * Special get functions can be created with this.
 * actor_ref - the actor getting it
 *
 * SEARCH (graves, secret doors)
 * Returns: True if the object contained other objects.
 * FIXME: might remove this and add as a player action
 *
 */

typedef enum {
	USE,
	GET,
	MOVE
} UseCodeType;

const char *useCodeTypeToString(UseCodeType type);

class ActorManager;
class Configuration;
class Events;
class Game;
class Map;
class MsgScroll;
class MapCoord;
class Party;
class Player;
class Script;
class ScriptThread;

class UseCode {
private:
	ScriptThread *script_thread;

protected:
	Game *game;
	const Configuration *config;
	ObjManager *obj_manager;
	Map *map;
	Player *player;
	MsgScroll *scroll;
	ActorManager *actor_manager;
	Party *party;
	Script *script;

// pass parameters to usecode functions via items (nullptr itemref is unset)
	struct {
		uint32 *uint_ref;
		sint32 *sint_ref;
		Obj *obj_ref;
		Actor *actor_ref, *actor2_ref;
		MapCoord *mapcoord_ref;
		CallbackMessage *msg_ref;
		Std::string *string_ref;
		MapEntity *ent_ref;
		char *data_ref;
	} items;
	void clear_items();

public:

	UseCode(Game *g, const Configuration *cfg);
	virtual ~UseCode();

	virtual bool init(ObjManager *om, Map *m, Player *p, MsgScroll *ms);

	bool use_obj(uint16 x, uint16 y, uint8 z, Obj *src_obj = nullptr);
	bool use_obj(Obj *obj, Obj *src_obj = nullptr) {
		return (use_obj(obj, player->get_actor()));    // ??
	}

	virtual bool use_obj(Obj *obj, Actor *actor);
	virtual bool look_obj(Obj *obj, Actor *actor)   {
		return false;
	}
	virtual bool pass_obj(Obj *obj, Actor *actor, uint16 x, uint16 y) {
		return false;
	}
	virtual bool search_obj(Obj *obj, Actor *actor) {
		return false;
	}
	virtual bool move_obj(Obj *obj, sint16 rel_x, sint16 rel_y);
	virtual bool load_obj(Obj *obj)                 {
		return false;
	}
	virtual bool message_obj(Obj *obj, CallbackMessage msg, void *msg_data) {
		return false;
	}
	virtual bool ready_obj(Obj *obj, Actor *actor);
	virtual bool get_obj(Obj *obj, Actor *actor)    {
		return false;
	}
	virtual bool drop_obj(Obj *obj, Actor *actor, uint16 x, uint16 y, uint16 qty = 0) {
		return false;
	}

	virtual bool has_usecode(Obj *obj, UseCodeEvent ev = USE_EVENT_USE);
	virtual bool has_usecode(Actor *actor, UseCodeEvent ev = USE_EVENT_USE) {
		return false;
	}
	virtual bool has_lookcode(Obj *obj) {
		return has_usecode(obj, USE_EVENT_LOOK);
	}
	virtual bool has_passcode(Obj *obj) {
		return has_usecode(obj, USE_EVENT_PASS);
	}
	virtual bool has_movecode(Obj *obj) {
		return has_usecode(obj, USE_EVENT_MOVE);
	}
	virtual bool has_loadcode(Obj *obj) {
		return has_usecode(obj, USE_EVENT_LOAD);
	}
	virtual bool has_readycode(Obj *obj) {
		return has_usecode(obj, USE_EVENT_READY);
	}
	virtual bool cannot_unready(const Obj *obj) const {
		return false;
	}
	virtual bool has_getcode(Obj *obj)  {
		return has_usecode(obj, USE_EVENT_GET);
	}
	virtual bool has_dropcode(Obj *obj) {
		return has_usecode(obj, USE_EVENT_DROP);
	}

	bool is_door(const Obj *obj) const {
		return (is_locked_door(obj) || is_unlocked_door(obj));
	}
	virtual bool is_locked_door(const Obj *obj) const {
		return false;
	}
	virtual bool is_unlocked_door(const Obj *obj) const {
		return false;
	}
	virtual bool is_closed_door(const Obj *obj) const {
		return false;
	}
	virtual bool process_effects(Obj *container_obj, Actor *actor) {
		return false;
	}
	virtual bool is_food(const Obj *obj) const {
		return false;
	}
	virtual bool is_container(const Obj *obj) const;
	virtual bool is_container(uint16 obj_n, uint8 frame_n) const {
		return false;
	}
	virtual bool is_readable(const Obj *obj) const {
		return false;
	}
	virtual bool is_chest(const Obj *obj) const {
		return false;
	}

	void set_itemref(sint32 *val) {
		items.sint_ref = val;
	}
	void set_itemref(Obj *val)   {
		items.obj_ref = val;
	}
	void set_itemref(Actor *val, Actor *val2 = nullptr) {
		items.actor_ref = val;
		items.actor2_ref = val2;
	}
	void set_itemref(MapCoord *val)   {
		items.mapcoord_ref = val;
	}

	Obj *get_obj_from_container(Obj *obj);
	bool search_container(Obj *obj, bool show_string = true);
	Obj *destroy_obj(Obj *obj, uint32 count = 0, bool run_usecode = true);
	bool out_of_use_range(Obj *obj, bool check_enemies);

	ScriptThread *get_running_script();
	bool is_script_running();

protected:

	void toggle_frame(Obj *obj);
	void dbg_print_event(UseCodeEvent event, Obj *obj);

};

} // End of namespace Nuvie
} // End of namespace Ultima

#endif