/* Simple plugin to check for ghosts and automatically queue jobs to engrave slabs for them.
 *
 * Enhancement idea: Queue up a ConstructSlab job, then link the engrave slab job to it. Avoids need to have slabs in stockpiles
 *                   Would require argument parsing, specifying materials
 * Enhancement idea: Automatically place the slab. This seems like a tricky problem but maybe solveable with named zones?
 *                   Might be made obsolete by people just using buildingplan to pre-place plans for slab?
 * Enhancement idea: Optionally enable autoengraving for pets.
 * Enhancement idea: Try to get ahead of ghosts by autoengraving for dead dwarves with no remains, or dwarves
 *                   whose remains are unreachable.
 */

#include "Debug.h"
#include "PluginManager.h"

#include "modules/Persistence.h"
#include "modules/Units.h"
#include "modules/World.h"

#include "df/historical_figure.h"
#include "df/item.h"
#include "df/item_slabst.h"
#include "df/manager_order.h"
#include "df/plotinfost.h"
#include "df/unit.h"
#include "df/world.h"

using namespace DFHack;

DFHACK_PLUGIN("autoslab");
DFHACK_PLUGIN_IS_ENABLED(is_enabled);

REQUIRE_GLOBAL(world);

// logging levels can be dynamically controlled with the `debugfilter` command.
namespace DFHack
{
    // for configuration-related logging
    DBG_DECLARE(autoslab, control, DebugCategory::LINFO);
    // for logging during the periodic scan
    DBG_DECLARE(autoslab, cycle, DebugCategory::LINFO);
}

static const auto CONFIG_KEY = std::string(plugin_name) + "/config";
static PersistentDataItem config;
enum ConfigValues
{
    CONFIG_IS_ENABLED = 0,
};

static int32_t cycle_timestamp = 0; // world->frame_counter at last cycle

static void do_cycle(color_ostream &out);

DFhackCExport command_result plugin_init(color_ostream &out, std::vector<PluginCommand> &commands)
{
    DEBUG(control, out).print("initializing {}\n", plugin_name);

    return CR_OK;
}

DFhackCExport command_result plugin_enable(color_ostream &out, bool enable)
{
    if (!Core::getInstance().isMapLoaded() || !World::isFortressMode())
    {
        out.printerr("Cannot enable {} without a loaded fort.\n", plugin_name);
        return CR_FAILURE;
    }

    if (enable != is_enabled)
    {
        is_enabled = enable;
        DEBUG(control, out).print("{} from the API; persisting\n", is_enabled ? "enabled" : "disabled");
        config.set_bool(CONFIG_IS_ENABLED, is_enabled);
        if (enable)
            do_cycle(out);
    }
    else
    {
        DEBUG(control, out).print("{} from the API, but already {}; no action\n", is_enabled ? "enabled" : "disabled", is_enabled ? "enabled" : "disabled");
    }
    return CR_OK;
}

DFhackCExport command_result plugin_shutdown(color_ostream &out)
{
    DEBUG(control, out).print("shutting down {}\n", plugin_name);

    return CR_OK;
}

DFhackCExport command_result plugin_load_site_data(color_ostream &out)
{
    cycle_timestamp = 0;
    config = World::GetPersistentSiteData(CONFIG_KEY);

    if (!config.isValid())
    {
        DEBUG(control, out).print("no config found in this save; initializing\n");
        config = World::AddPersistentSiteData(CONFIG_KEY);
        config.set_bool(CONFIG_IS_ENABLED, is_enabled);
    }

    // we have to copy our enabled flag into the global plugin variable, but
    // all the other state we can directly read/modify from the persistent
    // data structure.
    is_enabled = config.get_bool(CONFIG_IS_ENABLED);
    DEBUG(control, out).print("loading persisted enabled state: {}\n", is_enabled ? "true" : "false");
    return CR_OK;
}

DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event)
{
    if (event == DFHack::SC_WORLD_UNLOADED)
    {
        if (is_enabled)
        {
            DEBUG(control, out).print("world unloaded; disabling {}\n", plugin_name);
            is_enabled = false;
        }
    }
    return CR_OK;
}

static const int32_t CYCLE_TICKS = 1289;

DFhackCExport command_result plugin_onupdate(color_ostream &out)
{
    if (world->frame_counter - cycle_timestamp >= CYCLE_TICKS)
        do_cycle(out);
    return CR_OK;
}

// Queue up a single order to engrave the slab for the given unit
static void createSlabJob(df::unit *unit)
{
    auto next_id = world->manager_orders.manager_order_next_id++;
    auto order = new df::manager_order();

    order->id = next_id;
    order->job_type = df::job_type::EngraveSlab;
    order->specdata.hist_figure_id = unit->hist_figure_id;
    order->amount_left = 1;
    order->amount_total = 1;
    order->frequency = df::workquota_frequency_type::OneTime;
    world->manager_orders.all.push_back(order);
}

static void checkslabs(color_ostream &out)
{
    // Get existing orders for slab engraving as map hist_figure_id -> order ID
    std::map<int32_t, int32_t> histToJob;
    for (auto order : world->manager_orders.all)
    {
        if (order->job_type == df::job_type::EngraveSlab)
            histToJob[order->specdata.hist_figure_id] = order->id;
    }

    // Build list of ghosts
    std::vector<df::unit *> ghosts;
    std::copy_if(world->units.all.begin(), world->units.all.end(),
                 std::back_inserter(ghosts),
                 [](const df::unit *unit)
                 { return unit->flags3.bits.ghostly; });

    for (auto ghost : ghosts)
    {
        // Only create a job is the map has no existing jobs for that historical figure or no existing engraved slabs
        if (histToJob.count(ghost->hist_figure_id) == 0 &&
            !std::any_of(world->items.other.SLAB.begin(),
                        world->items.other.SLAB.end(),
                        [&ghost](df::item_slabst *slab){
                            return slab->engraving_type == df::slab_engraving_type::Memorial && slab->topic == ghost->hist_figure_id;
                        })
            )
        {
            createSlabJob(ghost);
            auto fullName = Units::getReadableName(ghost);
            out.print("Added slab order for {}\n", DF2CONSOLE(fullName));
        }
    }
}

static void do_cycle(color_ostream &out)
{
    // mark that we have recently run
    cycle_timestamp = world->frame_counter;

    checkslabs(out);
}