error.h

#ifndef ERROR_H_INCLUDED_
#define ERROR_H_INCLUDED_

#include <exception>
#include <iomanip>
#include <map>
#include <memory>
#include <sstream>
#include <string>

#include "kblib/containers.h"
#include "kblib/convert.h"
#include "kblib/stringops.h"

enum class ec : unsigned {
    // section 0: placeholder errors
    unknown = 0,
    internal,
    no_feature,

    // section 1: system errors

    // section 2: YAML Format errors (load time)
    y_internal = 200,
    too_many_tnode_args,
    invalid_stage_type,
    invalid_normalization_form,
    bad_regex,

    // section 3: noderef syntax errors (expansion time)
    n_internal = 300,
    unterminated_noderef,
    extra_rb,
    lb_in_name,
    illegal_escape,

    // section 4: template string errors (load time)
    p_internal = 400,
    bad_format,
    blank_fname,
    invalid_fname,
    call_arg,
    eos = 405,
    extra_rp,
    extra_lp,
    extra_p,
    extra_ab,
    extra_h = 410,
    extra_c,
    early_close,
    escape_nostr,
    overmarked_arg,
    invalid_raw = 415,
    no_function,

    // section 5: template evaluation errors (expansion time)
    e_internal = 500,
    bad_arg_type,
    bad_arg_rank,
    bad_randspec,
    invoke_null,
    invoke_type = 505,
    node_bad_cvt,
    unpaired_args,
    too_many_args,
    not_enough_args,
    e_nonode = 510,
    range_error,
    bad_math,
    m_divzero,
    null_var,

    // section 6: transformation evaluation errors (transform time)
    t_internal = 600,
};

const std::map<ec, std::string> err_strs{
    // E0
    {ec::unknown, "Unknown error."},
    {ec::internal, "Internal error."},
    {ec::no_feature, "Feature not implemented yet."},

    // E200
    {ec::y_internal, "Unknown load-time error."},
    {ec::too_many_tnode_args, "Too many arguments specified for a node."},
    {ec::invalid_stage_type, "Invalid replace stage type."},
    {ec::invalid_normalization_form, "Invalid normalization form."},
    {ec::bad_regex, "Invalid regular expression"},
    // E205

    // E300
    {ec::n_internal, "Internal error in noderef parser."},
    {ec::unterminated_noderef, "Unterminated reference."},
    {ec::extra_rb, "Encountered '}' outside reference."},
    {ec::lb_in_name, "Encountered '{' inside reference."},
    {ec::illegal_escape, "Illegal escape sequence."},

    // E400
    {ec::p_internal, "Internal error in template parser."},
    {ec::bad_format, "Invalid argref."},
    {ec::blank_fname, "Function names cannot be blank."},
    {ec::invalid_fname, "Invalid character in function name."},
    {ec::call_arg, "Arguments cannot be used as functions."},
    // E405
    {ec::eos, "Unexpected end-of-input"},
    {ec::extra_rp, "Unmatched )."},
    {ec::extra_lp, "Unmatched (; or unexpected >."},
    {ec::extra_p, "Unexpected top-level |."},
    {ec::extra_ab, "unescaped < in template context."},
    // E410
    {ec::extra_h, "encountered unexpected # in argument context."},
    {ec::extra_c, "encountered unexpected characters after )."},
    {ec::early_close, "blank argref is invalid."},
    {ec::escape_nostr, "escape sequence outside of string context."},
    {ec::overmarked_arg, "Argrefs at topmost level do not need #."},
    // E415
    {ec::invalid_raw, "Invalid raw string syntax."},
    {ec::no_function, "No function by this name exists."},

    // E500
    {ec::e_internal, "Internal error in template evaluator."},
    {ec::bad_arg_type,
     "Template function received argument of incorrect type."},
    {ec::bad_arg_rank,
     "Template function received a list when it expected a single element."},
    {ec::bad_randspec, "Bad parameters for a random function."},
    {ec::invoke_null, "Invoke requires arguments."},
    // E505
    {ec::invoke_type,
     "The first argument to invoke must be a string, not a list."},
    {ec::node_bad_cvt,
     "A synthesized node cannot be converted to another type."},
    {ec::unpaired_args, "Template function expected arguments in sets, but "
                        "could not complete a set."},
    {ec::too_many_args,
     "Template function received more arguments than it expected."},
    {ec::not_enough_args,
     "Template function did not receive all expected arguments."},
    // E510
    {ec::e_nonode, "'node' function's argument does not name a node"},
    {ec::range_error, "? or [] index out of range."},
    {ec::bad_math, "Invalid mathematical expression."},
    {ec::m_divzero, "Division by zero occurred."},
    {ec::null_var, "get() of nonexistent variable."},

    // E600
    {ec::t_internal, "Internal error in transformation processor"},
};

inline std::string format_err(ec err) {
    std::ostringstream out;
    out << 'E' << std::setw(3) << std::setfill('0') << static_cast<int>(err)
        << ": " << kblib::get_or(err_strs, err, err_strs.at(ec::unknown))
        << '\n';
    return out.str();
}

class wordgen_error final {
 public:
    wordgen_error(std::string desc, std::string context, std::string loc,
                  std::string info)
        : l1(std::make_shared<std::string>(std::move(desc))),
          l2(std::make_shared<std::string>(std::move(context))),
          l3(std::make_shared<std::string>(std::move(loc))),
          l4(std::make_shared<std::string>(std::move(info))), c(ec::unknown) {}
    wordgen_error(ec err, std::string context, std::string loc, std::string info)
        : l1(std::make_shared<std::string>(format_err(err))),
          l2(std::make_shared<std::string>(std::move(context))),
          l3(std::make_shared<std::string>(std::move(loc))),
          l4(std::make_shared<std::string>(std::move(info))), c(err) {}
    std::shared_ptr<std::string> l1, l2, l3, l4;
    ec c;
    ec code() const { return c; }
    std::string what() const { return kblib::concat(*l1, *l2, *l3, *l4); }
};

inline bool operator==(const wordgen_error& l, const wordgen_error& r) {
    return l.what() == r.what();
}

inline bool operator!=(const wordgen_error& l, const wordgen_error& r) {
    return l.what() != r.what();
}

[[noreturn]] inline void parse_error(ec err, std::string_view str,
                                     const char* epos, std::string msg = "") {
    auto printable = kblib::escapify(str);
    auto index = kblib::calculate_translated_index(str, epos);
    throw wordgen_error(err, kblib::concat("\"", printable, "\"\n"),
                        kblib::concat(" ", kblib::repeat(' ', index), "^\n"),
                        std::move(msg));
}

[[noreturn]] inline void parse_error(ec err, std::string_view str,
                                     long long epos, std::string msg = "") {
    parse_error(err, str, str.data() + epos, std::move(msg));
}

#endif // ERROR_H_INCLUDED_