#ifndef INTERPOLATE_H_INCLUDED_
#define INTERPOLATE_H_INCLUDED_

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

#include <yaml-cpp/yaml.h>

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

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;
}

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{} {}
	
	constexpr str_prefix(std::string_view s) : str{} {
		kblib::copy_n(s.begin(), std::min(s.size(), (std::size_t)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>;
		static_assert(N <= sizeof(To));
		if constexpr (N >= 2) {
			return static_cast<To>(str[N-1]) << shift
                | 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())<<32 | 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())<<32 | 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, 4>;

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&, std::string_view fmt);

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;
	int declared_argc;
	bool variadic;
	std::string name;
};

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

class datafile {
public:
	
	datafile() = default;
	datafile(YAML::Node data, RandomGenerator&);
	
	Word transform(Word, bool keephist, std::string_view hist_sep) const;
	
// 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();
	
	vmap<channelID, std::string> 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;
	
	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);
	const node* find_node(std::string_view name, int argc) const;
	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();
	}
	
};

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

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>> fparse(const datafile&, const std::string& s);

Word chooseFrom(const datafile&, RandomGenerator&, counters, const node&, const std::vector<std::string>& args, std::variant<std::monostate, flist_t, ilist_t> freq_override);
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_