#include <chrono>
#include <iostream>
#include <string>
#include <string_view>
#include <algorithm>

#include <tclap/CmdLine.h>
#include <yaml-cpp/yaml.h>
#include "interpolate.h"
#include "error.h"
#include "kblib/kblib.h"
#include "fda.h"
#include "logger.h"

#include <pcg_random.hpp>
#include "randutils.hpp"

#include "srell.hpp"

std::string toUTF8(const std::u16string&) {return {};}
std::u16string fromUTF8(const std::string&) {return {};}

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

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

using std::string;
using std::u16string;
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
 * 
*/

bool test_file(std::istream& tfile, const bytecode_machine& BM)
{
	std::string cTestCase;
	std::string cToken;
	while (tfile) {
		std::getline(tfile, cTestCase);
		cout<<kblib::quoted(cTestCase)<<'\n';
		try {
			auto tokens = BM.to_bytes(cTestCase);
			for (auto& tok : tokens) {
				std::getline(tfile, cToken);
				log_debug(kblib::concat('\t', cToken));
				if (auto got = serialize(tok, BM); cToken.empty()) {
					cerr<<"Test case failed: (mode 1)"
						<<"\nCase: "<<cTestCase
						<<"\nParsed:   "<<got
						<<"\nExpected: end of tokens\n";
					return false;
				} else if (cToken[0] == 'E') {
					auto code = std::stoul(cToken.substr(1));
					cerr<<"Test case failed: (mode 2)"
						<<"\nCase: "<<cTestCase
						<<"\nParsed:   "<<got
						<<"\nExpected: "<<format_err(static_cast<ec>(code))
						<<"\n";
					return false;
				} else if (cToken != got) {
					cerr<<"Test case failed: (mode 3)"
						<<"\nCase: "<<cTestCase
						<<"\nParsed:   "<<got
						<<"\nExpected: "<<cToken
						<<"\n";
					return false;
				}
				//success
			}
			std::getline(tfile, cToken);
			if (!cToken.empty()) {
				cerr<<"Test case failed: (mode 4)"
					<<"\nCase: "<<cTestCase
					<<"\nParsed:   end of tokens"
					<<"\nExpected: "<<cToken
					<<"\n";
				return false;
			}
			cout<<"Passed.\n";
		} catch (const wordgen_error& e) {
			std::getline(tfile, cToken);
			log_debug(kblib::concat('\t', cToken));
			if (cToken.empty()) {
				cerr<<"Test case failed: (mode 5)"
					<<"\nCase: "<<cTestCase
					<<"\nError:    "<<format_err(e.code())
					<<"\nExpected: end of tokens\n";
				cerr<<"Extra information:\n"
					<<*e.l2<<'\n'
					<<*e.l3<<'\n'
					<<*e.l4<<'\n';
				return false;
			} if (cToken[0] != 'E') {
				cerr<<"Test case failed: (mode 6)"
					<<"\nCase: "<<cTestCase
					<<"\nError:    "<<format_err(e.code())
					<<"\nExpected: "<<cToken
					<<"\n";
				cerr<<"Extra information:\n"
					<<*e.l2<<'\n'
					<<*e.l3<<'\n'
					<<*e.l4<<'\n';
				return false;
			} else {
				auto code = std::stoul(cToken.substr(1));
				if (code != kblib::etoi(e.code())) {
					cerr<<"Test case failed: (mode 7)"
						<<"\nCase: "<<cTestCase
						<<"\nError:    "<<format_err(e.code())
						<<"\nExpected: "<<format_err(static_cast<ec>(code))
						<<"\n";
					cerr<<"Extra information:\n"
						<<e.what()<<'\n';
					return false;
				}
				//success
				std::getline(tfile, cToken);
				if (!cToken.empty()) {
					std::cerr<<"Malformed test file.\n"
						<<cToken<<'\n';
					return false;
				}
			}
			cout<<"Passed - got expected error.\n";
		}
	}
	return true;
}

void testRE(std::istream& tfile)
{
	std::string line;
	const auto flag = srell::regex_constants::dotall;
	while (tfile) {
		std::getline(tfile, line);
		try {
			srell::regex{line, flag};
		} catch (srell::regex_error& e) {
			cerr<<"Regex error: "<<e.code()<<'\n'
				<<"Re: "<<kblib::quoted(line)<<'\n';
		}
	}
}

