#include <iostream>
#include <string>
#include <algorithm>

#include <tclap/CmdLine.h>
#include <yaml-cpp/yaml.h>
#include <unicode/unistr.h>

#include "grammar.h"
#include "word.h"
#include "loader.h"
#include "FRC.h"

extern const char* vnum;
randutils::random_generator<pcg64> randgen;

int complexity::gE = 0;

using std::cin;
using std::cout;
using std::cerr;
using std::clog;
using std::endl;

using std::string;
using std::u32string;
using namespace std::string_literals;

/* 
 * refParse: string -> vector<reference>
 *   class reference
 * 
 * chooseFrom: grammar, node, depth, maxdepth -> word
 *   class word
 *   class grammar
 * 
 * applyRE: word -> word
 * 
 * listAll: grammar, node, depth, maxdepth -> list<word>
 * 
 * formatWord: word, opts, formatStr -> string
 * 
 * printPath: path -> string
 * readPath: string -> path
 * followPath: path -> word
 *   class path
 * 
 * main: 
 *   gen: grammar, node,, count, depth -> list<word>
 *   list: grammar, node, depth -> list<word>
 *   
 * 
 * 
 * loadGrammar: YAML::Node -> grammar
 * dumpGrammar: grammar -> YAML::Node
 * 
 * toBNF: grammar, node -> BNFGrammar
 * fromBNF: BNFGrammar -> grammar
 * 
*/
//For debugging
std::string d_toUTF8(const icu::UnicodeString& s)
{
	std::string res;
	return s.toUTF8String(res);
}

icu::UnicodeString d_fromUTF8(std::string s)
{
	return icu::UnicodeString::fromUTF8(s);
}

