#include <iterator>

#include <map>

#include <memory>

#include <sstream>

#include "cpptcl/cpptcl.h"

using namespace Tcl;

using namespace Tcl::details;

using namespace std;

result::result(Tcl_Interp *interp) : interp_(interp) {}

result::operator bool() const {

Tcl_Obj *obj = Tcl_GetObjResult(interp_);

int val, cc;

cc = Tcl_GetBooleanFromObj(interp_, obj, &val);

if (cc != TCL_OK) {

throw tcl_error(interp_);

}

return static_cast<bool>(val);

}

result::operator double() const {

Tcl_Obj *obj = Tcl_GetObjResult(interp_);

double val;

int cc = Tcl_GetDoubleFromObj(interp_, obj, &val);

if (cc != TCL_OK) {

throw tcl_error(interp_);

}

return val;

}

result::operator int() const {

Tcl_Obj *obj = Tcl_GetObjResult(interp_);

int val, cc;

cc = Tcl_GetIntFromObj(interp_, obj, &val);

if (cc != TCL_OK) {

throw tcl_error(interp_);

}

return val;

}

result::operator long() const {

Tcl_Obj *obj = Tcl_GetObjResult(interp_);

long val;

int cc;

cc = Tcl_GetLongFromObj(interp_, obj, &val);

if (cc != TCL_OK) {

throw tcl_error(interp_);

}

return val;

}

result::operator string() const {

Tcl_Obj *obj = Tcl_GetObjResult(interp_);

return Tcl_GetString(obj);

}

result::operator object() const { return object(Tcl_GetObjResult(interp_)); }

void details::set_result(Tcl_Interp *interp, bool b) { Tcl_SetObjResult(interp, Tcl_NewBooleanObj(b)); }

void details::set_result(Tcl_Interp *interp, int i) { Tcl_SetObjResult(interp, Tcl_NewIntObj(i)); }

void details::set_result(Tcl_Interp *interp, long i) { Tcl_SetObjResult(interp, Tcl_NewLongObj(i)); }

void details::set_result(Tcl_Interp *interp, double d) { Tcl_SetObjResult(interp, Tcl_NewDoubleObj(d)); }

void details::set_result(Tcl_Interp *interp, string const &s) { Tcl_SetObjResult(interp, Tcl_NewStringObj(s.data(), static_cast<int>(s.size()))); }

void details::set_result(Tcl_Interp *interp, void *p) {

}

void details::set_result(Tcl_Interp *interp, object const &o) { Tcl_SetObjResult(interp, o.get_object()); }

void details::check_params_no(int objc, int required, const std::string &message) {

}

object details::get_var_params(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], int from, policies const &pol) {

}

namespace // anonymous

{

typedef map<string, shared_ptr<callback_base>> callback_interp_map;

typedef map<Tcl_Interp *, callback_interp_map> callback_map;

callback_map callbacks;

callback_map constructors;

typedef map<string, policies> policies_interp_map;

typedef map<Tcl_Interp *, policies_interp_map> policies_map;

policies_map call_policies;

typedef map<string, shared_ptr<class_handler_base>> class_interp_map;

typedef map<Tcl_Interp *, class_interp_map> class_handlers_map;

class_handlers_map class_handlers;

bool find_policies(Tcl_Interp *interp, string const &cmdName, policies_interp_map::iterator &piti) {

}

extern "C" int object_handler(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]);

void post_process_policies(Tcl_Interp *interp, policies &pol, Tcl_Obj *CONST objv[], bool isMethod) {

}