void printHelpText()
{
	#include "helptext.inc"
	//xd produces an array of unsigned char, so this cast is necessary to make a real string out of it. char is exempt from strict aliasing so this is legal, if ugly.
	std::cout
		<<"Extended help for wordgen v"<<vnum<<'\n'
		<<std::string_view{reinterpret_cast<char const *>(help_text), sizeof(help_text)};
}

int main(int argc, char** argv)
{
	// c_test_func();
	
	try {
		log_info("wordgen v", vnum);
		
		TCLAP::CmdLine cmd("Generate random words/sentences matching"
			" a context-free grammar", ' ', vnum);
		
		TCLAP::UnlabeledValueArg<string> file("file", "The datafile to use, or 'help', which will print extended information.", 
			true, "", "filename|help", cmd);
		TCLAP::UnlabeledValueArg<string> root("root", "Root node", 
			true, "", "root", cmd);
		TCLAP::ValuesConstraint<string> commands(
			"gen", "list", "diag", "show", "xform"
			);
		TCLAP::UnlabeledValueArg<string> command("command", "command", 
			false, "gen", &commands, cmd);
		
		TCLAP::MultiArg<string> channels("c", "channel",
			"print CHANNEL",
			false, "CHANNEL", cmd);
		TCLAP::SwitchArg ipaMode("p", "ipa",
			"print IPA transcriptions (-c ipa)", cmd);
		TCLAP::SwitchArg allChannels("C", "printAll",
			"print all channels present (overrides -c, -p, -V)", 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::SwitchArg silent("Q", "silent",
			"don't print anything except diagnostics", cmd);
		TCLAP::ValueArg<string> fstr("F", "fmt",
			"format string for printing words",
			false, "", "fmt_str", cmd);
		TCLAP::ValuesConstraint<string> loglevels(
			"none", "err", "error", "warn", "notice", "info", "debug"
			);
		TCLAP::ValueArg<string> loglevel("l", "loglevel",
			"Set the logging level. Defaults to 'notice'.",
			false, "notice", &loglevels, cmd);
		
		TCLAP::SwitchArg listZeros("0", "listZeros",
			"list: include 0-frequency values", cmd);
		
		TCLAP::SwitchArg dumpREs("", "regex",
			"diag: Dump regular expressions", cmd);
		TCLAP::SwitchArg dumpNodes("", "nodes",
			"diag: Dump switching nodes", cmd);
		TCLAP::SwitchArg testREs("", "retest",
			"diag: Apply tranformations from CHANNELS to input", cmd);
		TCLAP::SwitchArg EbnfExport("", "bnf",
			"diag: Export to EBNF (val only)", cmd);
		TCLAP::MultiArg<string> testParser("", "tstr",
			"diag: Test template parser with file(s)",
			false, "filename", cmd);
		TCLAP::SwitchArg dumpfmt("", "dumpfmt",
			"diag: Show the effective format string.", 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, u8" → ", "string", cmd);
		TCLAP::ValueArg<string> seed("r", "seed",
			"Random seed",
			false, "", "seed", cmd);
		
		cmd.parse(argc, argv);
		
		if (file.getValue() == "help") {
			printHelpText();
			return EXIT_SUCCESS;
		}
		
		std::vector<std::string> printChannels;
		if (!noVal.getValue()) {
			printChannels.push_back("val");
		}
		if (ipaMode.getValue()) {
			printChannels.push_back("ipa");
		}
		if (showPaths.getValue()) {
			printChannels.push_back("path");
		}
		for (auto c : channels) {
			printChannels.push_back(c);
		}
		
		randutils::seed_seq_fe128 seed_data{{0}};
		
		if (!seed.getValue().empty()) {
			seed_data.seed(seed.getValue().begin(), seed.getValue().end());
		} else {
			[&](auto& seed){
				std::array<std::uint32_t, 4> data;
				seed.param(data.begin());
				seed_data.seed(data.begin(), data.end());
			}(randutils::auto_seed_128{}.base());
		}
		
		set_log_level([&]{
			using namespace kblib::literals;
			switch (kblib::FNV32a(loglevel.getValue())) {
			case "none"_fnv32:
				return log_level::silent;
			case "err"_fnv32:
			case "error"_fnv32:
				return log_level::err;
			case "warn"_fnv32:
				return log_level::warn;
			case "notice"_fnv32:
				return log_level::notice;
			case "info"_fnv32:
				return log_level::info;
			case "debug"_fnv32:
				return log_level::debug;
			}
		}());
		
		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",
		};
		// std::ifstream retest(file.getValue());
		// testRE(retest);
		try {
			string fmt = [&]{
				if (allChannels.getValue()) {
					if (HTMLMode.getValue()) {
						return "<tr>{%all%!h}{path!h}</tr>"s;
					}
					return "{%all%}\t{path}"s;
				} else if (fstr.getValue().empty()) {
					std::string mods = [&]{
						if (HTMLMode.getValue()) {
							return "!h";
						} else {
							return "";
						}
					}();
					auto base_str = std::accumulate(printChannels.begin(), printChannels.end(), std::string{}, [&, first = true](std::string out, const std::string& ch) mutable {
						if (first || HTMLMode.getValue()) {
							first = false;
							return kblib::concat(out, '{', ch, mods, '}');
						} else {
							return kblib::concat(out, "\\t{", ch, mods, '}');
						}
					});
					if (HTMLMode.getValue()) {
						return kblib::concat("<tr>", base_str, "</tr>");
					}
					return base_str;
				} else {
					if (HTMLMode.getValue()) {
						return kblib::concat("<tr>", kblib::html_encode(fstr.getValue()), "</tr>");
					}
					return fstr.getValue();
				}
			}();
			// cout<<"Using format "<<kblib::quoted(fmt)<<'\n';
			if (command.getValue() == "gen"s) {
				RandomGenerator rng(seed_data);
				datafile Data{YAML::LoadFile(file.getValue()), rng};
				auto* node = Data.find_node(root.getValue());
				if (!node) {
					cerr<<"Could not find node named "<<kblib::quoted(root.getValue())<<'\n';
					cerr<<"List of all nodes:\n";
					for (const auto& [name, nodes] : Data.nodes) {
						cerr<<kblib::quoted(name)<<'\t'<<nodes.size()<<'\n';
					}
					return 1;
				}
				for (int n = 0; n != num.getValue(); ++n) {
					try {
						int e{};
						auto w = format(Data.transform(chooseFrom(Data, rng, counters{cdepth, cexps, &e}, *node, {}, {}), keepHistory.getValue(), KHSep.getValue()), fmt);
						if (!silent.getValue()) {
							std::cout<<w<<'\n';
						}
					} catch (int e) {
						cerr<<"\nThrew at "<<files[e/10000]
							<<":"<<e%10000<<" while generating word #"
							<<n+1<<'\n';
						return 1;
					}
				}
			} else if (command.getValue() == "list"s) {
				cerr<<"list not implemented yet.\n";
				return 1;
			} else if (command.getValue() == "diag"s) {
				RandomGenerator rng;
				bytecode_machine BM(nullptr, rng);
				if (auto& tests = testParser.getValue(); tests.size()) {
					for (auto& t : tests) {
						try {
							std::ifstream tfile(t);
							tfile.exceptions(std::ios_base::badbit);
							if (!test_file(tfile, BM)) {
								cout<<"Test failure, stopping.\n";
								break;
							}
							cout<<"All tests passed.\n";
						} catch (std::ios_base::failure& e) {
							cerr<<"Error: "<<e.what()<<'\n'
								<<"While reading test file: "<<std::quoted(t)
								<<"\nContinuing...\n";
						}
					}
				} else if (testREs.getValue()) {
					std::ifstream re_file(file.getValue());
					std::string regex;
					while (re_file >> kblib::get_line(regex)) {
						srell::u8regex re(regex);
					}
				} else if (dumpfmt.getValue()) {
					cout<<std::quoted(fmt)<<'\n';
				} else {
					cout<<"d: "<<cdepth<<" e: "<<cexps<<" n: "<<num.getValue()<<'\n';
				}
			} else {
				cerr<<"unknown command\n";
			}
		} catch (const YAML::BadFile& e) {
			cerr<<"Bad input file.\n"<<e.what()
				<<"\nAt "<<e.mark.pos<<", "<<e.mark.line<<':'<<e.mark.column<<'\n';
		} catch (wordgen_error& e) {
			cerr<<*e.l1
				<<*e.l2
				<<*e.l3
				<<*e.l4;
		} catch (int e) {
			cerr<<"\nThrew at "<<files[e/10000]
				<<":"<<e%10000<<" while loading grammar\n";
			return 1;
		}
	} catch (TCLAP::ArgException &e) {
		cerr<<"error: "<<e.error()<<" for arg "<<e.argId()<<'\n';
		return 1;
	}
}