#include "PluginManager.h"

#include "Export.h"

#include "DataDefs.h"

#include "df/world.h"

#include "df/ui.h"

#include "df/unit.h"

#include "df/unit_thought.h"

#include "df/unit_thought_type.h"

#include <string>

#include <vector>

#include <map>

using namespace std;

using namespace DFHack;

DFHACK_PLUGIN("misery");

DFHACK_PLUGIN_IS_ENABLED(is_enabled);

REQUIRE_GLOBAL(world);

REQUIRE_GLOBAL(ui);

static int factor = 1;

static map<int, int> processedThoughtCountTable;

//keep track of fake thoughts so you can remove them if requested

static vector<std::pair<int,int> > fakeThoughts;

static int count;

const int maxCount = 1000;

command_result misery(color_ostream& out, vector<string>& parameters);

DFhackCExport command_result plugin_shutdown(color_ostream& out) {

factor = 1;

return CR_OK;

}

DFhackCExport command_result plugin_onupdate(color_ostream& out) {

static bool wasLoaded = false;

if ( factor == 1 || !world || !world->map.block_index ) {

if ( wasLoaded ) {

//we just unloaded the game: clear all data

factor = 1;

is_enabled = false;

processedThoughtCountTable.clear();

fakeThoughts.clear();

wasLoaded = false;

}

return CR_OK;

}

if ( !wasLoaded ) {

wasLoaded = true;

}

if ( count < maxCount ) {

count++;

return CR_OK;

}

count = 0;

int32_t race_id = ui->race_id;

int32_t civ_id = ui->civ_id;

for ( size_t a = 0; a < world->units.all.size(); a++ ) {

df::unit* unit = world->units.all[a]; //TODO: consider units.active

//living, native units only

if ( unit->race != race_id || unit->civ_id != civ_id )

continue;

if ( unit->flags1.bits.dead )

continue;

int processedThoughtCount;

map<int,int>::iterator i = processedThoughtCountTable.find(unit->id);

if ( i == processedThoughtCountTable.end() ) {

processedThoughtCount = unit->status.recent_events.size();

processedThoughtCountTable[unit->id] = processedThoughtCount;

} else {

processedThoughtCount = (*i).second;

}

if ( processedThoughtCount == unit->status.recent_events.size() ) {

continue;

} else if ( processedThoughtCount > unit->status.recent_events.size() ) {

processedThoughtCount = unit->status.recent_events.size();

}

//don't reprocess any old thoughts

vector<df::unit_thought*> newThoughts;

for ( size_t b = processedThoughtCount; b < unit->status.recent_events.size(); b++ ) {

df::unit_thought* oldThought = unit->status.recent_events[b];

const char* bob = ENUM_ATTR(unit_thought_type, value, oldThought->type);

if ( bob[0] != '-' ) {

//out.print("unit %4d: old thought value = %s\n", unit->id, bob);

continue;

}

/*out.print("unit %4d: Duplicating thought type %d (%s), value %s, age %d, subtype %d, severity %d\n",

unit->id,

oldThought->type.value,

ENUM_ATTR(unit_thought_type, caption, (oldThought->type)),

//df::enum_traits<df::unit_thought_type>::attr_table[oldThought->type].caption

bob,

oldThought->age,

oldThought->subtype,

oldThought->severity

);*/

//add duplicate thoughts to the temp list

for ( size_t c = 0; c < factor; c++ ) {

df::unit_thought* thought = new df::unit_thought;

thought->type = unit->status.recent_events[b]->type;

thought->age = unit->status.recent_events[b]->age;

thought->subtype = unit->status.recent_events[b]->subtype;

thought->severity = unit->status.recent_events[b]->severity;

newThoughts.push_back(thought);

}

}

for ( size_t b = 0; b < newThoughts.size(); b++ ) {

fakeThoughts.push_back(std::pair<int, int>(a, unit->status.recent_events.size()));

unit->status.recent_events.push_back(newThoughts[b]);

}

processedThoughtCountTable[unit->id] = unit->status.recent_events.size();

}

return CR_OK;

}

DFhackCExport command_result plugin_init(color_ostream& out, vector<PluginCommand> &commands) {

commands.push_back(PluginCommand("misery", "increase the intensity of negative dwarven thoughts",

&misery, false,

"misery: When enabled, every new negative dwarven thought will be multiplied by a factor (2 by default).\n"

"Usage:\n"

" misery enable n\n"

" enable misery with optional magnitude n. If specified, n must be positive.\n"

" misery n\n"

" same as \"misery enable n\"\n"

" misery enable\n"

" same as \"misery enable 2\"\n"

" misery disable\n"

" stop adding new negative thoughts. This will not remove existing duplicated thoughts. Equivalent to \"misery 1\"\n"

" misery clear\n"

" remove fake thoughts added in this session of DF. Saving makes them permanent! Does not change factor.\n\n"

));

return CR_OK;

}

DFhackCExport command_result plugin_enable(color_ostream &out, bool enable)

{

if (enable != is_enabled)

{

is_enabled = enable;

factor = enable ? 2 : 1;

}

return CR_OK;

}

command_result misery(color_ostream &out, vector<string>& parameters) {

if ( !world || !world->map.block_index ) {

out.printerr("misery can only be enabled in fortress mode with a fully-loaded game.\n");

return CR_FAILURE;

}

if ( parameters.size() < 1 || parameters.size() > 2 ) {

return CR_WRONG_USAGE;

}

if ( parameters[0] == "disable" ) {

if ( parameters.size() > 1 ) {

return CR_WRONG_USAGE;

}

factor = 1;

is_enabled = false;

return CR_OK;

} else if ( parameters[0] == "enable" ) {

is_enabled = true;

factor = 2;

if ( parameters.size() == 2 ) {

int a = atoi(parameters[1].c_str());

if ( a <= 1 ) {

out.printerr("Second argument must be a positive integer.\n");

return CR_WRONG_USAGE;

}

factor = a;

}

} else if ( parameters[0] == "clear" ) {

for ( size_t a = 0; a < fakeThoughts.size(); a++ ) {

int dorfIndex = fakeThoughts[a].first;

int thoughtIndex = fakeThoughts[a].second;

world->units.all[dorfIndex]->status.recent_events[thoughtIndex]->age = 1000000;

}

fakeThoughts.clear();

} else {

int a = atoi(parameters[0].c_str());

if ( a < 1 ) {

return CR_WRONG_USAGE;

}

factor = a;

is_enabled = factor > 1;

}

return CR_OK;

}