#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>

#include <ostd/algorithm.hh>
#include <ostd/array.hh>
#include <ostd/vector.hh>
#include <ostd/string.hh>
#include <ostd/keyset.hh>
#include <ostd/format.hh>
#include <ostd/functional.hh>
#include <ostd/map.hh>
#include <ostd/io.hh>
#include <ostd/maybe.hh>

inline char *dup_ostr(ostd::ConstCharRange s) {
    char *r = new char[s.size() + 1];
    memcpy(r, s.data(), s.size());
    r[s.size()] = 0;
    return r;
}

static constexpr int MAX_ARGUMENTS = 25;
static constexpr int MAX_RESULTS = 7;
static constexpr int MAX_COMARGS = 12;

enum {
    VAL_NULL = 0, VAL_INT, VAL_FLOAT, VAL_STR,
    VAL_ANY, VAL_CODE, VAL_MACRO, VAL_IDENT, VAL_CSTR,
    VAL_CANY, VAL_WORD, VAL_POP, VAL_COND
};

enum {
    CODE_START = 0,
    CODE_OFFSET,
    CODE_NULL, CODE_TRUE, CODE_FALSE, CODE_NOT,
    CODE_POP,
    CODE_ENTER, CODE_ENTER_RESULT,
    CODE_EXIT, CODE_RESULT_ARG,
    CODE_VAL, CODE_VALI,
    CODE_DUP,
    CODE_MACRO,
    CODE_BOOL,
    CODE_BLOCK, CODE_EMPTY,
    CODE_COMPILE, CODE_COND,
    CODE_FORCE,
    CODE_RESULT,
    CODE_IDENT, CODE_IDENTU, CODE_IDENTARG,
    CODE_COM, CODE_COMD, CODE_COMC, CODE_COMV,
    CODE_CONC, CODE_CONCW, CODE_CONCM, CODE_DOWN,
    CODE_SVAR, CODE_SVARM, CODE_SVAR1,
    CODE_IVAR, CODE_IVAR1, CODE_IVAR2, CODE_IVAR3,
    CODE_FVAR, CODE_FVAR1,
    CODE_LOOKUP, CODE_LOOKUPU, CODE_LOOKUPARG,
    CODE_LOOKUPM, CODE_LOOKUPMU, CODE_LOOKUPMARG,
    CODE_ALIAS, CODE_ALIASU, CODE_ALIASARG,
    CODE_CALL, CODE_CALLU, CODE_CALLARG,
    CODE_PRINT,
    CODE_LOCAL,
    CODE_DO, CODE_DOARGS,
    CODE_JUMP, CODE_JUMP_TRUE, CODE_JUMP_FALSE,
    CODE_JUMP_RESULT_TRUE, CODE_JUMP_RESULT_FALSE,

    CODE_OP_MASK = 0x3F,
    CODE_RET = 6,
    CODE_RET_MASK = 0xC0,

    /* return type flags */
    RET_NULL   = VAL_NULL << CODE_RET,
    RET_STR    = VAL_STR << CODE_RET,
    RET_INT    = VAL_INT << CODE_RET,
    RET_FLOAT  = VAL_FLOAT << CODE_RET,
};

enum {
    ID_VAR, ID_FVAR, ID_SVAR, ID_COMMAND, ID_ALIAS, ID_LOCAL,
    ID_DO, ID_DOARGS, ID_IF, ID_RESULT, ID_NOT, ID_AND, ID_OR
};

enum {
    IDF_PERSIST    = 1 << 0,
    IDF_OVERRIDE   = 1 << 1,
    IDF_HEX        = 1 << 2,
    IDF_READONLY   = 1 << 3,
    IDF_OVERRIDDEN = 1 << 4,
    IDF_UNKNOWN    = 1 << 5,
    IDF_ARG        = 1 << 6
};

struct Ident;

struct IdentValue {
    union {
        int i;      /* ID_VAR, VAL_INT */
        float f;    /* ID_FVAR, VAL_FLOAT */
        char *s;    /* ID_SVAR, VAL_STR */
        const ostd::uint *code; /* VAL_CODE */
        Ident *id;  /* VAL_IDENT */
        const char *cstr; /* VAL_CSTR */
    };
};

struct TaggedValue: IdentValue {
    int type;

