interpolate.h

#ifndef INTERPOLATE_H_INCLUDED_
#define INTERPOLATE_H_INCLUDED_

#include "containers.h"
#include "random.h"
#include "tstrings.h"

#include <yaml-cpp/yaml.h>

#include "cppcoro/generator.hpp"
#include <algorithm>
#include <experimental/coroutine>
#include <functional>
#include <limits>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>

namespace details {
template <typename T>
struct tag {
    using type = T;
};

// base case: just fail
template <uint64_t V, typename...>
struct min_unsigned;

// recursive case: check using numeric_limits
template <uint64_t V, typename T, typename... Ts>
struct min_unsigned<V, T, Ts...>
    : std::conditional_t<(V <= sizeof(T)), tag<T>, min_unsigned<V, Ts...>> {};

template <uint64_t V>
using min_unsigned_t = typename details::min_unsigned<V, uint8_t, uint16_t,
                                                      uint32_t, uint64_t>::type;
} // namespace details

template <std::size_t N>
struct str_prefix {
    static_assert(N > 0, "str_prefix of size zero is disallowed");
    char str[N];

    constexpr str_prefix() : str{} {}

    /* implicit */ constexpr str_prefix(std::string_view s) : str{} {
        kblib::copy_n(s.begin(), std::min(s.size(), N), &str[0]);
    }

    constexpr str_prefix reverse() const {
        str_prefix reversed;
        for (std::size_t i = 0; i < N; ++i) {
            reversed.str[N - i - 1] = str[i];
        }
        return reversed;
    }

    // I checked already and compilers can't inline this code, but it's needed
    // for constexpr capability.
    template <std::size_t shift = std::numeric_limits<unsigned char>::digits*(N -
                                                                              1)>
    constexpr auto to_uint() const {
        using To = details::min_unsigned_t<N + shift / CHAR_BIT>;
        static_assert(N <= sizeof(To));
        if constexpr (N >= 2) {
            return static_cast<To>(str[N - 1]) << shift |
                   static_cast<To>(
                       str_prefix<N - 1>(std::string_view{std::begin(str), N})
                           .template to_uint<
                               shift -
                               std::numeric_limits<unsigned char>::digits>());
        } else {
            return static_cast<To>(str[0]) << shift;
        }
    }

    // This function is much faster than the above but is not constexpr.
    auto to_uint_fast() const {
        using To = details::min_unsigned_t<N>;
        static_assert(N <= sizeof(To));
        To x;
        if constexpr (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) {
            std::memcpy(&x, &str[0], N);
        } else {
            auto r = reverse();
            std::memcpy(&x, &r.str[0], N);
        }
        return x;
    }

    constexpr char& operator[](std::size_t n) { return str[n]; }
    constexpr const char& operator[](std::size_t n) const { return str[n]; }

    constexpr friend bool operator==(str_prefix lhs, str_prefix rhs) {
        return kblib::equal(&lhs[0], &lhs[N - 1], &rhs[0]);
    }
    constexpr friend bool operator!=(str_prefix lhs, str_prefix rhs) {
        return !(lhs == rhs);
    }
    constexpr friend bool operator<(str_prefix lesser, str_prefix greater) {
        return kblib::lexicographical_compare(&lesser[0], &lesser[N - 1],
                                              &greater[0], &greater[N - 1]);
    }
    constexpr friend bool operator>(str_prefix greater, str_prefix lesser) {
        return lesser < greater;
    }
    constexpr friend bool operator<=(str_prefix lesser, str_prefix greater) {
        return !(greater < lesser);
    }
    constexpr friend bool operator>=(str_prefix greater, str_prefix lesser) {
        return !(greater < lesser);
    }
};

// In order for two channel names to collide, they must have a common prefix of
// at least 4 characters and hash to the same 32-bit value. Considering a file
// can be assumed to have less than ten channels all with distinct and short
// names, this is astronomically unlikely.
using channelID = uint64_t;

constexpr inline channelID ch(std::string_view s) {
    return (static_cast<uint64_t>(str_prefix<4>(s).to_uint_fast()) << 32u |
            kblib::FNVa<std::uint32_t>(s));
}

constexpr channelID operator""_ch(const char* s, std::size_t len) {
    return (static_cast<uint64_t>(str_prefix<4>({s, len}).to_uint()) << 32u |
            kblib::FNVa<std::uint32_t>(std::string_view{s, len}));
}

struct path_t {
    int branch;
    std::vector<path_t> children;
};

using word_data_t = vmap<channelID, std::string, 8>;

struct Word {
    word_data_t data;
    double freq;
    path_t path;

    std::string& val() { return data["val"_ch]; }
    const std::string& val() const { return data.at("val"_ch); }
};

inline auto word_from_val(std::string v) -> word_data_t {
    word_data_t ret;
    ret.emplace("val"_ch, std::move(v));
    return ret;
}

