#include "lix/libexpr/nixexpr.hh"
#include "lix/libexpr/eval.hh"
#include "lix/libexpr/symbol-table.hh"
#include "lix/libexpr/print.hh"
#include "lix/libutil/json.hh"

#include <cstdlib>
#include <sstream>

namespace nix {

ExprBlackHole eBlackHole;

static Env nullEnv;
Value::Thunk Value::blackHole{{&nullEnv}, &eBlackHole};

// FIXME: remove, because *symbols* are abstract and do not have a single
//        textual representation; see printIdentifier()
std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
{
    std::string_view s = symbol;
    return printIdentifier(str, s);
}

std::ostream & operator<<(std::ostream & str, const InternedSymbol & symbol)
{
    str << SymbolStr(symbol);
    return str;
}

AttrName::AttrName(PosIdx pos, Symbol s) : pos(pos), symbol(s)
{
}

AttrName::AttrName(PosIdx pos, std::unique_ptr<Expr> e) : pos(pos), expr(std::move(e))
{
}

static JSON stringToJSON(std::string_view s)
{
    try {
        JSON value = s;
        // dump it now to catch invalid utf8 strings early. this code path is not
        // hot, so the extra memory allocation and encoding is not worth avoiding
        (void) value.dump();
        return value;
    } catch (json::JSONError & e) {
        if (e.id == 316) {
            // invalid utf8 in string! serialize as byte array instead
            return s | std::ranges::to<std::vector<unsigned char>>();
        } else {
            throw;
        }
    }
}

JSON Expr::toJSON(const SymbolTable & symbols) const
{
    abort();
}

JSON ExprLiteral::toJSON(const SymbolTable & symbols) const
{
    JSON valueType;
    JSON value;
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wswitch-enum"
    switch (v.type()) {
        case nInt:
            valueType = "Int";
            value = v.integer().value;
            break;
        case nFloat:
            valueType = "Float";
            value = v.fpoint();
            break;
        case nString:
            valueType = "String";
            value = stringToJSON(v.str());
            break;
        case nPath:
            valueType = "Path";
            value = v.path().to_string();
            break;
        default:
            assert(false);
    };
    #pragma GCC diagnostic pop

    return {
        {"_type", "ExprLiteral"},
        {"valueType", valueType},
        {"value", value}
    };
}

JSON ExprVar::toJSON(const SymbolTable & symbols) const
{
    return {{"_type", "ExprVar"}, {"value", stringToJSON(symbols[name])}};
}

JSON ExprInheritFrom::toJSON(SymbolTable const & symbols) const
{
    return {
        {"_type", "ExprInheritFrom"}
    };
}

JSON ExprSelect::toJSON(const SymbolTable & symbols) const
{
    JSON out = {
        {"_type", "ExprSelect"},
        {"e", e->toJSON(symbols)},
        {"attrs", printAttrPathToJson(symbols, attrPath)}
    };
    if (def)
        out["default"] = def->toJSON(symbols);
    return out;
}

JSON ExprOpHasAttr::toJSON(const SymbolTable & symbols) const
{
    return {
        {"_type", "ExprOpHasAttr"},
        {"e", e->toJSON(symbols)},
        {"attrs", printAttrPathToJson(symbols, attrPath)}
    };
}

void ExprAttrs::addBindingsToJSON(JSON & out, const SymbolTable & symbols) const
{
    typedef const decltype(attrs)::value_type * Attr;
    std::vector<Attr> sorted;
    for (auto & i : attrs) sorted.push_back(&i);
    // NOTE: this sort uses a total order, so the iteration over pointers is not an issue
    // NOLINTNEXTLINE(bugprone-nondeterministic-pointer-iteration-order)
    std::sort(sorted.begin(), sorted.end(), [&](Attr a, Attr b) {
        std::string_view sa = symbols[a->first], sb = symbols[b->first];
        return sa < sb;
    });
    std::map<Displacement, std::vector<Symbol>> inheritsFrom;
    for (auto & i : sorted) {
        switch (i->second.kind) {
        case AttrDef::Kind::Plain:
        case AttrDef::Kind::Inherited: {
            const auto key = i->second.kind == AttrDef::Kind::Plain ? "attrs" : "inherit";
            auto name = stringToJSON(symbols[i->first]);
            if (name.is_string()) {
                out[key][name] = i->second.e->toJSON(symbols);
            } else {
                out[fmt("binary_%s", key)][key].push_back({
                    {"name", name},
                    {"value", i->second.e->toJSON(symbols)},
                });
            }
            break;
        }
        case AttrDef::Kind::InheritedFrom: {
            auto & select = i->second.e->cast<ExprSelect>();
            auto & from = select.e->cast<ExprInheritFrom>();
            inheritsFrom[from.displ].push_back(i->first);
            break;
        }
        }
    }

    std::vector<Expr *> inheritFromExprs;
    if (this->inheritFromExprs) {
        for (auto & e : *this->inheritFromExprs) {
            inheritFromExprs.push_back(e.get());
        }
    }

    for (const auto & [from, syms] : inheritsFrom) {
        JSON attrs = JSON::array();
        for (auto sym : syms)
            attrs.push_back(stringToJSON(symbols[sym]));
        out["inheritFrom"].push_back({
            {"from", inheritFromExprs[from]->toJSON(symbols)},
            {"attrs", attrs}
        });
    }

    for (auto & i : dynamicAttrs) {
        out["dynamicAttrs"].push_back({
            {"name", i.nameExpr->toJSON(symbols) },
            {"value", i.valueExpr->toJSON(symbols)}
        });
    }
}

JSON ExprSet::toJSON(const SymbolTable & symbols) const
{
    JSON out = {
        {"_type", "ExprSet"},
        {"recursive", recursive},
    };
    addBindingsToJSON(out, symbols);
    return out;
}

JSON ExprList::toJSON(const SymbolTable & symbols) const
{
    JSON list = JSON::array();
    for (auto & i : elems)
        list.push_back(i->toJSON(symbols));
    return {
        { "_type", "ExprList" },
        { "elems", list },
    };
}

void SimplePattern::addBindingsToJSON(JSON & out, const SymbolTable & symbols) const
{
    // name must be alphanumeric
    out["arg"] = symbols[name];
}

void AttrsPattern::addBindingsToJSON(JSON & out, const SymbolTable & symbols) const
{
    // name must be alphanumeric
    if (name)
        out["arg"] = symbols[name];

    // the natural Symbol ordering is by creation time, which can lead to the
    // same expression being printed in two different ways depending on its
    // context. always use lexicographic ordering to avoid this.
    for (const Formal & i : lexicographicOrder(symbols)) {
        // names must be alphanumeric
        if (i.def)
            out["formals"][std::string(symbols[i.name])] = i.def->toJSON(symbols);
        else
            out["formals"][std::string(symbols[i.name])] = nullptr;
    }
    out["formalsEllipsis"] = ellipsis;
}

JSON ExprLambda::toJSON(const SymbolTable & symbols) const
{
    JSON out = {
        { "_type", "ExprLambda" },
        { "body", body->toJSON(symbols) }
    };
    pattern->addBindingsToJSON(out, symbols);
    return out;
}

JSON ExprCall::toJSON(const SymbolTable & symbols) const
{
    JSON outArgs = JSON::array();
    for (auto & e : args)
        outArgs.push_back(e->toJSON(symbols));
    return {
        {"_type", "ExprCall"},
        {"fun", fun->toJSON(symbols)},
        {"args", outArgs}
    };
}

JSON ExprLet::toJSON(const SymbolTable & symbols) const
{
    JSON out = {
        { "_type", "ExprLet" },
        { "body", body->toJSON(symbols) }
    };
    addBindingsToJSON(out, symbols);
    return out;
}

JSON ExprWith::toJSON(const SymbolTable & symbols) const
{
    return {
        {"_type", "ExprWith"},
        {"attrs", attrs->toJSON(symbols)},
        {"body", body->toJSON(symbols)}
    };
}

JSON ExprIf::toJSON(const SymbolTable & symbols) const
{
    return {
        {"_type", "ExprIf"},
        {"cond", cond->toJSON(symbols)},
        {"then", then->toJSON(symbols)},
        {"else", else_->toJSON(symbols)}
    };
}

JSON ExprAssert::toJSON(const SymbolTable & symbols) const
{
    return {
        {"_type", "ExprAssert"},
        {"cond", cond->toJSON(symbols)},
        {"body", body->toJSON(symbols)}
    };
}

JSON ExprOpNot::toJSON(const SymbolTable & symbols) const
{
    return {
        {"_type", "ExprOpNot"},
        {"e", e->toJSON(symbols)}
    };
}

JSON ExprConcatStrings::toJSON(const SymbolTable & symbols) const
{
    JSON parts = JSON::array();
    for (auto & [_pos, part] : es)
        parts.push_back(part->toJSON(symbols));
    return {
        {"_type", "ExprConcatStrings"},
        {"isInterpolation", isInterpolation},
        {"es", parts}
    };
}

JSON ExprPos::toJSON(const SymbolTable & symbols) const
{
    return {{ "_type", "ExprPos" }};
}


std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath)
{
    std::ostringstream out;
    bool first = true;
    for (auto & i : attrPath) {
        if (!first) out << '.'; else first = false;
        if (i.symbol)
            out << symbols[i.symbol];
        else
            out << "\"${...}\"";
    }
    return out.str();
}