    void set_int(int val) {
        type = VAL_INT;
        i = val;
    }
    void set_float(float val) {
        type = VAL_FLOAT;
        f = val;
    }
    void set_str(char *val) {
        type = VAL_STR;
        s = val;
    }
    void set_null() {
        type = VAL_NULL;
        i = 0;
    }
    void set_code(const ostd::uint *val) {
        type = VAL_CODE;
        code = val;
    }
    void set_macro(const ostd::uint *val) {
        type = VAL_MACRO;
        code = val;
    }
    void set_cstr(const char *val) {
        type = VAL_CSTR;
        cstr = val;
    }
    void set_ident(Ident *val) {
        type = VAL_IDENT;
        id = val;
    }

    const char *get_str() const;
    int get_int() const;
    float get_float() const;
    void get_val(TaggedValue &r) const;

    void force_null();
    float force_float();
    int force_int();
    const char *force_str();
    void force(int type);

    void cleanup();
};

struct IdentStack {
    IdentValue val;
    int valtype;
    IdentStack *next;
};

union IdentValuePtr {
    void *p;
    int *i;   /* ID_VAR */
    float *f; /* ID_FVAR */
    char **s; /* ID_SVAR */
};

struct CsState;

using IdentFunc = void (__cdecl *)(CsState &cs, Ident *id);

struct Ident {
    ostd::byte type; /* ID_something */
    union {
        ostd::byte valtype; /* ID_ALIAS */
        ostd::byte numargs; /* ID_COMMAND */
    };
    ostd::ushort flags;
    int index;
    ostd::String name;
    union {
        struct { /* ID_VAR, ID_FVAR, ID_SVAR */
            union {
                struct { /* ID_VAR */
                    int minval, maxval;
                };
                struct { /* ID_FVAR */
                    float minvalf, maxvalf;
                };
            };
            IdentValuePtr storage;
            IdentValue overrideval;
        };
        struct { /* ID_ALIAS */
            ostd::uint *code;
            IdentValue val;
            IdentStack *stack;
        };
        struct { /* ID_COMMAND */
            char *args;
            ostd::uint argmask;
        };
    };
    IdentFunc fun; /* ID_VAR, ID_FVAR, ID_SVAR, ID_COMMAND */

    Ident() {}
    /* ID_VAR */
    Ident(int t, ostd::ConstCharRange n, int m, int x, int *s, IdentFunc f = nullptr, int flags = 0)
        : type(t), flags(flags | (m > x ? IDF_READONLY : 0)), name(n), minval(m), maxval(x), fun(f) {
        storage.i = s;
    }
    /* ID_FVAR */
    Ident(int t, ostd::ConstCharRange n, float m, float x, float *s, IdentFunc f = nullptr, int flags = 0)
        : type(t), flags(flags | (m > x ? IDF_READONLY : 0)), name(n), minvalf(m), maxvalf(x), fun(f) {
        storage.f = s;
    }
    /* ID_SVAR */
    Ident(int t, ostd::ConstCharRange n, char **s, IdentFunc f = nullptr, int flags = 0)
        : type(t), flags(flags), name(n), fun(f) {
        storage.s = s;
    }
    /* ID_ALIAS */
    Ident(int t, ostd::ConstCharRange n, char *a, int flags)
        : type(t), valtype(VAL_STR), flags(flags), name(n), code(nullptr), stack(nullptr) {
        val.s = a;
    }
    Ident(int t, ostd::ConstCharRange n, int a, int flags)
        : type(t), valtype(VAL_INT), flags(flags), name(n), code(nullptr), stack(nullptr) {
        val.i = a;
    }
    Ident(int t, ostd::ConstCharRange n, float a, int flags)
        : type(t), valtype(VAL_FLOAT), flags(flags), name(n), code(nullptr), stack(nullptr) {
        val.f = a;
    }
    Ident(int t, ostd::ConstCharRange n, int flags)
        : type(t), valtype(VAL_NULL), flags(flags), name(n), code(nullptr), stack(nullptr) {
    }
    Ident(int t, ostd::ConstCharRange n, const TaggedValue &v, int flags)
        : type(t), valtype(v.type), flags(flags), name(n), code(nullptr), stack(nullptr) {
        val = v;
    }
    /* ID_COMMAND */
    Ident(int t, ostd::ConstCharRange n, ostd::ConstCharRange args, ostd::uint argmask, int numargs, IdentFunc f = nullptr, int flags = 0)
        : type(t), numargs(numargs), flags(flags), name(n), args(!args.empty() ? dup_ostr(args) : nullptr), argmask(argmask), fun(f) {
    }

