#include "Debug.h"
#include "LuaTools.h"
#include "PluginManager.h"
#include "PluginLua.h"
#include "TileTypes.h"

#include "modules/Buildings.h"
#include "modules/EventManager.h"
#include "modules/Job.h"
#include "modules/Maps.h"
#include "modules/World.h"

#include "df/building.h"
#include "df/construction_type.h"
#include "df/coord.h"
#include "df/item.h"
#include "df/job.h"
#include "df/job_item_ref.h"
#include "df/map_block.h"
#include "df/tile_designation.h"
#include "df/tile_occupancy.h"
#include "df/world.h"

#include <bitset>
#include <functional>
#include <ranges>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>

using std::string;
using std::vector;
using std::views::transform;

using namespace DFHack;

DFHACK_PLUGIN("suspendmanager");
DFHACK_PLUGIN_IS_ENABLED(is_enabled);

REQUIRE_GLOBAL(world);

namespace DFHack {
    DBG_DECLARE(suspendmanager, control, DebugCategory::LINFO);
    DBG_DECLARE(suspendmanager, cycle, DebugCategory::LINFO);
}

static const string CONFIG_KEY = string(plugin_name) + "/config";
static PersistentDataItem config;

enum ConfigValues {
    CONFIG_IS_ENABLED = 0,
    CONFIG_PREVENT_BLOCKING = 1,
};


static const int32_t CYCLE_TICKS = 1213; // about one day
static int32_t cycle_timestamp = 0;      // world->frame_counter at last cycle
static bool cycle_needed = false;          // run requested for next cycle



/////////////////////////////////////////////////////////////////////////////////
///                          Main Logic                                     /////
/////////////////////////////////////////////////////////////////////////////////

enum Reason {
    //The job is under water and dwarves will suspend the job when starting it
    UNDER_WATER = 1,
    // The job is planned by buildingplan, but not yet ready to start
    BUILDINGPLAN = 2,
    // Fuzzy risk detection of jobs blocking each other in shapes like corners
    RISK_BLOCKING = 3,
    // Building job on top of an erasable designation (smoothing, carving, ...)
    ERASE_DESIGNATION = 4,
    // Blocks a dead end (either a corridor or on top of a wall)
    DEADEND = 5,
    // Would cave in immediately on completion
    UNSUPPORTED = 6,
    // Has an unmovable item on top of the building job
    ITEM_IN_JOB = 7,
};

inline bool isExternalReason(Reason reason) {
    return reason == Reason::BUILDINGPLAN || reason == Reason::UNDER_WATER || reason == Reason::ITEM_IN_JOB;
}

static string reasonToString(Reason reason) {
  switch (reason) {
    case Reason::UNDER_WATER:
        return "Jobsite is submerged";
    case Reason::BUILDINGPLAN:
        return "Managed by buildingplan";
    case Reason::RISK_BLOCKING:
        return "May block another build job";
    case Reason::ERASE_DESIGNATION:
        return "Waiting for carve/smooth/engrave";
    case Reason::DEADEND:
        return "Blocks another build job";
    case Reason::UNSUPPORTED:
        return "Would collapse immediately";
    case Reason::ITEM_IN_JOB:
        return "Blocked by an unmovable item";
    default:
        return "External reason";
    }
}

using df::coord;

// set() is constexpr starting with C++23

// impassible constructions
static const std::bitset<64> construction_impassible = std::bitset<64>()
    .set(construction_type::Wall)
    .set(construction_type::ReinforcedWall)
    .set(construction_type::Fortification);

// constructions requiring same support as walls
static const std::bitset<64> construction_wall_support = std::bitset<64>()
    .set(construction_type::Wall)
    .set(construction_type::ReinforcedWall)
    .set(construction_type::Fortification)
    .set(construction_type::UpStair)
    .set(construction_type::UpDownStair);

