/* 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 "ultima/nuvie/core/nuvie_defs.h"
#include "ultima/nuvie/core/game.h"
#include "ultima/nuvie/conf/configuration.h"
#include "ultima/nuvie/misc/u6_misc.h"
#include "ultima/nuvie/files/u6_lzw.h"
#include "ultima/nuvie/core/player.h"
#include "ultima/nuvie/core/party.h"
#include "ultima/nuvie/views/view_manager.h"
#include "ultima/nuvie/actors/actor_manager.h"
#include "ultima/nuvie/sound/sound_manager.h"
#include "ultima/nuvie/core/events.h"
#include "ultima/nuvie/gui/widgets/map_window.h"
#include "ultima/nuvie/core/converse_interpret.h"
#include "ultima/nuvie/core/converse_speech.h"
#include "ultima/nuvie/gui/widgets/converse_gump.h"
#include "ultima/nuvie/core/converse.h"
#include "ultima/nuvie/gui/gui.h"
#include "ultima/nuvie/gui/widgets/background.h"

namespace Ultima {
namespace Nuvie {

//#define CONVERSE_DEBUG


Converse::Converse() : config(nullptr), actors(nullptr), objects(nullptr),
		player(nullptr), views(nullptr), last_view(nullptr), scroll(nullptr),
		conv_i(nullptr), script(nullptr), npc(nullptr), npc_num(0), script_num(0),
		src(nullptr), src_num(0), allowed_input(nullptr), active(false),
		variables(nullptr), party_all_the_time(false), speech(nullptr),
		using_fmtowns(false), need_input(false), conversations_stop_music(false),
		gametype(NUVIE_GAME_NONE), _clock(nullptr) {
	ARRAYCLEAR(aname);
}


/* Initialize global classes from the game.
 */
void
Converse::init(const Configuration *cfg, nuvie_game_t t, MsgScroll *s, ActorManager *a,
			   GameClock *c, Player *p, ViewManager *v, ObjManager *o) {
	Std::string townsdir;

	config = cfg;
	scroll = s;
	actors = a;
	_clock = c;
	player = p;
	views = v;
	objects = o;
	gametype = t;

	cfg->value("config/cheats/party_all_the_time", party_all_the_time);
	cfg->value("config/audio/conversations_stop_music", conversations_stop_music, false);

	cfg->value("config/townsdir", townsdir, "");
	if (townsdir != "" && directory_exists(townsdir.c_str()))
		using_fmtowns = true;

	speech = new ConverseSpeech();
	speech->init(config);
}


Converse::~Converse() {
	if (running()) {
		reset();
		DEBUG(0, LEVEL_INFORMATIONAL, "End conversation\n");
	}
	unload_conv();

	delete speech;
}


/* Free up allocated memory, reset values for new conversation. (call only when
 * ending a conversation or quitting)
 */
void Converse::reset() {
	delete conv_i;
	conv_i = nullptr;
	set_input("");	// delete
	set_output("");	// clear output
	_name = "";		// clear name

	if (script) {
		delete script;
		script = nullptr;
	}

	if (allowed_input) {
		free(allowed_input);
		allowed_input = nullptr;
	}

	player->set_quest_flag((uint8)get_var(U6TALK_VAR_QUESTF));
	player->set_gargish_flag((uint8)get_var(U6TALK_VAR_GARGF));

	delete_variables();
}


/* Load `convfilename' as src.
 */
void Converse::load_conv(const Std::string &convfilename) {
	Common::Path conv_lib_str;
	if (gametype == NUVIE_GAME_U6 && using_fmtowns) {
		config->pathFromValue("config/townsdir", convfilename, conv_lib_str);
	} else {
		config_get_path(config, convfilename, conv_lib_str);
	}

	unload_conv();
	src_num = 0;
	if (gametype == NUVIE_GAME_U6) {
		src = new U6Lib_n;
		src->open(conv_lib_str, 4);
		src_num = (convfilename == "converse.a") ? 1 : (convfilename == "converse.b") ? 2 : 0;
	} else { // MD or SE gametype
		src = new U6Lib_n;
		src->open(conv_lib_str, 4, gametype);
		src_num = 1;
	}

#ifdef CONVERSE_DEBUG
	DEBUG(0, LEVEL_DEBUGGING, "Converse: load \"%s\"\n", convfilename.c_str());
#endif
}

