#include <array>
#include <atomic>
#include <vector>
#include <random>
#include <string>
#include <thread>

#include "Console.h"
#include "Core.h"
#include "Debug.h"
#include "Export.h"
#include "MiscUtils.h"
#include "PluginManager.h"
#include "Signal.hpp"

#include "modules/Gui.h"
#include "modules/Items.h"
#include "modules/Maps.h"

#include "df/caste_raw.h"
#include "df/creature_raw.h"
#include "df/world.h"

// for MSVC alignas(64) issues
#ifdef WIN32
#define _DISABLE_EXTENDED_ALIGNED_STORAGE
#endif

using std::vector;
using std::string;
using namespace DFHack;

DFHACK_PLUGIN("kittens");
DFHACK_PLUGIN_IS_ENABLED(is_enabled);
REQUIRE_GLOBAL(ui);
REQUIRE_GLOBAL(world);

namespace DFHack {
DBG_DECLARE(kittens,command);
}

std::atomic<bool> shutdown_flag{false};
std::atomic<bool> final_flag{true};
std::atomic<bool> timering{false};
std::atomic<bool> trackmenu_flg{false};
std::atomic<uint8_t> trackpos_flg{0};
std::atomic<uint8_t> statetrack{0};
int32_t last_designation[3] = {-30000, -30000, -30000};
int32_t last_mouse[2] = {-1, -1};
df::ui_sidebar_mode last_menu = df::ui_sidebar_mode::Default;
uint64_t timeLast = 0;

command_result kittens (color_ostream &out, vector <string> & parameters);
command_result ktimer (color_ostream &out, vector <string> & parameters);
command_result trackmenu (color_ostream &out, vector <string> & parameters);
command_result trackpos (color_ostream &out, vector <string> & parameters);
command_result trackstate (color_ostream &out, vector <string> & parameters);
command_result colormods (color_ostream &out, vector <string> & parameters);
command_result sharedsignal (color_ostream &out, vector <string> & parameters);

DFhackCExport command_result plugin_init ( color_ostream &out, std::vector <PluginCommand> &commands)
{
    commands.push_back(PluginCommand("nyan","NYAN CAT INVASION!",kittens));
    commands.push_back(PluginCommand("ktimer","Measure time between game updates and console lag.",ktimer));
    commands.push_back(PluginCommand("trackmenu","Track menu ID changes (toggle).",trackmenu));
    commands.push_back(PluginCommand("trackpos","Track mouse and designation coords (toggle).",trackpos));
    commands.push_back(PluginCommand("trackstate","Track world and map state (toggle).",trackstate));
    commands.push_back(PluginCommand("colormods","Dump colormod vectors.",colormods));
    commands.push_back(PluginCommand("sharedsignal","Test Signal with signal_shared_tag",sharedsignal));
    return CR_OK;
}

DFhackCExport command_result plugin_shutdown ( color_ostream &out )
{
    shutdown_flag = true;
    while(!final_flag)
    {
        Core::getInstance().getConsole().msleep(60);
    }
    return CR_OK;
}

DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event)
{
    if(!statetrack)
        return CR_OK;
    switch (event) {
        case SC_MAP_LOADED:
            out << "Map loaded" << endl;
            break;
        case SC_MAP_UNLOADED:
            out << "Map unloaded" << endl;
            break;
        case SC_WORLD_LOADED:
            out << "World loaded" << endl;
            break;
        case SC_WORLD_UNLOADED:
            out << "World unloaded" << endl;
            break;
        case SC_VIEWSCREEN_CHANGED:
            out << "Screen changed" << endl;
            break;
        default:
            out << "Something else is happening, nobody knows what..." << endl;
            break;
    }
    return CR_OK;
}

DFhackCExport command_result plugin_onupdate ( color_ostream &out )
{
    if(timering)
    {
        uint64_t time2 = GetTimeMs64();
        uint64_t delta = time2-timeLast;
        timeLast = time2;
        out.print("Time delta = %d ms\n", int(delta));
    }
    if(trackmenu_flg)
    {
        if (last_menu != ui->main.mode)
        {
            last_menu = ui->main.mode;
            out.print("Menu: %d\n",last_menu);
        }
    }
    if(trackpos_flg)
    {
        int32_t desig_x, desig_y, desig_z;
        Gui::getDesignationCoords(desig_x,desig_y,desig_z);
        if(desig_x != last_designation[0] || desig_y != last_designation[1] || desig_z != last_designation[2])
        {
            last_designation[0] = desig_x;
            last_designation[1] = desig_y;
            last_designation[2] = desig_z;
            out.print("Designation: %d %d %d\n",desig_x, desig_y, desig_z);
        }
        int mouse_x, mouse_y;
        Gui::getMousePos(mouse_x,mouse_y);
        if(mouse_x != last_mouse[0] || mouse_y != last_mouse[1])
        {
            last_mouse[0] = mouse_x;
            last_mouse[1] = mouse_y;
            out.print("Mouse: %d %d\n",mouse_x, mouse_y);
        }
    }
    return CR_OK;
}