// constructions requiring same support as floors
static const std::bitset<64> construction_floor_support = std::bitset<64>()
    .set(construction_type::Floor)
    .set(construction_type::DownStair)
    .set(construction_type::Ramp)
    .set(construction_type::TrackN)
    .set(construction_type::TrackS)
    .set(construction_type::TrackE)
    .set(construction_type::TrackW)
    .set(construction_type::TrackNS)
    .set(construction_type::TrackNE)
    .set(construction_type::TrackSE)
    .set(construction_type::TrackSW)
    .set(construction_type::TrackEW)
    .set(construction_type::TrackNSE)
    .set(construction_type::TrackNSW)
    .set(construction_type::TrackNEW)
    .set(construction_type::TrackSEW)
    .set(construction_type::TrackNSEW)
    .set(construction_type::TrackRampN)
    .set(construction_type::TrackRampS)
    .set(construction_type::TrackRampE)
    .set(construction_type::TrackRampW)
    .set(construction_type::TrackRampNS)
    .set(construction_type::TrackRampNE)
    .set(construction_type::TrackRampNW)
    .set(construction_type::TrackRampSE)
    .set(construction_type::TrackRampSW)
    .set(construction_type::TrackRampEW)
    .set(construction_type::TrackRampNSE)
    .set(construction_type::TrackRampNSW)
    .set(construction_type::TrackRampNEW)
    .set(construction_type::TrackRampSEW)
    .set(construction_type::TrackRampNSEW);


static const std::bitset<64> shape_wall_support = std::bitset<64>()
    .set(tiletype_shape::WALL)
    .set(tiletype_shape::FORTIFICATION)
    .set(tiletype_shape::STAIR_UP)
    .set(tiletype_shape::STAIR_UPDOWN);

static const std::bitset<64> shape_floor_support = std::bitset<64>()
    .set(tiletype_shape::FLOOR)
    .set(tiletype_shape::STAIR_DOWN)
    .set(tiletype_shape::RAMP)
    .set(tiletype_shape::BOULDER)
    .set(tiletype_shape::PEBBLES)
    .set(tiletype_shape::SAPLING)
    .set(tiletype_shape::BROOK_BED)
    .set(tiletype_shape::BROOK_TOP)
    .set(tiletype_shape::SHRUB)
    .set(tiletype_shape::TWIG)
    .set(tiletype_shape::BRANCH)
    .set(tiletype_shape::TRUNK_BRANCH);

static const std::bitset<64> building_impassible = std::bitset<64>()
    .set(building_type::Floodgate)
    .set(building_type::Statue)
    .set(building_type::WindowGlass)
    .set(building_type::WindowGem)
    .set(building_type::GrateWall)
    .set(building_type::BarsVertical);


// using offset = std::tuple<int,int,int> woud be preferable
// However, tuple has non-public members and therefore tuples cannot be template arguments.
struct offset {
    int x,y,z;
    constexpr offset(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {};
};

inline coord operator+(coord pos, offset off) {
    return coord(pos.x + off.x, pos.y + off.y, pos.z + off.z);
}

// allows the idiom:
// "for (auto npos : neighbors | transform(around(pos)))"
static std::function<coord(offset)> around (coord pos) {
    return [pos](offset o){ return pos + o; };
}

/* offsets for various neighborhoods
 * using constexpr would be preferable,
 * but using arrays makes the length of the neighborhood part of its type
*/
static const vector<offset> neighbors {
    offset{ -1,  0,  0 },
    offset{ +1,  0,  0 },
    offset{  0, -1,  0 },
    offset{  0, +1,  0 }
};

static const vector<offset> neighboursWallSupportsWall {
    offset{-1, 0, 0}, // orthogonal same level
    offset{+1, 0, 0},
    offset{0, -1, 0},
    offset{0, +1, 0},
    offset{-1, 0, -1}, // orthogonal level below
    offset{+1, 0, -1},
    offset{0, -1, -1},
    offset{0, +1, -1},
    offset{-1, 0, +1}, // orthogonal level above
    offset{+1, 0, +1},
    offset{0, -1, +1},
    offset{0, +1, +1},
    offset{0, 0, -1}, // directly below
    offset{0, 0, +1}  // directly above
};

static const vector<offset> neighboursFloorSupportsWall {
    offset{-1, 0, 0},  // orthogonal same level
    offset{+1, 0, 0},
    offset{0, -1, 0},
    offset{0, +1, 0},
    offset{0, 0, +1},  // directly above
    offset{-1, 0, +1}, // orthogonal level above
    offset{+1, 0, +1},
    offset{0, -1, +1},
    offset{0, +1, +1}
};

static const vector<offset> neighboursWallSupportsFloor {
    offset{-1, 0, 0}, // orthogonal same level
    offset{+1, 0, 0},
    offset{0, -1, 0},
    offset{0, +1, 0},
    offset{-1, 0, -1}, // orthogonal level below
    offset{+1, 0, -1},
    offset{0, -1, -1},
    offset{0, +1, -1},
    offset{0, 0, -1}, // directly below
};


static const vector<offset> neighboursFloorSupportsFloor {
    offset{ -1,  0,  0 },
    offset{ +1,  0,  0 },
    offset{  0, -1,  0 },
    offset{  0, +1,  0 }
};

class SuspendManager {
private:
    static constexpr size_t max_deadend_depth = 1000;