uint32 Converse::get_script_num(uint8 a) {
	if (gametype == NUVIE_GAME_U6) {
		if (a > 200) { // (quick fix for U6: anything over 200 is a temporary npc)
			Actor *npcP = actors->get_actor(a);
			if (npcP->get_obj_n() == 373) // OBJ_U6_WISP
				a = 201;
			else if (npcP->get_obj_n() == 382) // OBJ_U6_GUARD
				a = 202;
		}
		//else if(a == 188)  // U6: temp. fix for shrines
		//   a = 191; // ??? -> Exodus
		//else if(a >= 191 && a <= 197) // shrines except spirituality & humility
		//   a += 2;
		//else if(a == 198)
		//   a = 192; // Spirituality -> Honesty
		//else if(a == 199)
		//   a = 200; // Humility -> Singularity
	}

	return a;
}

/* Check that loaded converse library (if any) has script for npc `a'. Load
 * another file if it doesn't.
 * Returns the real item number in the source.
 */
uint32 Converse::load_conv(uint8 a) {
	if (gametype == NUVIE_GAME_U6) {
		if (a <= 98) {
			if (src_num != 1)
				load_conv("converse.a");
		} else { // a >= 99
			if (src_num != 2)
				load_conv("converse.b");
		}
	} else {
		if (src_num != 1)
			load_conv("talk.lzc");
	}
// we want to return the real item number in the converse file.
	if (gametype == NUVIE_GAME_U6 && a > 98) {
		a -= 99;
	} else if (gametype == NUVIE_GAME_SE) {
		a -= 2;
	}
	return a;
}


/* Returns name of loaded source file, identified by `src_num'.
 */
const char *Converse::src_name() {
	if (src_num == 0)
		return "";
	if (gametype == NUVIE_GAME_U6)
		return ((src_num == 1) ? "converse.a" : "converse.b");
	if (gametype == NUVIE_GAME_MD)
		return "talk.lzc";
	if (gametype == NUVIE_GAME_SE)
		return "talk.lzc";

	return "";
}


/* Get an NPC conversation from the source file.
 * Returns new ConvScript object.
 */
ConvScript *Converse::load_script(uint32 n) {
	ConvScript *loaded = new ConvScript(src, n);
	if (!loaded->loaded()) {
		delete loaded;
		loaded = nullptr;
	} else
		DEBUG(0, LEVEL_INFORMATIONAL, "Read %s npc script (%s:%d)\n",
		      loaded->compressed ? "encoded" : "unencoded", src_name(), (unsigned int)n);
	return loaded;
}


/* Initialize Converse variable list, and set globals from game.
 */
void Converse::init_variables() {
	if (variables)
		delete_variables();

	variables = new converse_variables_s[U6TALK_VAR__LAST_ + 1];
	for (uint32 v = 0; v <= U6TALK_VAR__LAST_; v++) {
		variables[v].cv = 0;
		variables[v].sv = nullptr;
	}
	set_var(U6TALK_VAR_SEX, player->get_gender());
	set_var(U6TALK_VAR_KARMA, player->get_karma());
	set_var(U6TALK_VAR_GARGF, player->get_gargish_flag());
	set_var(U6TALK_VAR_PARTYLIVE, player->get_party()->get_party_size() - 1);
	// FIXME: count dead party members in PARTYALL, not in PARTYLIVE
	set_var(U6TALK_VAR_PARTYALL, get_var(U6TALK_VAR_PARTYLIVE));
	set_var(U6TALK_VAR_HP, player->get_actor()->get_hp());
	set_svar(U6TALK_VAR_NPC_NAME, npc_name(npc_num));
	set_svar(U6TALK_VAR_PLAYER_NAME, player->get_name());
	set_var(U6TALK_VAR_QUESTF, player->get_quest_flag());
	set_var(U6TALK_VAR_WORKTYPE, npc->get_worktype());
}