command_result trackmenu (color_ostream &out, vector <string> & parameters)
{
    bool is_running = trackmenu_flg.exchange(false);
    if(is_running)
    {
        return CR_OK;
    }
    else
    {
        is_enabled = true;
        last_menu = ui->main.mode;
        out.print("Menu: %d\n",last_menu);
        trackmenu_flg = true;
        return CR_OK;
    }
}
command_result trackpos (color_ostream &out, vector <string> & parameters)
{
    trackpos_flg.fetch_xor(1);
    is_enabled = true;
    return CR_OK;
}

command_result trackstate ( color_ostream& out, vector< string >& parameters )
{
    statetrack.fetch_xor(1);
    return CR_OK;
}

command_result colormods (color_ostream &out, vector <string> & parameters)
{
    CoreSuspender suspend;
    auto & vec = world->raws.creatures.alphabetic;
    for(df::creature_raw* rawlion : vec)
    {
        df::caste_raw * caste = rawlion->caste[0];
        out.print("%s\nCaste addr %p\n",rawlion->creature_id.c_str(), &caste->color_modifiers);
        for(size_t j = 0; j < caste->color_modifiers.size();j++)
        {
            out.print("mod %zd: %p\n", j, caste->color_modifiers[j]);
        }
    }
    return CR_OK;
}

command_result ktimer (color_ostream &out, vector <string> & parameters)
{
    bool is_running = timering.exchange(false);
    if(is_running)
    {
        return CR_OK;
    }
    uint64_t timestart = GetTimeMs64();
    {
        CoreSuspender suspend;
        uint64_t timeend = GetTimeMs64();
        timeLast = timeend;
        timering = true;
        out.print("Time to suspend = %d ms\n", int(timeend - timestart));
    }
    is_enabled = true;
    return CR_OK;
}

struct Connected;
using shared = std::shared_ptr<Connected>;
using weak = std::weak_ptr<Connected>;

static constexpr std::chrono::microseconds delay{1};

template<typename Derived>
struct ClearMem : public ConnectedBase {
    ~ClearMem()
    {
        memset(reinterpret_cast<void*>(this), 0xDE, sizeof(Derived));
    }
};

struct Connected : public ClearMem<Connected> {
    using Sig = Signal<void(uint32_t), signal_shared_tag>;
    std::array<Sig::Connection,4> con;
    Sig signal;
    weak other;
    Sig::weak_ptr other_sig;
    color_ostream *out;
    int id;
    uint32_t count;
    uint32_t caller;
    alignas(64) std::atomic<uint32_t> callee;
    Connected() = default;
    Connected(int id) :
        Connected{}
    {
        this->id = id;
    }
    void connect(color_ostream& o, shared& b, size_t pos, uint32_t c)
    {
        out = &o;
        count = c*2;
        other = b;
        other_sig = b->signal.weak_from_this();
        // Externally synchronized object destruction is only safe to this
        // connect.
        con[pos] = b->signal.connect(
                [this](uint32_t) {
                    uint32_t old = callee.fetch_add(1);
                    assert(old != 0xDEDEDEDE); (void)old;
                    std::this_thread::sleep_for(delay);
                    assert(callee != 0xDEDEDEDE);
                });
        // Shared object managed object with possibility of destruction while
        // other threads calling emit must pass the shared_ptr to connect.
        Connected *bptr = b.get();
        b->con[pos] = signal.connect(b,
                [bptr](int) {
                    uint32_t old = bptr->callee.fetch_add(1);
                    assert(old != 0xDEDEDEDE); (void)old;
                    std::this_thread::sleep_for(delay);
                    assert(bptr->callee != 0xDEDEDEDE);
                });
    }
    void reconnect(size_t pos) {
        auto b = other.lock();
        if (!b)
            return;
        // Not required to use Sig::lock because other holds strong reference to
        // Signal. But this just shows how weak_ref could be used.
        auto sig = Sig::lock(other_sig);
        if (!sig)
            return;
        con[pos] = sig->connect(b,
                [this](uint32_t) {
                    uint32_t old = callee.fetch_add(1);
                    assert(old != 0xDEDEDEDE); (void)old;
                    std::this_thread::sleep_for(delay);
                    assert(callee != 0xDEDEDEDE);
                });
    }
    void connect(color_ostream& o, shared& a, shared& b,size_t pos, uint32_t c)
    {
        out = &o;
        count = c;
        con[pos] = b->signal.connect(a,
                [this](uint32_t) {
                    uint32_t old = callee.fetch_add(1);
                    assert(old != 0xDEDEDEDE); (void)old;
                    std::this_thread::sleep_for(delay);
                    assert(callee != 0xDEDEDEDE);
                });
    }
    Connected* operator->() noexcept
    {
        return this;
    }
    ~Connected() {
        INFO(command,*out).print("Connected %d had %d count. "
                "It was caller %d times. "
                "It was callee %d times.\n",
                id, count, caller, callee.load());
    }
};