JSON printAttrPathToJson(const SymbolTable & symbols, const AttrPath & attrPath)
{
    JSON out = JSON::array();
    for (auto & i : attrPath) {
        if (i.symbol)
            out.push_back(stringToJSON(symbols[i.symbol]));
        else
            out.push_back(i.expr->toJSON(symbols));
    }
    return out;
}


/* Computing levels/displacements for variables. */

namespace {
struct VarBinder : ExprVisitor
{
    Evaluator & es;
    std::shared_ptr<const StaticEnv> env;

    VarBinder(Evaluator & eval, std::shared_ptr<const StaticEnv> env) : es(eval), env(env) {}

    auto withEnv(std::shared_ptr<const StaticEnv> env, auto fn)
    {
        std::swap(env, this->env);
        KJ_DEFER(std::swap(env, this->env););
        return fn();
    }

    using ExprVisitor::visit;

    void visit(ExprDebugFrame & e, std::unique_ptr<Expr> & ptr) override
    {
        visit(e.inner);
    }
    void visit(ExprLiteral & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprVar & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprInheritFrom & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprSelect & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprOpHasAttr & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprSet & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprList & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprLambda & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprCall & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprLet & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprWith & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprIf & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprAssert & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprOpNot & e, std::unique_ptr<Expr> & ptr) override;
#define BINOP(type)                                            \
    /* NOLINTNEXTLINE(bugprone-macro-parentheses) */           \
    void visit(type & e, std::unique_ptr<Expr> & ptr) override \
    {                                                          \
        visit(e.e1);                                           \
        visit(e.e2);                                           \
    }
    BINOP(ExprOpEq)
    BINOP(ExprOpNEq)
    BINOP(ExprOpAnd)
    BINOP(ExprOpOr)
    BINOP(ExprOpImpl)
    BINOP(ExprOpUpdate)
    BINOP(ExprOpConcatLists)
#undef BINOP
    void visit(ExprConcatStrings & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprPos & e, std::unique_ptr<Expr> & ptr) override;
    void visit(ExprBlackHole & e, std::unique_ptr<Expr> & ptr) override {}
};
}