    void changed(CsState &cs) {
        if (fun) fun(cs, this);
    }

    void setval(const TaggedValue &v) {
        valtype = v.type;
        val = v;
    }

    void setval(const IdentStack &v) {
        valtype = v.valtype;
        val = v.val;
    }

    void forcenull() {
        if (valtype == VAL_STR) delete[] val.s;
        valtype = VAL_NULL;
    }

    float get_float() const;
    int get_int() const;
    const char *get_str() const;
    void get_val(TaggedValue &r) const;
    void getcstr(TaggedValue &v) const;
    void getcval(TaggedValue &v) const;

    ostd::ConstCharRange get_key() const {
        return name.iter();
    }

    void clean_code();

    void push_arg(const TaggedValue &v, IdentStack &st);
    void pop_arg();
    void undo_arg(IdentStack &st);
    void redo_arg(const IdentStack &st);

    void push_alias(IdentStack &st);
    void pop_alias();

    void set_arg(CsState &cs, TaggedValue &v);
    void set_alias(CsState &cs, TaggedValue &v);
};

struct IdentLink {
    Ident *id;
    IdentLink *next;
    int usedargs;
    IdentStack *argstack;
};

void debug_alias(CsState &cs);
ostd::ConstCharRange debug_line(CsState &cs, ostd::ConstCharRange p,
                               ostd::ConstCharRange fmt,
                               ostd::CharRange buf);

struct CsState {
    ostd::Keyset<Ident> idents;
    ostd::Vector<Ident *> identmap;

    Ident *dummy = nullptr;
    TaggedValue *result = nullptr;

    IdentLink noalias = {
        nullptr, nullptr, (1 << MAX_ARGUMENTS) - 1, nullptr
    };
    IdentLink *stack = &noalias;

    ostd::ConstCharRange src_file;
    ostd::ConstCharRange src_str;

    int identflags = 0;
    int nodebug = 0;
    int numargs = 0;
    int dbgalias = 4;

    CsState();
    ~CsState();

    void clear_override(Ident &id);
    void clear_overrides();

    template<typename ...A>
    Ident *add_ident(A &&...args) {
        Ident &def = idents.emplace(ostd::forward<A>(args)...).first.front();
        def.index = identmap.size();
        return identmap.push(&def);
    }

    Ident *new_ident(ostd::ConstCharRange name, int flags = 0);
    Ident *force_ident(TaggedValue &v);

    Ident *get_ident(ostd::ConstCharRange name) {
        return idents.at(name);
    }

    bool have_ident(ostd::ConstCharRange name) {
        return idents.at(name) != nullptr;
    }

    bool reset_var(ostd::ConstCharRange name);
    void touch_var(ostd::ConstCharRange name);

    template<typename F>
    bool add_command(ostd::ConstCharRange name, ostd::ConstCharRange args,
                     F func, int type = ID_COMMAND) {
        return add_command(name, args,
            (IdentFunc)(ostd::FunctionMakeDefaultConstructible<F>)func, type);
    }

    bool add_command(ostd::ConstCharRange name, ostd::ConstCharRange args,
                     IdentFunc func, int type = ID_COMMAND);

    ostd::String run_str(const ostd::uint *code);
    ostd::String run_str(ostd::ConstCharRange code);
    ostd::String run_str(Ident *id, ostd::PointerRange<TaggedValue> args);

    int run_int(const ostd::uint *code);
    int run_int(ostd::ConstCharRange code);
    int run_int(Ident *id, ostd::PointerRange<TaggedValue> args);

    float run_float(const ostd::uint *code);
    float run_float(ostd::ConstCharRange code);
    float run_float(Ident *id, ostd::PointerRange<TaggedValue> args);

    bool run_bool(const ostd::uint *code);
    bool run_bool(ostd::ConstCharRange code);
    bool run_bool(Ident *id, ostd::PointerRange<TaggedValue> args);