extern "C" int callback_handler(ClientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {

}

extern "C" int object_handler(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {

}

extern "C" int constructor_handler(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {

}

} // namespace

Tcl::details::no_init_type Tcl::no_init;

policies &policies::factory(string const &name) {

factory_ = name;

return *this;

}

policies &policies::sink(int index) {

sinks_.push_back(index);

return *this;

}

policies &policies::variadic() {

variadic_ = true;

return *this;

}

policies &policies::usage(string const &message) {

usage_ = std::string("Usage: ") + message;

return *this;

}

policies Tcl::factory(string const &name) { return policies().factory(name); }

policies Tcl::sink(int index) { return policies().sink(index); }

policies Tcl::variadic() { return policies().variadic(); }

policies Tcl::usage(string const &message) { return policies().usage(message); }

class_handler_base::class_handler_base() {

// default policies for the -delete command

policies_["-delete"] = policies();

}

void class_handler_base::register_method(string const &name, shared_ptr<object_cmd_base> ocb, policies const &p) {

methods_[name] = ocb;

policies_[name] = p;

}

policies &class_handler_base::get_policies(string const &name) {

policies_map_type::iterator it = policies_.find(name);

if (it == policies_.end()) {

throw tcl_error("Trying to use non-existent policy: " + name);

}

return it->second;

}

object::object() : interp_(0) {

obj_ = Tcl_NewObj();

Tcl_IncrRefCount(obj_);

}

object::object(bool b) : interp_(0) {

obj_ = Tcl_NewBooleanObj(b);

Tcl_IncrRefCount(obj_);

}

object::object(char const *buf, size_t size) : interp_(0) {

obj_ = Tcl_NewByteArrayObj(reinterpret_cast<unsigned char const *>(buf), static_cast<int>(size));

Tcl_IncrRefCount(obj_);

}

object::object(double d) : interp_(0) {

obj_ = Tcl_NewDoubleObj(d);

Tcl_IncrRefCount(obj_);

}

object::object(int i) : interp_(0) {

obj_ = Tcl_NewIntObj(i);

Tcl_IncrRefCount(obj_);

}

object::object(long l) : interp_(0) {

obj_ = Tcl_NewLongObj(l);

Tcl_IncrRefCount(obj_);

}

object::object(char const *s) : interp_(0) {

obj_ = Tcl_NewStringObj(s, -1);

Tcl_IncrRefCount(obj_);

}

object::object(string const &s) : interp_(0) {

obj_ = Tcl_NewStringObj(s.data(), static_cast<int>(s.size()));

Tcl_IncrRefCount(obj_);

}

object::object(Tcl_Obj *o, bool shared) : interp_(0) { init(o, shared); }

object::object(object const &other, bool shared) : interp_(other.get_interp()) { init(other.obj_, shared); }

void object::init(Tcl_Obj *o, bool shared) {

}

object::~object() { Tcl_DecrRefCount(obj_); }

object &object::assign(bool b) {

Tcl_SetBooleanObj(obj_, b);

return *this;

}

object &object::resize(size_t size) {

Tcl_SetByteArrayLength(obj_, static_cast<int>(size));

return *this;

}

object &object::assign(char const *buf, size_t size) {

Tcl_SetByteArrayObj(obj_, reinterpret_cast<unsigned char const *>(buf), static_cast<int>(size));

return *this;

}

object &object::assign(double d) {

Tcl_SetDoubleObj(obj_, d);

return *this;

}

object &object::assign(int i) {

Tcl_SetIntObj(obj_, i);

return *this;

}

object &object::assign(long l) {

Tcl_SetLongObj(obj_, l);

return *this;

}

object &object::assign(char const *s) {

Tcl_SetStringObj(obj_, s, -1);

return *this;

}

object &object::assign(string const &s) {

Tcl_SetStringObj(obj_, s.data(), static_cast<int>(s.size()));

return *this;

}

object &object::assign(object const &other) {

object(other).swap(*this);

return *this;

}

object &object::assign(Tcl_Obj *o) {

object(o).swap(*this);

return *this;

}

object &object::swap(object &other) {

std::swap(obj_, other.obj_);

std::swap(interp_, other.interp_);

return *this;

}

template <> bool object::get<bool>(interpreter &i) const {

int retVal;

int res = Tcl_GetBooleanFromObj(i.get(), obj_, &retVal);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return static_cast<bool>(retVal);

}

template <> vector<char> object::get<vector<char>>(interpreter &) const {

size_t size;

char const *buf = get(size);

return vector<char>(buf, buf + size);

}

template <> double object::get<double>(interpreter &i) const {

double retVal;

int res = Tcl_GetDoubleFromObj(i.get(), obj_, &retVal);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return retVal;

}

template <> int object::get<int>(interpreter &i) const {

int retVal;

int res = Tcl_GetIntFromObj(i.get(), obj_, &retVal);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return retVal;

}

template <> long object::get<long>(interpreter &i) const {

long retVal;

int res = Tcl_GetLongFromObj(i.get(), obj_, &retVal);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return retVal;

}

template <> char const *object::get<char const *>(interpreter &) const { return get(); }

template <> string object::get<string>(interpreter &) const {

Tcl_Size len;

char const *buf = Tcl_GetStringFromObj(obj_, &len);

return string(buf, buf + len);

}

string object::asString() const { return get<string>(); }

int object::asInt() const { return get<int>(); }

bool object::asBool() const { return get<bool>(); }

long object::asLong() const { return get<long>(); }

double object::asDouble() const { return get<double>(); }

char const *object::get() const { return Tcl_GetString(obj_); }

char const *object::get(size_t &size) const {

Tcl_Size len;

unsigned char *buf = Tcl_GetByteArrayFromObj(obj_, &len);

size = len;

return const_cast<char const *>(reinterpret_cast<char *>(buf));

}

size_t object::size(interpreter &i) const {

}

object object::at(size_t index, interpreter &i) const {

}

object &object::append(object const &o, interpreter &i) {

int res = Tcl_ListObjAppendElement(i.get(), obj_, o.obj_);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return *this;

}

object &object::append_list(object const &o, interpreter &i) {

int res = Tcl_ListObjAppendList(i.get(), obj_, o.obj_);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return *this;

}

object &object::replace(size_t index, size_t count, object const &o, interpreter &i) {

int res = Tcl_ListObjReplace(i.get(), obj_, static_cast<int>(index), static_cast<int>(count), 1, &(o.obj_));

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return *this;

}

object &object::replace_list(size_t index, size_t count, object const &o, interpreter &i) {

Tcl_Size objc;

Tcl_Obj **objv;

int res = Tcl_ListObjGetElements(i.get(), o.obj_, &objc, &objv);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

res = Tcl_ListObjReplace(i.get(), obj_, static_cast<int>(index), static_cast<int>(count), objc, objv);

if (res != TCL_OK) {

throw tcl_error(i.get());

}

return *this;

}

void object::set_interp(Tcl_Interp *interp) { interp_ = interp; }

Tcl_Interp *object::get_interp() const { return interp_; }

Tcl::interpreter *interpreter::defaultInterpreter = nullptr;

interpreter::interpreter() {

}

interpreter::interpreter(Tcl_Interp *interp, bool owner) {

}

interpreter::interpreter(const interpreter &i) : interp_(i.interp_), owner_(i.owner_) {}

interpreter::~interpreter() {

if (owner_) {

// clear all callback info belonging to this interpreter

clear_definitions(interp_);

Tcl_DeleteInterp(interp_);

}

}

#if TCL_MAJOR_VERSION < 9

void interpreter::make_safe() {

}

#endif

result interpreter::eval(string const &script) {

}

result interpreter::eval(istream &s) {

string str(istreambuf_iterator<char>(s.rdbuf()), istreambuf_iterator<char>());

return eval(str);

}

result interpreter::eval(object const &o) {

}

result interpreter::getVar(string const &variableName, string const &indexName) {

}

result interpreter::getVar(string const &variableName) {

}

bool interpreter::exists(string const &variableName, string const &indexName) {

}

bool interpreter::exists(string const &variableName) {

}

void interpreter::pkg_provide(string const &name, string const &version) {

}

void interpreter::create_namespace(string const &name) {

}

void interpreter::create_alias(string const &cmd, interpreter &targetInterp, string const &targetCmd) {

}

void interpreter::clear_definitions(Tcl_Interp *interp) {

}

void interpreter::add_function(string const &name, shared_ptr<callback_base> cb, policies const &p) {

}

void interpreter::add_class(string const &name, shared_ptr<class_handler_base> chb) { class_handlers[interp_][name] = chb; }

void interpreter::add_constructor(string const &name, shared_ptr<class_handler_base> chb, shared_ptr<callback_base> cb, policies const &p) {

}

int tcl_cast<int>::from(Tcl_Interp *interp, Tcl_Obj *obj, bool) {

int res;

int cc = Tcl_GetIntFromObj(interp, obj, &res);

if (cc != TCL_OK) {

throw tcl_error(interp);

}

return res;

}

long tcl_cast<long>::from(Tcl_Interp *interp, Tcl_Obj *obj, bool) {

long res;

int cc = Tcl_GetLongFromObj(interp, obj, &res);

if (cc != TCL_OK) {

throw tcl_error(interp);

}

return res;

}

bool tcl_cast<bool>::from(Tcl_Interp *interp, Tcl_Obj *obj, bool) {

int res;

int cc = Tcl_GetBooleanFromObj(interp, obj, &res);

if (cc != TCL_OK) {

throw tcl_error(interp);

}

return res != 0;

}

double tcl_cast<double>::from(Tcl_Interp *interp, Tcl_Obj *obj, bool) {

double res;

int cc = Tcl_GetDoubleFromObj(interp, obj, &res);

if (cc != TCL_OK) {

throw tcl_error(interp);

}

return res;

}

string tcl_cast<string>::from(Tcl_Interp *, Tcl_Obj *obj, bool) { return Tcl_GetString(obj); }

char const *tcl_cast<char const *>::from(Tcl_Interp *, Tcl_Obj *obj, bool) { return Tcl_GetString(obj); }

object tcl_cast<object>::from(Tcl_Interp *interp, Tcl_Obj *obj, bool) {

object o(obj);

o.set_interp(interp);

return o;

}