#include <random>

#include <chrono>

#include <unordered_map>

#include <vector>

#include <algorithm>

#include <cstdint>

#include <cinttypes>

#include <stdio.h>

#include <stdlib.h>

#include "DataFuncs.h"

#include "PluginManager.h"

#include "PluginLua.h"

using namespace DFHack;

DFHACK_PLUGIN("cxxrandom");

#define PLUGIN_VERSION 2.0

color_ostream *cout = nullptr;

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

cout = &out;

return CR_OK;

}

DFhackCExport command_result plugin_shutdown (color_ostream &out) {

return CR_OK;

}

DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event) {

return CR_OK;

}

#define EK_ID_BASE (1ll << 40)

class EnginesKeeper

};

uint64_t GenerateEngine( uint64_t seed ) {

return EnginesKeeper::Instance().NewEngine( seed );

}

void DestroyEngine( uint64_t id ) {

EnginesKeeper::Instance().DestroyEngine( id );

}

void NewSeed( uint64_t id, uint64_t seed ) {

EnginesKeeper::Instance().NewSeed( id, seed );

}

int rollInt(uint64_t id, int min, int max) {

std::uniform_int_distribution<int> ND(min, max);

return ND(EnginesKeeper::Instance().RNG(id));

}

double rollDouble(uint64_t id, double min, double max) {

std::uniform_real_distribution<double> ND(min, max);

return ND(EnginesKeeper::Instance().RNG(id));

}

double rollNormal(uint64_t id, double mean, double stddev) {

std::normal_distribution<double> ND(mean, stddev);

return ND(EnginesKeeper::Instance().RNG(id));

}

bool rollBool(uint64_t id, float p) {

std::bernoulli_distribution ND(p);

return ND(EnginesKeeper::Instance().RNG(id));

}

class NumberSequence

};

#define SK_ID_BASE 0

class SequenceKeeper

};

uint64_t MakeNumSequence( int64_t start, int64_t end ) {

}

void DestroyNumSequence( uint64_t seqID ) {

SequenceKeeper::Instance().DestroySequence(seqID);

}

void AddToSequence(uint64_t seqID, int64_t num ) {

SequenceKeeper::Instance().AddToSequence(seqID, num);

}

void ShuffleSequence(uint64_t seqID, uint64_t engID ) {

SequenceKeeper::Instance().Shuffle(seqID, engID);

}

int64_t NextInSequence( uint64_t seqID ) {

return SequenceKeeper::Instance().NextInSequence(seqID);

}

void DebugSequence( uint64_t seqID ) {

SequenceKeeper::Instance().PrintSequence(seqID);

}

DFHACK_PLUGIN_LUA_FUNCTIONS {

DFHACK_LUA_FUNCTION(GenerateEngine),

DFHACK_LUA_FUNCTION(DestroyEngine),

DFHACK_LUA_FUNCTION(NewSeed),

DFHACK_LUA_FUNCTION(rollInt),

DFHACK_LUA_FUNCTION(rollDouble),

DFHACK_LUA_FUNCTION(rollNormal),

DFHACK_LUA_FUNCTION(rollBool),

DFHACK_LUA_FUNCTION(MakeNumSequence),

DFHACK_LUA_FUNCTION(DestroyNumSequence),

DFHACK_LUA_FUNCTION(AddToSequence),

DFHACK_LUA_FUNCTION(ShuffleSequence),

DFHACK_LUA_FUNCTION(NextInSequence),

DFHACK_LUA_FUNCTION(DebugSequence),

DFHACK_LUA_END

};