struct DebugVarBinder : VarBinder
{
    using VarBinder::VarBinder, VarBinder::visit;

#define OVERRIDE(type)                                         \
    /* NOLINTNEXTLINE(bugprone-macro-parentheses) */           \
    void visit(type & e, std::unique_ptr<Expr> & ptr) override \
    {                                                          \
        es.debug->exprEnvs.insert(std::make_pair(&e, env));    \
        VarBinder::visit(e, ptr);                              \
    }

    OVERRIDE(ExprLiteral)
    OVERRIDE(ExprVar)
    OVERRIDE(ExprInheritFrom)
    void visit(ExprSelect & e, std::unique_ptr<Expr> & ptr) override
    {
        es.debug->exprEnvs.insert(std::make_pair(&e, env));
        VarBinder::visit(e, ptr);

        ptr = std::make_unique<ExprDebugFrame>(e.pos, std::move(ptr), "while evaluating an attribute");
    }
    OVERRIDE(ExprOpHasAttr)
    OVERRIDE(ExprSet)
    OVERRIDE(ExprList)
    void visit(ExprLambda & e, std::unique_ptr<Expr> & ptr) override
    {
        es.debug->exprEnvs.insert(std::make_pair(&e, env));
        VarBinder::visit(e, ptr);

        e.body = std::make_unique<ExprDebugFrame>(
            e.pos, std::move(e.body), HintFmt("while calling %s", e.getQuotedName(es.symbols)).str()
        );
    }
    void visit(ExprCall & e, std::unique_ptr<Expr> & ptr) override
    {
        es.debug->exprEnvs.insert(std::make_pair(&e, env));
        VarBinder::visit(e, ptr);

        ptr = std::make_unique<ExprDebugFrame>(e.pos, std::move(ptr), "while calling a function");
    }
    void visit(ExprLet & e, std::unique_ptr<Expr> & ptr) override
    {
        es.debug->exprEnvs.insert(std::make_pair(&e, env));
        VarBinder::visit(e, ptr);

        e.body = std::make_unique<ExprDebugFrame>(
            e.pos, std::move(e.body), HintFmt("while evaluating a '%1%' expression", "let").str()
        );
    }
    OVERRIDE(ExprWith)
    OVERRIDE(ExprIf)
    OVERRIDE(ExprAssert)
    OVERRIDE(ExprOpNot)
    OVERRIDE(ExprOpEq)
    OVERRIDE(ExprOpNEq)
    OVERRIDE(ExprOpAnd)
    OVERRIDE(ExprOpOr)
    OVERRIDE(ExprOpImpl)
    OVERRIDE(ExprOpUpdate)
    OVERRIDE(ExprOpConcatLists)
    OVERRIDE(ExprConcatStrings)
    OVERRIDE(ExprPos)
    OVERRIDE(ExprBlackHole)
#undef OVERRIDE
};