    void run_ret(const ostd::uint *code, TaggedValue &result);
    void run_ret(ostd::ConstCharRange code, TaggedValue &result);
    void run_ret(Ident *id, ostd::PointerRange<TaggedValue> args,
                 TaggedValue &result);

    void run_ret(const ostd::uint *code) {
        run_ret(code, *result);
    }

    void run_ret(ostd::ConstCharRange code) {
        run_ret(code, *result);
    }

    void run_ret(Ident *id, ostd::PointerRange<TaggedValue> args) {
        run_ret(id, args, *result);
    }

    bool run_file(ostd::ConstCharRange fname, bool msg = true);

    template<typename ...A>
    void debug_code(ostd::ConstCharRange fmt, A &&...args) {
        if (nodebug) return;
        ostd::err.writefln(fmt, ostd::forward<A>(args)...);
        debug_alias(*this);
    }

    template<typename ...A>
    void debug_code_line(ostd::ConstCharRange p,
                         ostd::ConstCharRange fmt, A &&...args) {
        if (nodebug) return;
        ostd::Array<char, 256> buf;
        ostd::err.writefln(debug_line(*this, p, fmt,
                                      ostd::CharRange(buf.data(),
                                                      buf.size())),
                           ostd::forward<A>(args)...);
        debug_alias(*this);
    }

    void set_alias(ostd::ConstCharRange name, TaggedValue &v);

    void set_var_int(ostd::ConstCharRange name, int v,
                     bool dofunc = true, bool doclamp = true);
    void set_var_float(ostd::ConstCharRange name, float v,
                       bool dofunc = true, bool doclamp = true);
    void set_var_str(ostd::ConstCharRange name, ostd::ConstCharRange v,
                     bool dofunc = true);

    void set_var_int_checked(Ident *id, int v);
    void set_var_int_checked(Ident *id, ostd::PointerRange<TaggedValue> args);
    void set_var_float_checked(Ident *id, float v);
    void set_var_str_checked(Ident *id, ostd::ConstCharRange v);

    ostd::Maybe<int> get_var_int(ostd::ConstCharRange name);
    ostd::Maybe<float> get_var_float(ostd::ConstCharRange name);
    ostd::Maybe<ostd::String> get_var_str(ostd::ConstCharRange name);

    ostd::Maybe<int> get_var_min_int(ostd::ConstCharRange name);
    ostd::Maybe<int> get_var_max_int(ostd::ConstCharRange name);

    ostd::Maybe<float> get_var_min_float(ostd::ConstCharRange name);
    ostd::Maybe<float> get_var_max_float(ostd::ConstCharRange name);

    ostd::Maybe<ostd::ConstCharRange> get_alias(ostd::ConstCharRange name);
};

extern CsState cstate;

extern const char *intstr(int v);
extern const char *floatstr(float v);
extern void stringret(CsState &cs, char *s);
extern void result(CsState &cs, TaggedValue &v);
extern void result(CsState &cs, const char *s);

static inline int parseint(const char *s) {
    return int(strtoul(s, nullptr, 0));
}

#define PARSEFLOAT(name, type) \
    static inline type parse##name(const char *s) \
    { \
        /* not all platforms (windows) can parse hexadecimal integers via strtod */ \
        char *end; \
        double val = strtod(s, &end); \
        return val || end==s || (*end!='x' && *end!='X') ? type(val) : type(parseint(s)); \
    }
PARSEFLOAT(float, float)
PARSEFLOAT(number, double)

static inline void intformat(char *buf, int v, int len = 20) {
    snprintf(buf, len, "%d", v);
}
static inline void floatformat(char *buf, float v, int len = 20) {
    snprintf(buf, len, v == int(v) ? "%.1f" : "%.7g", v);
}

static inline const char *get_str(const IdentValue &v, int type) {
    switch (type) {
    case VAL_STR:
    case VAL_MACRO:
    case VAL_CSTR:
        return v.s;
    case VAL_INT:
        return intstr(v.i);
    case VAL_FLOAT:
        return floatstr(v.f);
    default:
        return "";
    }
}
inline const char *TaggedValue::get_str() const {
    return ::get_str(*this, type);
}
inline const char *Ident::get_str() const {
    return ::get_str(val, valtype);
}

