#include "FRC.h"
#include "loader.h"

#include <iostream>
#include <string>
#include <regex>

class BNFGrammar {};

static std::vector<std::unique_ptr<Grammar::Transformer>>
	extractTransform(const YAML::Node& n);

Grammar loadGrammar(YAML::Node node)
{
	Grammar g;
	// extract:
		//	channelnames
		// transformations
		// nodes
	
	if (node["channels"]) {
		for (const auto& c : node["channels"]) {
			g.nameChannel(
				fromUTF8(c.first.template as<std::string>()),
				fromUTF8(c.second.template as<std::string>())
			);
		}
		node.remove("channels");
	}
	if (node["replace"]) {
		for (const auto& rch : node["replace"]) {
			g.transform_stages[
				g.chI(fromUTF8(rch.first.template as<std::string>()))
			] = extractTransform(rch.second);
		}
		node.remove("replace");
	} else {
		if (node["replacement"]) {
			g.transform_stages[g.chI(u"val")]
				= extractTransform(node["replacement"]);
			node.remove("replacement");
		}
		if (node["replaceIPA"]) {
			g.transform_stages[g.chI(u"ipa")]
				= extractTransform(node["replaceIPA"]);
			node.remove("replaceIPA");
		}
	}
	for (const auto& n : node) {
		Grammar::nodeData branches;
		for (const auto& b : n.second) {
			// std::cerr<<':';
			Grammar::nodeData::value_type m;
			for (const auto& c : b) {
				// std::cerr<<'.';
				m[g.chI(fromUTF8(c.first.as<std::string>()))]
					= fromUTF8(c.second.as<std::string>());
			}
			branches.push_back(std::move(m));
		}
		// std::cerr<<std::endl;
		auto name = fromUTF8(n.first.as<std::string>());
		int c = std::count(
			name.getBuffer(),
			name.getBuffer()+name.length(),
			u'|'
		);
#ifdef _DEBUG
		std::cerr<<"Node "<<n.first.as<std::string>()
			<<" has "<<branches.size()<<" branches, "<<c;
		if (name.endsWith(u"|..."))
			std::cerr<<'+';
		std::cerr<<" args"<<std::endl;
#endif
		if (name.endsWith(u"|...")) {
			g.tnodes.emplace(std::piecewise_construct,
				std::forward_as_tuple(name, c, true),
				std::forward_as_tuple(branches, g, c, true)
			);
		} else if (name.endsWith(u"|")) {
			g.tnodes.emplace(std::piecewise_construct,
				std::forward_as_tuple(name, c, false),
				std::forward_as_tuple(branches, g, c, false)
			);
		} else {
			g.nodes.emplace(std::piecewise_construct,
				std::forward_as_tuple(name),
				std::forward_as_tuple(branches, g)
			);
		}
	}
	return g;
}

std::unique_ptr<Grammar::state_machine> extractStates(const YAML::Node& n)
{
	auto tmp = std::make_unique<Grammar::state_machine>();
	for (const auto& s : n) {
		if (s.first.as<std::string>() == "reversed") {
			auto r = s.second.as<int>();
			if (r > 3 || r < 0) {
				throw std::runtime_error("\"reversed\" must be 0..3");
			}
			tmp->tapeDirection = static_cast<Grammar::state_machine::dir>(r);
		} else {
			Grammar::state_machine::State state;
			for (const auto& r : s) {
				const auto& i = r.first.as<std::string>();
				const auto& d = r.second.as<std::vector<std::string>>();
				if (i == "default") {
					auto v = r.second.as<std::vector<std::string>>();
					icu::UnicodeString o{fromUTF8(v.at(0))},
						s{v.size()>1?fromUTF8(v[1]):u""};
					state.defaultRule = {o,s};
					state.hasDefault = true;
				} else if (i == "return") {
					state.returnState = fromUTF8(r.second.as<std::string>());
				} else if (i == "set") {
					auto v = r.second.as<std::vector<std::string>>();
					icu::UnicodeString m{fromUTF8(v.at(0))},
						r{fromUTF8(v.at(1))},
						s{v.size()>2?fromUTF8(v[2]):u""};
					state.setRules.emplace_back(m,r,s);
				} else if (i == "match") {
					auto v = r.second.as<std::vector<std::string>>();
					icu::UnicodeString m{fromUTF8(v.at(0))},
						s{fromUTF8(v.at(1))};
					state.matchRules.emplace_back(m,s);
				} else if (i == "map") {
					auto v = r.second.as<std::vector<std::string>>();
					icu::UnicodeString m{fromUTF8(v.at(0))},
						r{fromUTF8(v.at(1))},
						s{v.size()>2?fromUTF8(v[2]):u""};
					state.mapRules.emplace_back(m,r,s);
				} else if (i == "end") {
					state.endRule = fromUTF8(r.second.as<std::string>());
				} else {
					auto v = r.second.as<std::vector<std::string>>();
					icu::UnicodeString o{fromUTF8(v.at(0))},
						s{v.size()>1?fromUTF8(v[1]):u""};
					if (o.countChar32() == 1) {
						state.charRules[o.char32At(0)] = {o,s};
					} else {
						//Invalid rule
					}
				}
				
			}
			tmp->states[fromUTF8(s.first.as<std::string>())] = state;
		}
	}
	return tmp;
}

static std::vector<std::unique_ptr<Grammar::Transformer>>
	extractTransform(const YAML::Node& n)
{
	std::vector<std::unique_ptr<Grammar::Transformer>> ret;
	for (auto& stage : n) {
		if (stage.IsSequence()) {
			// std::vector<Grammar::regexer2::regex_type> REs;
			// for (auto& RE : stage) {
				// REs.emplace_back(
					// fromUTF8(RE["m"].as<std::string>()),
					// fromUTF8(RE["r"].as<std::string>())
				// );
				// std::clog<<__LINE__<<" m: "<<RE["m"].as<std::string>()<<std::endl;
				// std::clog<<__LINE__<<" r: "<<RE["r"].as<std::string>()<<std::endl;
			// }
			// ret.push_back(std::make_unique<Grammar::regexer2>(std::move(REs)));
			std::vector<Grammar::regexer::regex_type> REs;
			for (auto& RE : stage) {
				UErrorCode status{U_ZERO_ERROR};
				UParseError pe;
				REs.emplace_back(
					fromUTF8(RE["m"].as<std::string>()), pe, status,
					fromUTF8(RE["r"].as<std::string>())
				);
				std::clog<<__LINE__<<" m: "<<RE["m"].as<std::string>()<<std::endl;
				std::clog<<__LINE__<<" r: "<<RE["r"].as<std::string>()<<std::endl;
				if (U_FAILURE(status))
					throw std::make_pair(status, pe);
			}
			ret.push_back(std::make_unique<Grammar::regexer>(std::move(REs)));
		} else if (stage["S"]) {
			ret.push_back(extractStates(stage));
		}
	}
	return ret;
}

YAML::Node dumpGrammar(const Grammar&)
{
	throw 10000+__LINE__;
}


Grammar loadBNF(const BNFGrammar&)
{
	throw 10000+__LINE__;
}

BNFGrammar dumpBNF(const Grammar&)
{
	throw 10000+__LINE__;
}