#include <algorithm>

#include <cassert>

#include <ostream>

#include "misc.h"

#include "search.h"

#include "thread.h"

#include "tt.h"

#include "uci.h"

#include "syzygy/tbprobe.h"

using std::string;

UCI::OptionsMap Options; // Global object

namespace UCI {

void on_clear_hash(const Option&) { Search::clear(); }

void on_hash_size(const Option& o) { TT.resize(o); }

void on_logger(const Option& o) { start_logger(o); }

void on_threads(const Option& o) { Threads.set(o); }

void on_tb_path(const Option& o) { Tablebases::init(o); }

bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {

return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),

[](char c1, char c2) { return tolower(c1) < tolower(c2); });

}

void init(OptionsMap& o) {

}

std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {

for (size_t idx = 0; idx < om.size(); ++idx)

for (const auto& it : om)

if (it.second.idx == idx)

{

const Option& o = it.second;

os << "\noption name " << it.first << " type " << o.type;

if (o.type == "string" || o.type == "check" || o.type == "combo")

os << " default " << o.defaultValue;

if (o.type == "spin")

os << " default " << int(stof(o.defaultValue))

<< " min " << o.min

<< " max " << o.max;

break;

}

return os;

}

Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f)

{ defaultValue = currentValue = v; }

Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)

{ defaultValue = currentValue = (v ? "true" : "false"); }

Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)

{}

Option::Option(double v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f)

{ defaultValue = currentValue = std::to_string(v); }

Option::Option(const char* v, const char* cur, OnChange f) : type("combo"), min(0), max(0), on_change(f)

{ defaultValue = v; currentValue = cur; }

Option::operator double() const {

assert(type == "check" || type == "spin");

return (type == "spin" ? stof(currentValue) : currentValue == "true");

}

Option::operator std::string() const {

assert(type == "string");

return currentValue;

}

bool Option::operator==(const char* s) const {

assert(type == "combo");

return !CaseInsensitiveLess()(currentValue, s)

&& !CaseInsensitiveLess()(s, currentValue);

}

void Option::operator<<(const Option& o) {

static size_t insert_order = 0;

*this = o;

idx = insert_order++;

}

Option& Option::operator=(const string& v) {

assert(!type.empty());

if ( (type != "button" && v.empty())

|| (type == "check" && v != "true" && v != "false")

|| (type == "spin" && (stof(v) < min || stof(v) > max)))

return *this;

if (type != "button")

currentValue = v;

if (on_change)

on_change(*this);

return *this;

}

} // namespace UCI