    static void suspend(df::job* job) {
        job->flags.bits.suspend = true;
        job->flags.bits.working = false;
        Job::removeWorker(job, 0);
    }

    static void unsuspend(df::job* job) {
        job->flags.bits.suspend = false;
    }

    static bool walkable (coord pos) { return Maps::getWalkableGroup(pos) > 0; }

    static bool buildingOnDesignation(df::building *building){
        CHECK_NULL_POINTER(building);
        auto z = building->z;
        for (auto x = building->x1; x <= building->x2; ++x){
            for (auto y = building->y1; y <= building->y2; ++y){
                auto flags = Maps::getTileDesignation(x,y,z);
                if (flags && (
                    flags->bits.dig != df::tile_dig_designation::No ||
                    flags->bits.smooth > 0))
                    return true;
                auto occupancy = Maps::getTileOccupancy(x,y,z);
                if (occupancy && (
                    occupancy->bits.carve_track_north ||
                    occupancy->bits.carve_track_east ||
                    occupancy->bits.carve_track_south ||
                    occupancy->bits.carve_track_west))
                    return true;
            }
        }
        return false;
    }

    static bool suitableToMoveItemTo(df::coord pos) {
        if (!walkable(pos))
            return false;

        // Dwarves will move a blocking item to a walkable building, but only if its fully constructed
        auto building = Buildings::findAtTile(pos);
        return !building || building->flags.bits.exists;
    }

    // True for buildings planned on a tile with an item that cannot be moved aside
    static bool isOnUnmovableItem(df::job *job) {
        CHECK_NULL_POINTER(job);
        auto building = Job::getHolder(job);
        if (!building)
            return false;

        // Check for items on the building, look into all the map blocks overlapping
        // the building
        bool has_item = false;
        for (int32_t block_x = building->x1 >> 4; block_x <= building->x2 >> 4; ++block_x) {
            for (int32_t block_y = building->y1 >> 4; block_y <= building->y2 >> 4; ++block_y) {
                auto block = Maps::getBlock(block_x,block_y,building->z);
                if (!block)
                    continue;

                for (df::item *item : block->items | transform(df::item::find)) {
                    if (!item)
                        continue;
                    if (item->pos.x < building->x1 || item->pos.x > building->x2 ||
                        item->pos.y < building->y1 || item->pos.y > building->y2)
                        continue;

                    // Ok if it's an item of the job
                    if (std::ranges::any_of(job->items, [item](df::job_item_ref *j) {return j->item == item;}))
                        continue;
                    if (item->flags.bits.in_job || item->flags.bits.forbid)
                        return true; // Assigned to a different task or forbidden, not movable
                    has_item = true;
                }
            }
        }

        if (!has_item)
            return false;

        // When there is an item on top of the building, check for the surrounding of the building
        // for a place where the dwarves would be able to move the item to.
        // The dwarves will move an item if there is a walkable space without any
        // building planned, non-diagonally neighbouring the building.
        // The position of the item does not matter, in multi-tile buildings
        // dwarves will move the item multiple tiles if necessary
        for (auto x : {building->x1-1, building->x2+1}) {
            for (auto y = building->y1; y <= building->y2; ++y) {
                if (suitableToMoveItemTo(coord(x,y,building->z)))
                    return false;
            }
        }
        for (auto y : {building->y1-1, building->y2+1}) {
            for (auto x = building->x1; x <= building->x2; ++x) {
                if (suitableToMoveItemTo(coord(x,y,building->z)))
                    return false;
            }
        }

        return true;
    }

