#ifndef __MACHINES_H_INCLUDED__
#define __MACHINES_H_INCLUDED__

#include "interpolate.h"

#include "kblib/kblib.h"
#include <vector>

namespace fsm {

class state {
public:
	std::pair<std::string, const state*> step(char32_t c) const;
	const std::string& suf() const {return end;}
private:
	struct action_t {
		std::string format;
		const state* dest;
	};
	vmap<char32_t, action_t, 16> cmap;
	struct set_action_t {
		std::string matches;
		action_t action;
	};
	std::vector<set_action_t> set;
	struct map_action_t {
		small_vector<char32_t, 64> in_set;
		small_vector<char32_t, 64> out_set;
		const state* dest;
	};
	std::vector<map_action_t> map;
	struct match_action_t {
		small_vector<char32_t, 64> matches;
		const state* dest;
	};
	std::vector<match_action_t> match;
	std::optional<action_t> def;
	const state* ret;
	std::string end;
	
	friend std::optional<state> toState(const YAML::Node&);
	friend bool set_dests(std::map<std::string, state>& states, std::string name, const YAML::Node& data);
};

class state_machine {
public:
	enum dir_override : unsigned char {
		none = 0,
		r_in = 1,
		r_out = 2,
		r_both = 3,
	};
	
	//be a valid string_transformer
	word_data_t operator()(Word, channelID) const;
	
private:
	//using std::map for reference stability
	std::map<std::string, state> states;
	dir_override dir;
	
	friend struct YAML::convert<state_machine>;
};

} // namespace fsm

namespace YAML {

template<>
struct convert<fsm::state_machine> {
	static bool decode(const Node& node, fsm::state_machine& sm);
};

template<>
struct convert<fsm::state> {
	static bool decode(const Node& node, fsm::state& s);
};

}

#endif //__MACHINES_H_INCLUDED__