/* Free memory used by Converse variable list.
 */
void Converse::delete_variables() {
	for (uint32 v = 0; v <= U6TALK_VAR__LAST_; v++)
		if (variables[v].sv)
			free(variables[v].sv);
	delete [] variables;
	variables = nullptr;
}


/* Create new script interpreter for the current game.
 * Returns pointer to object which is derived from ConverseInterpret.
 */
ConverseInterpret *Converse::new_interpreter() {
	ConverseInterpret *ci = nullptr;
	switch (gametype) {
	case NUVIE_GAME_U6:
		ci = (ConverseInterpret *)new U6ConverseInterpret(this);
		break;
	case NUVIE_GAME_MD:
		ci = (ConverseInterpret *)new MDTalkInterpret(this);
		break;
	case NUVIE_GAME_SE:
		ci = (ConverseInterpret *)new SETalkInterpret(this);
		break;
	}
	return ci;
}


/* Returns false if a conversation cannot be started with the NPC. This
 * represents an internal error, and doesn't have anything to do with the NPC
 * not wanting/being able to talk to the Avatar.
 */
bool Converse::start(uint8 n) {
	uint32 real_script_num = 0; // The script number in the converse file.

	// load, but make sure previous script is unloaded first
	if (running())
		stop();
	if (!(npc = actors->get_actor(n)))
		return false;
	// get script num for npc number (and open file)
	script_num = get_script_num(n);
	real_script_num = load_conv(script_num);
	if (!src)
		return false;

	script = load_script(real_script_num);

	// begin
	if (script) {
		active = true;
		last_view = views->get_current_view();
		if (!(conv_i = new_interpreter())) {
			DEBUG(0, LEVEL_CRITICAL, "Can't talk: Unimplemented or unknown game type\n");
			return false;
		}
		views->close_all_gumps();
		// set current NPC and start conversation
		npc_num = n;
		init_variables();
		scroll->set_talking(true, actors->get_actor(npc_num));
		Game::get_game()->get_map_window()->set_walking(false);
		Game::get_game()->get_map_window()->set_looking(false);
		if (conversations_stop_music)
			Game::get_game()->get_sound_manager()->musicStop();
		//Game::get_game()->get_event()->set_mode(WAIT_MODE); // ignore player actions
		Game::get_game()->pause_user();
		Game::get_game()->get_gui()->unblock();
		scroll->set_autobreak(true);
		/* moved into ConverseGump::set_talking()
		if(Game::get_game()->is_new_style())
		{
		    scroll->Show();
		    scroll->set_input_mode(false);
		    scroll->clear_scroll();
		    ((ConverseGump *)scroll)->set_found_break_char(true);
		    //scroll->grab_focus();
		}
		*/
		show_portrait(npc_num);
		unwait();
		DEBUG(0, LEVEL_INFORMATIONAL, "Begin conversation with \"%s\" (npc %d)\n", npc_name(n), n);
		return true;
	}
	DEBUG(0, LEVEL_ERROR, "Failed to load npc %d from %s:%d\n",
	      n, src_name(), script_num);
	return false;
}


/* Stop execution of the current script.
 */