    // check if the tile is suitable tile to stand on for construction (walkable & not a tree branch)
    static bool isSuitableAccess (coord pos) {
        auto tile_type = Maps::getTileType(pos);
        if (!tile_type)
            return false; // no tiletype, likely out of bound
        auto shape = tileShape(*tile_type);
        if (shape == df::enums::tiletype_shape::BRANCH ||
            shape == df::enums::tiletype_shape::TRUNK_BRANCH)
            return false;

        return walkable(pos);
    }

    // check if the tile is suitable to stand on and build, or is planned to become one
    static bool isPotentialSuitableAccess (coord pos) {
        if (isSuitableAccess(pos))
            return true;

        // wall-type tiles can never become suitable
        auto tile_type = Maps::getTileType(pos);
        if (!tile_type || isWallTerrain(*tile_type))
            return false;

        // other tiles can become suitable if a wall is being constructed below
        auto below = Buildings::findAtTile(coord(pos.x,pos.y,pos.z-1));
        if (below && below->getType() == df::building_type::Construction &&
            (below->getSubtype() == construction_type::Wall ||
             below->getSubtype() == construction_type::ReinforcedWall))
            return true;

        return false;
    }

    static bool tileHasSupportWall(coord pos) {
        auto tile_type = Maps::getTileType(pos);
        if (tile_type) {
            auto shape = tileShape(*tile_type);
            return shape == df::enums::tiletype_shape::NONE ? false : shape_wall_support[shape];
        }
        return false;
    }

    static bool tileHasSupportFloor(coord pos) {
        auto tile_type = Maps::getTileType(pos);
        if (tile_type) {
            auto shape = tileShape(*tile_type);
            return shape == df::enums::tiletype_shape::NONE ? false : shape_floor_support[shape];
        }
        return false;
    }

    static bool tileHasSupportBuilding(coord pos) {
        auto building = Buildings::findAtTile(pos);
        if (building)
            return building->getType() == df::building_type::Support && building->flags.bits.exists;
        return false;
    }


    static bool isImpassable(df::building* building) {
        auto type = building->getType();
        if (type == building_type::Construction) {
            return construction_impassible[building->getSubtype()];
        }
        else return building_impassible[type];
    }

    static bool hasWalkableNeighbor(coord pos) {
        return std::ranges::any_of(neighbors | transform(around(pos)), walkable);
    }


    static df::building* plannedImpassibleAt(coord pos) {
        auto building = Buildings::findAtTile(pos);
        if (!building)
            return nullptr;
        if (!building->flags.bits.exists && isImpassable(building))
            return building;
        return nullptr;
    }

    static int riskOfStuckConstructionAt(coord pos) {
        auto risk = 0;
        for (auto npos : neighbors | transform(around(pos))) {
            if (!isSuitableAccess(npos)) { // original used walkable
                ++risk; // one access blocked, increase danger
            } else if (!plannedImpassibleAt(npos)) {
                // walkable neighbour with no plan to build a wall, no danger
                return -1;
            }
        }
        return risk;
    }