std::unique_ptr<Expr> Expr::finalize(
    std::unique_ptr<Expr> parsed, Evaluator & es, const std::shared_ptr<const StaticEnv> & env
)
{
    if (es.debug) {
        DebugVarBinder{es, env}.visit(parsed);
    } else {
        VarBinder{es, env}.visit(parsed);
    }
    return parsed;
}

void VarBinder::visit(ExprLiteral & e, std::unique_ptr<Expr> & ptr)
{
}

void VarBinder::visit(ExprVar & e, std::unique_ptr<Expr> & ptr)
{
    e.fromWith = nullptr;

    /* Check whether the variable appears in the environment.  If so,
       set its level and displacement. */
    const StaticEnv * curEnv;
    Level level;
    int withLevel = -1;
    for (curEnv = env.get(), level = 0; curEnv; curEnv = curEnv->up, level++) {
        if (curEnv->isWith) {
            if (withLevel == -1) withLevel = level;
        } else {
            auto i = curEnv->vars.find(e.name);
            if (i != curEnv->vars.end()) {
                if (e.needsRoot && !curEnv->isRoot) {
                    throw ParseError({
                        .msg = HintFmt(
                            "Shadowing symbol '%s' used in internal expressions is not allowed. Use %s to disable this error.",
                            es.symbols[e.name],
                            "--extra-deprecated-features shadow-internal-symbols"
                        ),
                        .pos = es.positions[e.pos]
                    });
                }

                e.level = level;
                e.displ = i->second;
                return;
            }
        }
    }

    /* Otherwise, the variable must be obtained from the nearest
       enclosing `with'.  If there is no `with', then we can issue an
       "undefined variable" error now. */
    if (withLevel == -1)
        es.errors.make<UndefinedVarError>(
            "undefined variable '%1%'",
            es.symbols[e.name]
        ).atPos(e.pos).throw_();
    for (auto * se = env.get(); se && !e.fromWith; se = se->up)
        e.fromWith = se->isWith;
    e.level = withLevel;
}