void Converse::stop() {
	scroll->set_talking(false);
	MsgScroll *system_scroll = Game::get_game()->get_scroll();

	if ((Game::get_game()->using_new_converse_gump() || scroll != system_scroll) && !scroll->is_converse_finished()) {
		return;
	}

	reset(); // free memory

	if (Game::get_game()->using_new_converse_gump()) {
		scroll->Hide();
		if (!Game::get_game()->is_new_style()) {
			Game::get_game()->get_event()->endAction(true);
			GUI::get_gui()->force_full_redraw(); // need to remove converse background
		}
	} else {


		system_scroll->set_autobreak(false);
		system_scroll->display_string("\n");
		system_scroll->display_prompt();

		if (scroll != system_scroll) { //if using an alternate scroll eg wou fullmap scroll.
			scroll->Hide();
		}
	}
	if (!Game::get_game()->is_new_style()) {
		if (last_view->set_party_member(last_view->get_party_member_num()) == false) // set party member left party
			last_view->prev_party_member(); // seems only needed with new converse gump but will leave here just in case
		views->set_current_view(last_view);
	}

	Game::get_game()->unpause_user();
	if (conversations_stop_music) {
		SoundManager *sm = Game::get_game()->get_sound_manager();
		if (sm->is_audio_enabled() && sm->is_music_enabled())
			sm->musicPlay();
	}
	Game::get_game()->get_event()->set_mode(MOVE_MODE); // return control to player

	active = false;
	DEBUG(0, LEVEL_INFORMATIONAL, "End conversation\n");
}


/* Returns true if there is input available (placed at `in_str'.)
 */
bool Converse::input() {
	if (scroll->has_input()) {
		Std::string s = scroll->get_input();
		set_input(s);
#ifdef CONVERSE_DEBUG
		DEBUG(0, LEVEL_DEBUGGING, "Converse: INPUT \"%s\"\n\n", get_input().c_str());
#endif
		return true;
	}
	return false;
}


/* Output string `s' or the current set output to the scroll view.
 */
void Converse::print(const char *s) {
#ifdef CONVERSE_DEBUG
	DEBUG(0, LEVEL_DEBUGGING, "Converse: PRINT \"%s\"\n\n", s ? s : get_output().c_str());
#endif
	if (s)
		scroll->display_string(s, MSGSCROLL_NO_MAP_DISPLAY);
	else
		scroll->display_string(get_output(), MSGSCROLL_NO_MAP_DISPLAY);
}

void Converse::print_prompt() {
	scroll->display_converse_prompt();
}

/* Get string value of variable `varnum'.
 */
const char *Converse::get_svar(uint8 varnum) {
	if (varnum <= U6TALK_VAR__LAST_ && variables[varnum].sv)
		return (const char *)variables[varnum].sv;
	return "";
}


/* Set string value of variable `varnum'.
 */
void Converse::set_svar(uint8 varnum, const char *set) {
	if (varnum <= U6TALK_VAR__LAST_)
		variables[varnum].sv = scumm_strdup(set);
}


/* Show portrait for npc `n'. The name will be shown for actors in the player
 * party, or those the player/avatar has met. The look-string will be shown for
 * anyone else.
 */
void Converse::show_portrait(uint8 n) {
	Game *game = Game::get_game();
	Actor *actor = (n == npc_num) ? npc : actors->get_actor(n);
	const char *nameret = nullptr;
	if (!actor)
		return;
	bool statue = (gametype == NUVIE_GAME_U6 && n >= 189 && n <= 191);
	if (gametype == NUVIE_GAME_U6 && n == 0) { // Pushme Pullyu
		Actor *real_actor = game->get_actor_manager()->get_actor(130);
		if (real_actor->is_met() || player->get_party()->contains_actor(real_actor))
			nameret = npc_name(130);
		else
			nameret = actors->look_actor(real_actor, false);
	} else if ((actor->is_met() || player->get_party()->contains_actor(actor))
	           && !statue) // they need to display statue of names
		nameret = npc_name(n);
	else
		nameret = actors->look_actor(actor, false);
	if (game->using_new_converse_gump()) {
		if ((game->is_original_plus() && game->get_converse_gump()->W() > game->get_game_width() - game->get_background()->get_border_width())
		        || game->is_orig_style())
			views->close_current_view();
		((ConverseGump *)scroll)->set_actor_portrait(actor);
	} else
		views->set_portrait_mode(actor, nameret);
}