    // return true if this job is at risk of blocking another one
    static bool riskBlocking(color_ostream &out, df::job* job) {
        if (job->job_type != job_type::ConstructBuilding)
            return false;
        TRACE(cycle,out).print("risk blocking: check construction job {}\n", job->id);

        auto building = Job::getHolder(job);
        if (!building || !isImpassable(building))
            return false; // not building a blocking construction, no risk

        coord pos(building->centerx,building->centery,building->z);
        if (!isPotentialSuitableAccess(pos))
            // construction is on a tile that is not usable to build, and will not
            // become one, can't block
            return false;

        auto risk = riskOfStuckConstructionAt(pos);
        TRACE(cycle,out).print("  risk is {}\n", risk);

        // TOTHINK: on a large grid, this will compute the same risk up to 5 times
        for (auto npos : neighbors | transform(around(pos))) {
            if (plannedImpassibleAt(npos) && riskOfStuckConstructionAt(npos) > risk)
                return true; // neighbour job is at greater risk of getting stuck
        }

        return false;
    }

    static bool constructionIsUnsupported(color_ostream &out, df::job* job)
    {
        if (!isConstructionJob(job))
            return false;

        auto building = Job::getHolder(job);
        if (!building || building->getType() != df::building_type::Construction)
            return false;

        TRACE(cycle,out).print("check (construction) construction job {} for support\n", job->id);

        coord pos(building->centerx,building->centery,building->z);

        // if no neighbour is walkable, it can't be constructed now anyways
        if (!hasWalkableNeighbor(pos))
            return false;



        auto constr_type = building->getSubtype();

        const vector<offset> *wall_would_support, *floor_would_support;
        vector<offset> supportbld_would_support;

        if (construction_floor_support[constr_type]){
            wall_would_support = &neighboursWallSupportsFloor;
            floor_would_support = &neighboursFloorSupportsFloor;
            supportbld_would_support = vector<offset>{offset(0,0,-1)};
        } else if (construction_wall_support[constr_type]){
            wall_would_support = &neighboursWallSupportsWall;
            floor_would_support = &neighboursFloorSupportsWall;
            supportbld_would_support = vector<offset>{offset(0,0,-1), offset(0,0,+1)};
        } else {
            return false; // some unknown construction - don't suspend
        }

        for (auto npos : *wall_would_support | transform(around(pos)))
            if (tileHasSupportWall(npos)) return false;
        for (auto npos : *floor_would_support | transform(around(pos)))
            if (tileHasSupportFloor(npos)) return false;
        for (auto npos : supportbld_would_support | transform(around(pos)))
            if (tileHasSupportBuilding(npos)) return false;

        return true;
    }

    void suspendBuilding(df::building *building, Reason reason){
        for (auto job : building->jobs)
            if (job->job_type == df::job_type::ConstructBuilding)
                suspensions[job->id] = reason;
    }

    void suspendDeadend (color_ostream &out, df::job* job) {
        auto building = Job::getHolder(job);
        if (!building) return;
        coord pos(building->centerx,building->centery,building->z);

        for (size_t count = 0; count < max_deadend_depth; ++count){

            df::building* exit = nullptr;
            for (auto npos : neighbors | transform(around(pos))) {
                if (!isPotentialSuitableAccess(npos))
                    // non walkable neighbour, nor planned to become one, not an exit
                    continue;

                auto impassiblePlan = plannedImpassibleAt(npos);
                if (!impassiblePlan)
                    // walkable neighbour with no building scheduled, not in a dead end
                    return;

                if (leadsToDeadend.contains(impassiblePlan->id))
                    continue; // already visited, not an exit

                if (exit)
                    return; // more than one exit, not in a dead end

                exit = impassiblePlan;
            }


            if (!exit) {
                // there is no exit at all
                if (isImpassable(building)) {
                    // suspend the current construction job to leave the entire plan suspended
                    suspendBuilding(building, Reason::DEADEND);
                }
                // and stop here
                return;
            }

            // exit is the single exit point of this corridor, suspend its construction job...
            suspendBuilding(exit, Reason::DEADEND);
            // ...mark the current tile of the corridor as leading to a dead-end...
            leadsToDeadend.insert(building->id);

            // ...and continue the exploration from its position
            building = exit;
            pos = coord(building->centerx,building->centery,building->z);
        }
    }