command_result sharedsignal (color_ostream &out, vector <string> & parameters)
{
    using rng_t = std::linear_congruential_engine<uint32_t, 747796405U, 2891336453U, 0>;
    rng_t rng(std::random_device{}());
    size_t count = 10;
    if (0 < parameters.size()) {
        std::stringstream ss(parameters[0]);
        ss >> count;
        DEBUG(command, out) << "Parsed " << count
            << " from paramters[0] '" << parameters[0] << '\'' << std::endl;
    }


    std::uniform_int_distribution<uint32_t>  dis(4096,8192);
    out << "Running signal_shared_tag destruction test "
        << count << " times" << std::endl;
    for (size_t nr = 0; nr < count; ++nr) {
        std::array<std::thread,4> t{};
        // Make an object which destruction is protected by std::thread::join()
        Connected external{static_cast<int>(t.size())};
        TRACE(command, out) << "begin " << std::endl;
        {
            int id = 0;
            // Make objects that are automatically protected using weak_ptr
            // references that are promoted to shared_ptr when Signal is
            // accessed.
            std::array<shared,4> c = {
                std::make_shared<Connected>(id++),
                std::make_shared<Connected>(id++),
                std::make_shared<Connected>(id++),
                std::make_shared<Connected>(id++),
            };
            assert(t.size() == c.size());
            for (unsigned i = 1; i < c.size(); ++i) {
                c[0]->connect(out, c[0], c[i], i - 1, dis(rng));
                c[i]->connect(out, c[i], c[0], 0, dis(rng));
            }
            external.connect(out, c[1], 1, dis(rng));
            auto thr = [&out](shared c) {
                TRACE(command, out) << "Thread " << c->id << " started." << std::endl;
                weak ref = c;
                for (;c->caller < c->count; ++c->caller) {
                    c->signal(std::move(c->caller));
                }
                TRACE(command, out) << "Thread " << c->id << " resets shared." << std::endl;
                c.reset();
                while((c = ref.lock())) {
                    ++c->caller;
                    c->signal(std::move(c->caller));
                    c.reset();
                    std::this_thread::sleep_for(delay*25);
                }
            };
            for (unsigned i = 0; i < c.size(); ++i) {
                TRACE(command, out) << "start thread " << i << std::endl;
                t[i] = std::thread{thr, c[i]};
            }
        }
        TRACE(command, out) << "running " << std::endl;
        for (;external->caller < external->count; ++external->caller) {
            external->signal(std::move(external->caller));
            external->reconnect(1);
        }
        TRACE(command, out) << "join " << std::endl;
        for (unsigned i = 0; i < t.size(); ++i)
            t[i].join();
    }
    return CR_OK;
}

command_result kittens (color_ostream &out, vector <string> & parameters)
{
    if (parameters.size() >= 1)
    {
        if (parameters[0] == "stop")
        {
            shutdown_flag = true;
            while(!final_flag)
            {
                Core::getInstance().getConsole().msleep(60);
            }
            shutdown_flag = false;
            return CR_OK;
        }
    }
    final_flag = false;
    if (!out.is_console())
        return CR_FAILURE;
    Console &con = static_cast<Console&>(out);
    // http://evilzone.org/creative-arts/nyan-cat-ascii/
    const char * nyan []=
    {
        "NYAN NYAN NYAN NYAN NYAN NYAN NYAN",
        "+      o     +              o   ",
        "    +             o     +       +",
        "o          +",
        "    o  +           +        +",
        "+        o     o       +        o",
        "-_-_-_-_-_-_-_,------,      o ",
        "_-_-_-_-_-_-_-|   /\\_/\\  ",
        "-_-_-_-_-_-_-~|__( ^ .^)  +     +  ",
        "_-_-_-_-_-_-_-\"\"  \"\"      ",
        "+      o         o   +       o",
        "    +         +",
        "o        o         o      o     +",
        "    o           +",
        "+      +     o        o      +    ",
        "NYAN NYAN NYAN NYAN NYAN NYAN NYAN",
        0
    };
    const char VARIABLE_IS_NOT_USED * kittenz1 []=
    {
        "   ____",
        "  (.   \\",
        "    \\  |  ",
        "     \\ |___(\\--/)",
        "   __/    (  . . )",
        "  \"'._.    '-.O.'",
        "       '-.  \\ \"|\\",
        "          '.,,/'.,,mrf",
        0
    };
    con.cursor(false);
    con.clear();
    Console::color_value color = COLOR_BLUE;
    while(1)
    {
        if(shutdown_flag || !con.isInited())
        {
            final_flag = true;
            con.reset_color();
            con << std::endl << "NYAN!" << std::endl << std::flush;
            return CR_OK;
        }
        con.color(color);
        int index = 0;
        const char * kit = nyan[index];
        con.gotoxy(1,1);
        //con << "Your DF is now full of kittens!" << std::endl;
        while (kit != 0)
        {
            con.gotoxy(1,1+index);
            con << kit << std::endl;
            index++;
            kit = nyan[index];
        }
        con.flush();
        con.msleep(60);
        color = Console::color_value(int(color) + 1);
        if(color > COLOR_MAX)
            color = COLOR_BLUE;
    }
}