void VarBinder::visit(ExprInheritFrom & e, std::unique_ptr<Expr> & ptr)
{
}

void VarBinder::visit(ExprSelect & e, std::unique_ptr<Expr> & ptr)
{
    visit(e.e);
    if (e.def) visit(e.def);
    for (auto & i : e.attrPath)
        if (!i.symbol)
            visit(i.expr);
}

void VarBinder::visit(ExprOpHasAttr & e, std::unique_ptr<Expr> & ptr)
{
    visit(e.e);
    for (auto & i : e.attrPath)
        if (!i.symbol)
            visit(i.expr);
}

std::shared_ptr<const StaticEnv> ExprAttrs::buildRecursiveEnv(const std::shared_ptr<const StaticEnv> & env)
{
    auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), attrs.size());

    // safety: the attrs is already sorted
    newEnv->vars.unsafe_insert_bulk([&] (auto & map) {
        Displacement displ = 0;
        for (auto & i : attrs)
            map.emplace_back(i.first, i.second.displ = displ++);
    });
    return newEnv;
}

std::shared_ptr<const StaticEnv> ExprAttrs::bindInheritSources(ExprVisitor & e, const StaticEnv & env)
{
    if (!inheritFromExprs)
        return nullptr;

    // the inherit (from) source values are inserted into an env of its own, which
    // does not introduce any variable names.
    // analysis must see an empty env, or an env that contains only entries with
    // otherwise unused names to not interfere with regular names. the parser
    // has already filled all exprs that access this env with appropriate level
    // and displacement, and nothing else is allowed to access it. ideally we'd
    // not even *have* an expr that grabs anything from this env since it's fully
    // invisible, but the evaluator does not allow for this yet.
    auto inner = std::make_shared<StaticEnv>(nullptr, &env, 0);
    for (auto & from : *inheritFromExprs)
        e.visit(from);

    return inner;
}

void VarBinder::visit(ExprSet & e, std::unique_ptr<Expr> & ptr)
{
    auto innerEnv = e.recursive ? e.buildRecursiveEnv(env) : env;
    auto inheritFromEnv = withEnv(innerEnv, [&] { return e.bindInheritSources(*this, *innerEnv); });

    // No need to sort newEnv since attrs is in sorted order.

    for (auto & i : e.attrs) {
        withEnv(i.second.chooseByKind(innerEnv, env, inheritFromEnv), [&] {
            visit(i.second.e);
        });
    }

    withEnv(innerEnv, [&] {
        for (auto & i : e.dynamicAttrs) {
            visit(i.nameExpr);
            visit(i.valueExpr);
        }
    });
}

void VarBinder::visit(ExprList & e, std::unique_ptr<Expr> & ptr)
{
    for (auto & i : e.elems)
        visit(i);
}

void VarBinder::visit(ExprLambda & e, std::unique_ptr<Expr> & ptr)
{
    withEnv(e.pattern->buildEnv(env.get()), [&] {
        e.pattern->accept(*this);
        visit(e.body);
    });
}

void VarBinder::visit(ExprCall & e, std::unique_ptr<Expr> & ptr)
{
    visit(e.fun);
    for (auto & se : e.args)
        visit(se);
}

void VarBinder::visit(ExprLet & e, std::unique_ptr<Expr> & ptr)
{
    auto newEnv = e.buildRecursiveEnv(env);

    // No need to sort newEnv since attrs is in sorted order.

    auto inheritFromEnv = withEnv(newEnv, [&] { return e.bindInheritSources(*this, *newEnv); });
    for (auto & i : e.attrs) {
        withEnv(i.second.chooseByKind(newEnv, env, inheritFromEnv), [&] {
            visit(i.second.e);
        });
    }

    withEnv(std::move(newEnv), [&] { visit(e.body); });
}