    void preserveDesigations (df::job* job){
        CHECK_NULL_POINTER(job)
        if (job->job_type == df::job_type::CarveTrack ||
            job->job_type == df::job_type::SmoothFloor ||
            job->job_type == df::job_type::DetailFloor)
        {
            auto building = Buildings::findAtTile(job->pos);
            if (building) {
                suspendBuilding(building, Reason::ERASE_DESIGNATION);
            }
        }
    }

    // try to fetch suspension reason for a job without modifying the map
    // (std::map::operator[] inserts the key if it isn't found)
    bool tryGetReason (df::job* job, Reason &reason) {
        auto reason_it = suspensions.find(job->id);
        if (reason_it != suspensions.end()) {
                reason = reason_it->second;
                return true;
        }
        return false;
    }

    std::unordered_map<int,Reason> suspensions;
    std::unordered_set<int> leadsToDeadend;
    size_t num_suspend = 0, num_unsuspend = 0;

public:
    bool prevent_blocking = true;

    // gather some statistics about the last call to do_cycle()
    string getStatus (color_ostream &out) {
        std::map<Reason,int> stats;

        for (auto [_ , reason] : suspensions) {
            stats[reason == Reason::DEADEND ? Reason::RISK_BLOCKING : reason]++;
        }

        std::stringstream res;
        res << "suspended " << num_suspend << " and unsuspended " << num_unsuspend <<  " jobs\n";
        res << "maintaining " << suspensions.size() << " suspension reasons\n";
        for (auto stat : stats) {
            res << std::setw(5) << stat.second << "x " << reasonToString(stat.first) << std::endl;
        }

        return res.str();
    }

    void refresh(color_ostream &out)
    {
        DEBUG(cycle,out).print("starting refresh, prevent blocking is {}\n",
                               prevent_blocking ? "true" : "false");
        suspensions.clear();
        leadsToDeadend.clear();

        for (auto job : df::global::world->jobs.list) {

            // check carving/detailing jobs and suspend buildings over them
            preserveDesigations(job);

            // remaining checks only apply to construction jobs
            if (!isConstructionJob(job)) continue;

            // may suspend other jobs, must always be called
            if (prevent_blocking) suspendDeadend(out, job);

            if (suspensions.contains(job->id))
                continue; // we already have a reason to suspend this job

            // external reasons
            if (Maps::getTileDesignation(job->pos)->bits.flow_size > 1) {
                suspensions[job->id]=Reason::UNDER_WATER;
                continue;
            } else if (isBuildingPlanJob(job)) {
                suspensions[job->id]=Reason::BUILDINGPLAN;
                continue;
            } else if (isOnUnmovableItem(job)) {
                suspensions[job->id]=Reason::ITEM_IN_JOB;
                continue;
            }

            if (constructionIsUnsupported(out, job))
                suspensions[job->id]=Reason::UNSUPPORTED;

            if (!prevent_blocking) continue;

            if (riskBlocking(out, job)) {
                suspensions[job->id]=Reason::RISK_BLOCKING;
                continue;
            }

            // protect (unprocessed) designations
            auto building = Job::getHolder(job);
            if (building && buildingOnDesignation(building))
                suspensions[job->id]=Reason::ERASE_DESIGNATION;
        }
        DEBUG(cycle,out).print("finished refresh: found {} reasons for suspension\n",suspensions.size());
    }

    void do_cycle (color_ostream &out, bool unsuspend_everything = false)
    {
        if (unsuspend_everything){
            suspensions.clear();
        } else {
            refresh(out);
        }
        num_suspend = 0, num_unsuspend = 0;

        Reason reason;


        for (auto job : df::global::world->jobs.list | std::views::filter(isConstructionJob))
        {
            if (job->flags.bits.suspend && !suspensions.contains(job->id)) {
                unsuspend(job); // suspended for no reason
                ++num_unsuspend;
            } else if (!job->flags.bits.suspend && tryGetReason(job,reason)) {
                if (!isExternalReason(reason)) {
                    suspend(job); // has internal reason to be suspended
                    ++num_suspend;
                }
            }
        }
        DEBUG(cycle,out).print("suspended {} constructions and unsuspended {} constructions\n",
                              num_suspend, num_unsuspend);
    }