/* Copy the NPC num's name from their conversation script. This is very U6
 * specific.
 * Returns the name as a non-modifiable string of 16 characters maximum. */
const char *Converse::npc_name(uint8 num) {
	ConvScript *temp_script;
	convscript_buffer s_pt;
	aname[15] = '\0';

// FIX (crashing)
//    if(actors->get_actor(num))
//        actors->get_actor(num)->set_name(name);

	if ((num == npc_num) && !_name.empty()) // use NPC name
		strncpy(aname, _name.c_str(), 15);
	else {                            // or load another script
//        uint32 temp_num = num;
		num = load_conv(get_script_num(num)); // get idx number; won't actually reload file
		temp_script = new ConvScript(src, num);
		s_pt = temp_script->get_buffer();
		if (!s_pt) {
			delete temp_script;
			return nullptr;
		}

		// read name up to LOOK section, convert "_" to "."
		uint32 c;
		for (c = 0; s_pt[c + 2] != 0xf1 && s_pt[c + 2] != 0xf3 && c <= 14; c++)
			aname[c] = s_pt[c + 2] != '_' ? s_pt[c + 2] : '.';

		aname[c] = '\0';
		delete temp_script;
	}
	return aname;
}


/* Start checking i/o object for some input, (optionally block all but allowed
 * input) and tell interpreter to wait.
 */
void Converse::poll_input(const char *allowed, bool nonblock) {
	if (allowed_input)
		free(allowed_input);
	allowed_input = nullptr;
	allowed_input = (allowed && strlen(allowed)) ? scumm_strdup(allowed) : nullptr;

	scroll->set_input_mode(true, allowed_input, nonblock);
	need_input = true;
	conv_i->wait();
}


/* Stop polling i/o, tell interpreter to stop waiting.
 */
void Converse::unwait() {
	need_input = false;
	conv_i->unwait();
}


/* Check talk input and determine if it needs to be handled before being passed
 * to the interpreter.
 * Returns false if the conversation should be stopped.
 */
bool Converse::override_input() {
	bool overide_cheat = Game::get_game()->are_cheats_enabled() && party_all_the_time;
	if (in_str.empty())
		in_str = "bye";
	else if (in_str == "look") {
		print("You see ");
		print(_desc.c_str());
		script->seek(script->pos() - 1); // back to ASK command
	} else if (overide_cheat && in_str == "join") {
		if (Game::get_game()->get_game_type() == NUVIE_GAME_U6 // altars and statues
		        && (npc->get_actor_num() >= 189 && npc->get_actor_num() <= 200))
			return true;
		else if (!npc->is_alive()) {
			print("\"How can I join you when I'm dead?\"\n*");
			return true;
		}
		if (!player->get_party()->contains_actor(npc))
			player->get_party()->add_actor(npc);
		print("\"Friends of Nuvie? Sure, I'll come along!\"\n*");
		return false;
	} else if (overide_cheat && in_str == "leave") {
		if (player->get_party()->contains_actor(npc))
			player->get_party()->remove_actor(npc);
		print("\"For Nuvie!\"\n*");
		return false;
	}
	return true;
}

void Converse::collect_input() {
	if (!Game::get_game()->using_new_converse_gump()) {
		print_prompt();
	}
	poll_input();
}

/* If not waiting, continue the active script. If waiting for input, check i/o
 * object (scroll), taking the input if available. Else wait until the scroll's
 * page is unbroken.
 */
void Converse::continue_script() {
	speech->update();

	if (running()) {
		if (!conv_i->waiting())
			conv_i->step();
		else if (need_input && input()) {
			print("\n\n");
			if (!override_input()) {
				need_input = false;
				conv_i->stop();
				stop();
				return;
			}
			// assign value to declared input variable
			if (conv_i->var_input())
				conv_i->assign_input();
			set_svar(U6TALK_VAR_INPUT, get_input().c_str()); // set $Z
			unwait();
		} else if (!need_input && !scroll->get_page_break() && scroll->is_converse_finished()) {
			// if page unbroken, unpause script
			unwait();
		}
		// interpreter has stopped itself
		if (conv_i->end())
			stop();
	}
}