#define GETNUMBER(name, ret) \
    static inline ret get_##name(const IdentValue &v, int type) \
    { \
        switch(type) \
        { \
            case VAL_FLOAT: return ret(v.f); \
            case VAL_INT: return ret(v.i); \
            case VAL_STR: case VAL_MACRO: case VAL_CSTR: return parse##name(v.s); \
            default: return ret(0); \
        } \
    } \
    inline ret TaggedValue::get_##name() const { return ::get_##name(*this, type); } \
    inline ret Ident::get_##name() const { return ::get_##name(val, valtype); }
GETNUMBER(int, int)
GETNUMBER(float, float)

static inline void get_val(const IdentValue &v, int type, TaggedValue &r) {
    switch (type) {
    case VAL_STR:
    case VAL_MACRO:
    case VAL_CSTR:
        r.set_str(dup_ostr(v.s));
        break;
    case VAL_INT:
        r.set_int(v.i);
        break;
    case VAL_FLOAT:
        r.set_float(v.f);
        break;
    default:
        r.set_null();
        break;
    }
}

inline void TaggedValue::get_val(TaggedValue &r) const {
    ::get_val(*this, type, r);
}
inline void Ident::get_val(TaggedValue &r) const {
    ::get_val(val, valtype, r);
}

inline void Ident::getcstr(TaggedValue &v) const {
    switch (valtype) {
    case VAL_MACRO:
        v.set_macro(val.code);
        break;
    case VAL_STR:
    case VAL_CSTR:
        v.set_cstr(val.s);
        break;
    case VAL_INT:
        v.set_str(dup_ostr(intstr(val.i)));
        break;
    case VAL_FLOAT:
        v.set_str(dup_ostr(floatstr(val.f)));
        break;
    default:
        v.set_cstr("");
        break;
    }
}

inline void Ident::getcval(TaggedValue &v) const {
    switch (valtype) {
    case VAL_MACRO:
        v.set_macro(val.code);
        break;
    case VAL_STR:
    case VAL_CSTR:
        v.set_cstr(val.s);
        break;
    case VAL_INT:
        v.set_int(val.i);
        break;
    case VAL_FLOAT:
        v.set_float(val.f);
        break;
    default:
        v.set_null();
        break;
    }
}

extern ostd::uint *compilecode(const char *p);
extern void keepcode(ostd::uint *p);
extern void freecode(ostd::uint *p);

extern const char *getalias(const char *name);
extern const char *escapestring(const char *s);
extern const char *escapeid(const char *s);
static inline const char *escapeid(Ident &id) {
    return escapeid(id.name.data());
}
extern bool validateblock(const char *s);
void explodelist(const char *s, ostd::Vector<ostd::String> &elems, int limit = -1);
extern char *indexlist(const char *s, int pos);
extern int listlen(CsState &cs, const char *s);
extern void printvar(Ident *id);
extern void printvar(Ident *id, int i);
extern void printfvar(Ident *id, float f);
extern void printsvar(Ident *id, const char *s);

#define COMMAND(name, nargs) static bool __dummy_##name = cstate.add_command(#name, nargs, (IdentFunc)name, ID_COMMAND)

#define ICOMMANDNAME(name) _icmd_##name
#define ICOMMANDSNAME _icmds_
#define ICOMMANDNS(name, cmdname, nargs, proto, b) template<int N> struct cmdname; template<> struct cmdname<__LINE__> { static bool init; static void run proto; }; bool cmdname<__LINE__>::init = cstate.add_command(name, nargs, (IdentFunc)cmdname<__LINE__>::run, ID_COMMAND); void cmdname<__LINE__>::run proto \
    { b; }
#define ICOMMANDN(name, cmdname, nargs, proto, b) ICOMMANDNS(#name, cmdname, nargs, proto, b)
#define ICOMMAND(name, nargs, proto, b) ICOMMANDN(name, ICOMMANDNAME(name), nargs, proto, b)
#define ICOMMANDS(name, nargs, proto, b) ICOMMANDNS(name, ICOMMANDSNAME, nargs, proto, b)

void init_lib_base(CsState &cs);
void init_lib_io(CsState &cs);
void init_lib_math(CsState &cs);
void init_lib_shell(CsState &cs);