//#include "interpolate.h"

#include "srell/srell.hpp"

#include <filesystem>
#include <kblib/poly_obj.h>
#include <map>

namespace fs = std::filesystem;

namespace parser {

class TokenStream;

namespace AST {

	struct ASTNode {
		// virtual void parse(TokenStream& input) = 0;

		virtual ~ASTNode() = default;

		static constexpr std::size_t max_derived_size = 64;
	};

	template <typename T, typename B = ASTNode>
	struct List : B {
		std::vector<T> vals;
		static_assert(std::is_base_of_v<ASTNode, B>);
	};
	template <typename K, typename V, typename B = ASTNode>
	struct Map : B {
		std::map<K, V> vals;
		static_assert(std::is_base_of_v<ASTNode, B>);
	};
	template <typename B, typename... Ts>
	struct BTuple : B {
		std::tuple<Ts...> vals;
		static_assert(std::is_base_of_v<ASTNode, B>);
	};
	template <typename... Ts>
	using Tuple = BTuple<ASTNode, Ts...>;

	struct TExpr : ASTNode {
		static constexpr std::size_t max_derived_size =
		    sizeof(ASTNode) + sizeof(std::string) + sizeof(std::vector<int>);
	};
	struct TLiteral : TExpr {
		std::string val;
	};
	struct TFCall : TExpr {
		std::string fname;
		std::vector<kblib::poly_obj<TExpr>> args;
	};
	struct TArgRef : TExpr {
		std::string name;
	};
	struct TDots : TArgRef {};

	struct String : ASTNode {
		template <typename... Ts>
		auto refine() const -> std::tuple<std::optional<Ts>...>;
		static constexpr std::size_t max_derived_size =
		    sizeof(ASTNode) + sizeof(std::vector<int>);
	};
	struct tname : String {
		std::string name;
		int argc;
		bool variadic;
	};
	struct LString final : String {
		std::string val;
	};
	struct IString : String {};
	struct TString : String {
		std::vector<std::variant<std::string, TExpr>> contents;
	};

	struct replace_stage : ASTNode {};
	struct regex_action final : ASTNode {
		srell::regex r;
		std::string m;
	};
	struct regex_stage final : List<regex_action, replace_stage> {};
	struct state_machine final : replace_stage {};

	struct Replacement_group final : ASTNode {
		std::map<std::string, List<kblib::poly_obj<replace_stage>>> actions;
	};
	struct Control final : ASTNode {
		std::map<std::string, std::string> channel_names;
		std::map<tname, TString> functions;
		std::vector<Replacement_group> replacements;
		IString entry_point;

		// void parse(TokenStream& input) override;
	};

	struct Alternative : ASTNode {
		auto val() const -> String&;
		std::variant<double, TString> freq;
		Map<std::string, kblib::poly_obj<String>> channels;
	};

	struct Node {};
	struct NormalNode final : List<Alternative> {};
	struct LiteralNode final : Alternative {};

	struct Datafile final : ASTNode {
		Control control;
		Map<tname, kblib::poly_obj<Node>> nodes;
	};
} // namespace AST

} // namespace parser