int main(int argc, char** argv)
{
	try {
		
		TCLAP::CmdLine cmd("Generate random words/sentences matching"
			" a context-free grammar", ' ', vnum);
#ifdef _DEBUG
		clog<<"wordgen v"<<vnum<<endl;
#endif
		
		TCLAP::UnlabeledValueArg<string> file("file", "datafile", 
			true, "", "filename", cmd);
		TCLAP::UnlabeledValueArg<string> root("root", "Root node", 
			true, "", "root", cmd);
		TCLAP::UnlabeledValueArg<string> command("command", "command", 
			false, "gen", "gen|list|diag", cmd);
		
		TCLAP::MultiArg<string> channels("c", "channel",
			"print CHANNEL",
			false, "CHANNEL", cmd);
		TCLAP::SwitchArg ipaMode("p", "ipa",
			"print IPA transcriptions (-c ipa)", cmd);
		TCLAP::ValueArg<int> depth("d", "depth",
			"maximum recursion depth",
			false, -1, "int", cmd);
		TCLAP::ValueArg<int> expansions("e", "expansions",
			"maximum number of expansions (implies -d equal to -e) (defaults to depth^2)",
			false, -1, "int", cmd);
		TCLAP::SwitchArg HTMLMode("H", "html",
			"write output as HTML table", cmd);
		TCLAP::ValueArg<int> num("n", "num",
			"number of words to generate",
			false, 1, "int", cmd);
		TCLAP::SwitchArg noVal("V", "noVal",
			"suppress implicit 'val' printing", cmd);
		TCLAP::SwitchArg quiet("q", "quiet",
			"don't print the header", cmd);
		TCLAP::ValueArg<string> fstr("F", "fmt",
			"format string for printing words",
			false, "", "fmt_str", cmd);
		
		TCLAP::SwitchArg listZeros("0", "listZeros",
			"list: include 0-frequency values", cmd);
		
		TCLAP::SwitchArg dumpREs("", "regex",
			"Dump regular expressions", cmd);
		TCLAP::SwitchArg dumpNodes("", "nodes",
			"Dump switching nodes", cmd);
		TCLAP::SwitchArg testREs("", "retest",
			"Apply tranformations from CHANNELS to input", cmd);
		TCLAP::SwitchArg EbnfExport("", "bnf",
			"Export to EBNF (val only)", cmd);
		
		TCLAP::SwitchArg showPaths("P", "path",
			"Print paths (-c path)", cmd);
		TCLAP::SwitchArg keepHistory("K", "keepHistory",
			"Print intermediate tranformations (may be hard to read)", cmd);
		TCLAP::ValueArg<string> KHSep("", "KHSep",
			"Separator between transformation stages",
			false, " → ", "string", cmd);
		TCLAP::ValueArg<string> seed("r", "seed",
			"Random seed",
			false, "", "seed", cmd);
		
		cmd.parse(argc, argv);
		
		std::vector<icu::UnicodeString> printChannels;
		if (!noVal.getValue()) {
			printChannels.push_back(u"val");
		}
		if (ipaMode.getValue()) {
			printChannels.push_back(u"ipa");
		}
		if (showPaths.getValue()) {
			printChannels.push_back(u"path");
		}
		for (auto c : channels) {
			printChannels.push_back(fromUTF8(c));
		}
		
		if (!seed.getValue().empty()) {
			// randgen.seed();
		}
		
		int cdepth=-1, cexps=-1;
		if (depth.getValue() != -1 && expansions.getValue() != -1) {
			cdepth = depth.getValue();
			cexps = expansions.getValue();
		} else if (depth.getValue() != -1) {
			cdepth = depth.getValue();
			cexps = cdepth * cdepth;
		} else if (expansions.getValue() != -1) {
			cdepth = cexps = expansions.getValue();
		} else {
			cdepth = 24;
			cexps = 576;
		}
		
		constexpr const std::array<char const*const,5> files = {
			"grammar.cpp",
			"loader.cpp",
			"word.cpp",
			"path.cpp",
			"transform.cpp",
		};
		auto Data = YAML::LoadFile(file.getValue());
		try {
			Grammar g = loadGrammar(Data);
			Grammar::ParsedString tmpv{fromUTF8(root.getValue()), 0, false};
			auto rootv = 
				(tmpv.begin()->second)
				? fromUTF8(root.getValue())
				: fromUTF8("{"s + root.getValue() + "}")
			;
			Grammar::Node arg{rootv, g};
#ifdef _DEBUG
			clog<<g.printAllChannelNames()<<endl;
#endif
			string format;
			if (fstr.getValue().empty()) {
				format = "{" + toUTF8(join(printChannels, icu::UnicodeString{u"}\t{"})) + "}";
				// for (auto c : printChannels) {
					// format += "{"s+toUTF8(c)+"}\t";
				// }
			} else {
				format = fstr.getValue();
			}
			// cout<<format<<endl;
			if (command.getValue() == "gen"s) {
				for (int n = 0; n != num.getValue(); ++n) {
					try {
						int exp = 0;
						auto w = g.genWord(&arg, {cdepth, cexps, &exp});
						if (keepHistory.getValue()) {
							w = g.applyTransforms(w).getWord(fromUTF8(KHSep.getValue()));
						} else {
							w = g.applyTransforms(w).getWord(false);
						}
						cout<<toUTF8(w.format(format))<<endl;
						// cout<<toUTF8(w.printAll(u"\n"))<<endl;
					} catch (int e) {
						cerr<<endl<<"Threw at "<<files[e/10000]
							<<":"<<e%10000<<" while generating word #"
							<<n+1<<endl;
						return 1;
					} catch (std::pair<UErrorCode, UParseError> e) {
						cerr<<"Regex error: "<<e.first<<endl
							<<e.second.line<<" "<<e.second.offset
							<<" "<<toUTF8(e.second.preContext)
							<<" "<<toUTF8(e.second.postContext)<<endl;
						return 1;
					} catch (UErrorCode e) {
						cerr<<"ICU error: "
							<<u_errorName(e)<<endl;
					} catch (std::pair<UErrorCode, int> e) {
						cerr<<"ICU error: "
							<<u_errorName(e.first)
							<<" at "<<files[e.second/10000]
							<<":"<<e.second%10000
							<<endl;
					}
				}
			} else if (command.getValue() == "list"s) {
				cerr<<"list not implemented yet."<<endl;
				return 1;
			} else if (command.getValue() == "diag"s) {
				cout<<"d: "<<cdepth<<" e: "<<cexps<<" n: "<<num.getValue()<<endl;
				cout<<Data<<endl;
			} else {
				
			}
		} catch (int e) {
			cerr<<endl<<"Threw at "<<files[e/10000]
				<<":"<<e%10000<<" while loading grammar"<<endl;
			return 1;
		} catch (std::pair<UErrorCode, UParseError> e) {
			cerr<<"Regex error [load]: "<<e.first<<endl
				<<e.second.line<<" "<<e.second.offset
				<<" "<<toUTF8(e.second.preContext)
				<<" "<<toUTF8(e.second.postContext)<<endl;
			return 1;
		} catch (UErrorCode e) {
			cerr<<"ICU error [load]: "
				<<u_errorName(e)<<endl;
		} catch (std::pair<UErrorCode, int> e) {
			cerr<<"ICU error: "
				<<u_errorName(e.first)
				<<" at "<<files[e.second/10000]
				<<":"<<e.second%10000
				<<endl;
		}
		
	} catch (TCLAP::ArgException &e) {
		cerr<<"error: "<<e.error()<<" for arg "<<e.argId()<<endl;
		return 1;
	}
}