    static bool isConstructionJob(df::job *job) {
        return job->job_type == job_type::ConstructBuilding;
    }

    bool keptSuspended(df::job *job) {
        Reason reason;
        if (tryGetReason(job,reason) && !isExternalReason(reason))
            return true;
        else
            return false;
    }

    std::string suspensionDescription (df::job *job) {
        Reason reason;
        if (tryGetReason(job,reason)) {
            return reasonToString(reason);
        }
        return "not suspended by suspendmanager";
    }

    /**
     * This is a proxy, since there is currently no (easy) way for C++ plugins
     * to communicate with each other.
     * NOTE: If buidingplan is changed to set the material early
     * (e.g., to solve the issue of some planned buildings not rendering)
     * this will need to be adapted.
     */
    static bool isBuildingPlanJob (df::job* job) {
        auto building = Job::getHolder(job);
        return building && building->mat_type == -1;
    }
};

/////////////////////////////////////////////////////////////////////////////////
///                      Interface for Plugin Manager                       /////
/////////////////////////////////////////////////////////////////////////////////


std::unique_ptr<SuspendManager> suspendmanager_instance;
std::unique_ptr<EventManager::EventHandler> eventhandler_instance;


static command_result do_command(color_ostream &out, vector<string> &parameters);
static command_result do_unsuspend_command(color_ostream &out, vector<string> &parameters);
static void do_cycle(color_ostream &out);
static void jobCompletedHandler(color_ostream& out, void* ptr);

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

    suspendmanager_instance = std::make_unique<SuspendManager>();
    eventhandler_instance = std::make_unique<EventManager::EventHandler>(plugin_self,jobCompletedHandler,1);

    // provide a configuration interface for the plugin
    commands.push_back(PluginCommand(
        plugin_name,
         "Intelligently suspend and unsuspend jobs.",
        do_command));

    commands.push_back(PluginCommand(
        "unsuspend",
        "Resume suspended building construction jobs.",
        do_unsuspend_command));

    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) {
            EventManager::registerListener(EventManager::EventType::JOB_COMPLETED, *eventhandler_instance);
            EventManager::registerListener(EventManager::EventType::JOB_INITIATED, *eventhandler_instance);
            do_cycle(out);
        } else {
            EventManager::unregisterAll(plugin_self);
        }

    } 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);
    suspendmanager_instance.release();
    eventhandler_instance.release();
    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);
        config.set_bool(CONFIG_PREVENT_BLOCKING, true);
    }

    is_enabled = config.get_bool(CONFIG_IS_ENABLED);
    suspendmanager_instance->prevent_blocking = config.get_bool(CONFIG_PREVENT_BLOCKING);
    DEBUG(control,out).print("loading persisted state: enabled is {} / prevent_blocking is {}\n",
                            is_enabled ? "true" : "false",
                            suspendmanager_instance->prevent_blocking ? "true" : "false");
    if(is_enabled) {
        DEBUG(control,out).print("registering job event handlers\n");
        EventManager::registerListener(EventManager::EventType::JOB_COMPLETED, *eventhandler_instance);
        EventManager::registerListener(EventManager::EventType::JOB_INITIATED, *eventhandler_instance);
        do_cycle(out);
    }

    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;
}

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