/*** ConvScript ***/

/* Init. and read data from U6Lib.
 */
ConvScript::ConvScript(U6Lib_n *s, uint32 idx) {
	buf = nullptr;
	buf_len = 0;
	src = s;
	src_index = idx;

	ref = 0;
	cpy = nullptr;

	read_script();

	rewind();
}


/* Init. and use data from another ConvScript.
 */
ConvScript::ConvScript(ConvScript *orig) {
	src = nullptr;
	buf = nullptr;
	buf_len = 0;
	src_index = 0;
	compressed = false;

	cpy = orig;
	ref = 1;
	cpy->ref += 1;

	rewind();
}


ConvScript::~ConvScript() {
	if (ref == 0)
		free(buf);
	else if (cpy)
		cpy->ref -= 1;
}


/* Read (decode if necessary) the script data (with the pre-set item index) from
 * the loaded converse library.
 */
void ConvScript::read_script() {
	unsigned char *undec_script = 0; // item as it appears in library
	unsigned char *dec_script = 0; // decoded
	uint32 undec_len = 0, dec_len = 0;
	U6Lzw decoder;
	uint8 gametype = src->get_game_type();

	undec_len = src->get_item_size(src_index);
	if (undec_len > 4) {
		undec_script = src->get_item(src_index);
		if (gametype == NUVIE_GAME_U6) {
			// decode
			if (!(undec_script[0] == 0 && undec_script[1] == 0
			        && undec_script[2] == 0 && undec_script[3] == 0)) {
				compressed = true;
				dec_script =
				    decoder.decompress_buffer(undec_script, undec_len, dec_len);
				free(undec_script);
			} else {
				compressed = false;
				dec_len = undec_len - 4;
				dec_script = (unsigned char *)malloc(dec_len);
				memcpy(dec_script, undec_script + 4, dec_len);
				free(undec_script);
			}
		} else {
			// MD/SE compression handled by lzc library
			compressed = false;
			dec_len = undec_len;
			dec_script = undec_script;
		}
	}
	if (dec_len) {
		buf = (convscript_buffer)dec_script;
		buf_len = dec_len;
	}
}


/* Returns 8bit value from current script location in LSB-first form.
 */
converse_value ConvScript::read(uint32 advance) {
	uint8 val = 0;
	while (advance--) {
		val = *buf_pt;
		++buf_pt;
	}
	return val;
}


/* Returns 16bit value from current script location in LSB-first form.
 */
converse_value ConvScript::read2() {
	uint16 val = 0;
	val = *(buf_pt++);
	val += *(buf_pt++) << 8;
	return val;
}


/* Returns 32bit value from current script location in LSB-first form.
 */
converse_value ConvScript::read4() {
	uint32 val = 0;
	val = *(buf_pt++);
	val += *(buf_pt++) << 8;
	val += *(buf_pt++) << 16;
	val += *(buf_pt++) << 24;
	return val;
}

void ConvScript::write2(converse_value val) {
	*(buf_pt++) = val & 0xff;
	*(buf_pt++) = (val >> 8) & 0xff;
	return;
}


ConverseGumpType get_converse_gump_type_from_config(const Configuration *config) {
	Std::string configvalue;
	config->value("config/general/converse_gump", configvalue, "default");

	if (string_i_compare(configvalue, "default")) {
		return CONVERSE_GUMP_DEFAULT;
	} else if (string_i_compare(configvalue, "u7style")) {
		return CONVERSE_GUMP_U7_STYLE;
	} else if (string_i_compare(configvalue, "wou")) {
		return CONVERSE_GUMP_WOU_STYLE;
	}

	return CONVERSE_GUMP_DEFAULT;
}

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