void VarBinder::visit(ExprWith & e, std::unique_ptr<Expr> & ptr)
{
    e.parentWith = nullptr;
    for (auto * se = env.get(); se && !e.parentWith; se = se->up)
        e.parentWith = se->isWith;

    /* Does this `with' have an enclosing `with'?  If so, record its
       level so that `lookupVar' can look up variables in the previous
       `with' if this one doesn't contain the desired attribute. */
    const StaticEnv * curEnv;
    Level level;
    e.prevWith = 0;
    for (curEnv = env.get(), level = 1; curEnv; curEnv = curEnv->up, level++)
        if (curEnv->isWith) {
            e.prevWith = level;
            break;
        }

    visit(e.attrs);
    withEnv(std::make_shared<StaticEnv>(&e, env.get()), [&] { visit(e.body); });
}

void VarBinder::visit(ExprIf & e, std::unique_ptr<Expr> & ptr)
{
    visit(e.cond);
    visit(e.then);
    visit(e.else_);
}

void VarBinder::visit(ExprAssert & e, std::unique_ptr<Expr> & ptr)
{
    visit(e.cond);
    visit(e.body);
}

void VarBinder::visit(ExprOpNot & e, std::unique_ptr<Expr> & ptr)
{
    visit(e.e);
}

void VarBinder::visit(ExprConcatStrings & e, std::unique_ptr<Expr> & ptr)
{
    for (auto & i : e.es)
        visit(i.second);
}

void VarBinder::visit(ExprPos & e, std::unique_ptr<Expr> & ptr)
{
}

/* Function argument destructuring */

std::shared_ptr<const StaticEnv> SimplePattern::buildEnv(const StaticEnv * up)
{
    auto newEnv = std::make_shared<StaticEnv>(nullptr, up, 1);
    newEnv->vars.insert_or_assign(name, 0);
    return newEnv;
}

void SimplePattern::accept(ExprVisitor & ev) { }

std::shared_ptr<const StaticEnv> AttrsPattern::buildEnv(const StaticEnv * up)
{
    auto newEnv = std::make_shared<StaticEnv>(
        nullptr, up,
        formals.size() + (name ? 1 : 0)
    );

    Displacement displ = 0;

    if (name) newEnv->vars.insert_or_assign(name, displ++);

    // safety: The formals are already sorted
    newEnv->vars.unsafe_insert_bulk([&] (auto & map) {
        for (auto & i : formals)
            map.emplace_back(i.name, displ++);
    });

    return newEnv;
}

void AttrsPattern::accept(ExprVisitor & ev)
{
    for (auto & i : formals)
        if (i.def) ev.visit(i.def);
}

/* Storing function names. */

void Expr::setName(Symbol name)
{
}


void ExprLambda::setName(Symbol name)
{
    this->name = name;
    body->setName(name);
}


std::string ExprLambda::showNamePos(const EvalState & state) const
{
    std::string id(name
        ? concatStrings("'", state.ctx.symbols[name], "'")
        : "anonymous function");
    return fmt("%1% at %2%", id, state.ctx.positions[pos]);
}



/* Position table. */

Pos PosTable::operator[](PosIdx p) const
{
    auto origin = resolve(p);
    if (!origin)
        return {};

    const auto offset = origin->offsetOf(p);

    Pos result{0, 0, origin->origin};
    auto lines = this->lines.lock();
    auto & linesForInput = (*lines)[origin->offset];

    if (linesForInput.empty()) {
        auto source = result.getSource().value_or("");
        const char * begin = source.data();
        for (Pos::LinesIterator it(source), end; it != end; it++)
            linesForInput.push_back(it->data() - begin);
        if (linesForInput.empty())
            linesForInput.push_back(0);
    }
    // as above: the first line starts at byte 0 and is always present
    auto lineStartOffset = std::prev(
        std::upper_bound(linesForInput.begin(), linesForInput.end(), offset));

    result.line = 1 + (lineStartOffset - linesForInput.begin());
    result.column = 1 + (offset - *lineStartOffset);
    return result;
}



/* Symbol table. */

size_t SymbolTable::totalSize() const
{
    size_t n = 0;
    dump([&](const std::string_view s) { n += s.size(); });
    return n;
}

}