static command_result do_command(color_ostream &out, vector<string> &parameters) {
    if (!Core::getInstance().isMapLoaded() || !World::isFortressMode()) {
        out.printerr("Cannot run {} without a loaded fort.\n", plugin_name);
        return CR_FAILURE;
    }

    if (parameters.size() == 0) {
        if (!is_enabled) {
            out.print("{} is disabled\n", plugin_name);
        } else {
            out.print(
                "{} is enabled {} suspending blocking jobs\n", plugin_name,
                suspendmanager_instance->prevent_blocking ? "and" : "but not");
        }
        return CR_OK;
    } else if (parameters[0] == "now") {
        do_cycle(out);
        return CR_OK;
    } else if (parameters[0] == "enable") {
        return plugin_enable(out,true);
    } else if (parameters[0] == "disable") {
        return plugin_enable(out,false);
    } else if (parameters[0] == "set" && parameters[1] == "preventblocking") {
        if (parameters[2] == "true") {
            suspendmanager_instance->prevent_blocking = true;
            config.set_bool(CONFIG_PREVENT_BLOCKING, true);
            if (is_enabled) {
                do_cycle(out);
                out.print("{}", suspendmanager_instance->getStatus(out));
            }
            return CR_OK;
        } else if (parameters[2] == "false") {
            suspendmanager_instance->prevent_blocking = false;
            config.set_bool(CONFIG_PREVENT_BLOCKING, false);
            if (is_enabled) {
                do_cycle(out);
                out.print("{}", suspendmanager_instance->getStatus(out));
            }
            return CR_OK;
        } else
            return CR_WRONG_USAGE;
    } else {
        return CR_WRONG_USAGE;
    }
}

static command_result do_unsuspend_command(color_ostream &out, vector<string> &parameters) {
    auto ok = Lua::CallLuaModuleFunction(out, "plugins.suspendmanager", "unsuspend_command", parameters);
    return ok ? CR_OK : CR_FAILURE;
}

static void jobCompletedHandler(color_ostream& out, void* ptr) {
    TRACE(cycle,out).print("job completed/initiated handler called\n");
    df::job* job = static_cast<df::job*>(ptr);
    if (SuspendManager::isConstructionJob(job)) {
        DEBUG(cycle,out).print("construction job initiated/completed (tick: {})\n", world->frame_counter);
        cycle_needed = true;
    }

}

/////////////////////////////////////////////////////
// cycle logic
//

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

    DEBUG(cycle,out).print("running {} cycle\n", plugin_name);

    suspendmanager_instance->do_cycle(out);
}


/////////////////////////////////////////////////////
// Lua exports
//

// Return a human readable description of why suspendmanager keeps a job suspended
static std::string suspendmanager_suspensionDescription(df::job *job) {
    if (is_enabled) {
        CHECK_NULL_POINTER(suspendmanager_instance);
        return suspendmanager_instance->suspensionDescription(job);
    } else {
        return "suspendmanager disabled";
    }
}

// check whether suspendmanager keeps a job suspended
static bool suspendmanager_isKeptSuspended(df::job *job) {
    if (is_enabled) {
        CHECK_NULL_POINTER(suspendmanager_instance);
        return suspendmanager_instance->keptSuspended(job);
    } else {
        return false;
    }
}

static void suspendmanager_runOnce(color_ostream &out, bool blocking, bool unsuspend_everything) {
    auto save = suspendmanager_instance->prevent_blocking;
    suspendmanager_instance->prevent_blocking = blocking;
    suspendmanager_instance->do_cycle(out, unsuspend_everything);
    suspendmanager_instance->prevent_blocking = save;
}

static string suspendmanager_getStatus(color_ostream &out) {
    return suspendmanager_instance->getStatus(out);
}

static bool suspendmanager_isBuildingPlanJob(df::job *job) {
    return suspendmanager_instance->isBuildingPlanJob(job);
}

static bool suspendmanager_preventBlockingEnabled() {
    return config.get_bool(CONFIG_PREVENT_BLOCKING);
}

DFHACK_PLUGIN_LUA_FUNCTIONS {
    DFHACK_LUA_FUNCTION(suspendmanager_suspensionDescription),
    DFHACK_LUA_FUNCTION(suspendmanager_isKeptSuspended),
    DFHACK_LUA_FUNCTION(suspendmanager_runOnce),
    DFHACK_LUA_FUNCTION(suspendmanager_getStatus),
    DFHACK_LUA_FUNCTION(suspendmanager_isBuildingPlanJob),
    DFHACK_LUA_FUNCTION(suspendmanager_preventBlockingEnabled),
    DFHACK_LUA_END
};