std::string format(const word_data_t& data, std::string_view fmt,
                   const path_t* path = nullptr);

inline std::string format(Word word, std::string_view fmt) {
    // word.data.insert_or_assign("freq"_ch, std::to_string(word.freq));
    word.data.insert_or_assign("freq"_ch, kblib::toStr(word.freq));
    return format(word.data, fmt, &word.path);
}

using string_transformer = std::function<word_data_t(Word, channelID)>;

using replace_sequence = std::vector<string_transformer>;

struct node {
    using Alternative = vmap<channelID, bytecodes>;
    std::vector<std::variant<double, bytecodes>> freqs;
    std::vector<bytecodes> vals;
    std::vector<Alternative> other_channels;
    unsigned short declared_argc;
    bool variadic;
    std::string name;
};

struct ReplaceStage {
    vmap<channelID, replace_sequence> actions;
    Word operator()(const Word&) const;
};

class datafile;

using flist_t = std::vector<double>;
using ilist_t = std::vector<std::pair<std::size_t, std::optional<double>>>;

Word chooseFrom(
    const datafile& data, RandomGenerator& rng, counters c, const node& n,
    const std::vector<std::string>& args,
    const std::variant<std::monostate, flist_t, ilist_t>& freq_override);

cppcoro::generator<Word>
enumerate(const datafile& data, counters c, const node& n,
          std::vector<std::string> args,
          std::variant<std::monostate, flist_t, ilist_t> freq_override,
          bool include_zeros);

class datafile {
 public:
    datafile(YAML::Node data, RandomGenerator&);

    Word transform(Word, bool keephist, std::string_view hist_sep) const;

    Word
    generate(RandomGenerator& rng, counters c, const node& node,
             const std::vector<std::string>& args,
             const std::variant<std::monostate, flist_t, ilist_t>& freq_override,
             bool keephist, std::string_view sep) {
        auto w = transform(
            chooseFrom(*this, rng, c, node, args, std::move(freq_override)),
            keephist, sep);
        bm.variables.clear();
        return w;
    }

    // private:

    bytecode_machine bm;

    static std::tuple<std::string, int, bool> parse_nodename(std::string_view);

    static std::unordered_map<channelID, std::string>& ch_db();

    word_data_t channelNames;
    vmap<channelID, std::shared_ptr<datafile>> externFiles;
    small_vector<ReplaceStage, 1> replace;
    std::optional<std::string> startNode;

    vmap<std::string, std::vector<node>, 1> nodes;

    template <typename Datafile>
    static auto find_node_impl(Datafile& This, std::string_view name);
    template <typename Map>
    static auto find_node_impl(Map& nodes, std::string_view name, int argc)
        -> kblib::copy_const_t<Map, node>* {
        auto nlist = nodes.find(name);

        if (nlist == nodes.end()) {
            return nullptr;
        }
        for (auto&& n : nlist->second) {
            if (n.declared_argc == argc ||
                (n.variadic && n.declared_argc <= argc)) {
                return &n;
            }
        }
        return nullptr;
    }

    node* find_node(std::string_view name);
    const node* find_node(std::string_view name) const;
    node* find_node(std::string_view name, int argc) {
        return find_node_impl(nodes, name, argc);
    }
    const node* find_node(std::string_view name, int argc) const {
        return find_node_impl(nodes, name, argc);
    }

    datafile* lookup_domain(std::string_view name) {
        if (name.empty()) {
            return this;
        }

        if (auto check = kblib::get_check(externFiles, ch(name))) {
            return check->second.get();
        }
        return nullptr;

        // auto it = externFiles.find(ch(name));
        // if (it == externFiles.end()) {
        // return nullptr;
        // }
        // return it->second.get();
    }
    const datafile* lookup_domain(std::string_view name) const {
        if (name.empty()) {
            return this;
        }
        if (auto check = kblib::get_check(externFiles, ch(name))) {
            return check->second.get();
        }
        return nullptr;
        // auto it = externFiles.find(ch(name));
        // if (it == externFiles.end()) {
        // return nullptr;
        // }
        // return it->second.get();
    }
};

struct noderef {
    std::optional<const datafile*> source;
    std::string name;
    std::vector<std::string> args;
    std::variant<std::monostate, flist_t, ilist_t> freq_override;
};

// After eval
[[nodiscard]] cppcoro::generator<
    std::variant<std::string, noderef, wordgen_error>>
fparse(const datafile&, const std::string& s);

small_vector<double, 16> freqs_of(const bytecode_machine& bm, const node& n,
                                  const std::vector<std::string>& args,
                                  const counters& c, int argc);

struct basic_parse_token {
    std::string pre_text;
    std::optional<std::string> id;
    std::string mods;
};

cppcoro::generator<basic_parse_token> basic_parser(std::string_view input);

#endif // INTERPOLATE_H_INCLUDED_