#include <iomanip>
#include <iostream>

#include <array>
#include <cmath>
#include <map>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>

#include "tecla_oo.h"

#include <png++/png.hpp>
#undef protected

#include "input.h"
#include "map.h"
#define KBLIB_DEF_MACROS 1
#include "kblib/convert.h"

extern const char* vnum;

// HelpStr, iHelpStr
#include "strings.h"

using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
using namespace std::string_literals;

// main interface, generates 1024x1024 map with all default settings
// void genMap(vector<string> inList);

static bool Continue = true;

std::map<std::string, std::string> vars;
std::map<std::string, bool> settings;
static input_trie commands;

bool& verbose() { return settings["verbose"]; }

void createInitTrie();
std::vector<std::pair<std::string, functdata*>> initTrie1();
std::vector<std::pair<std::string, functdata*>> initTrie2();

void runCommand(string in);

// Since every lambda has the same signature, and it's quite verbose
#define INPUT_TRIE_DECL(X) std::pair<std::string, functdata*>(std::string(X), new functdata(\
	[](std::vector<std::string> inList) -> std::vector<std::string>

// This one is pretty much useless, but otherwise the parentheses end up
// unmatched
#define CPARENS ))

void drawMap(vector<string> inList) {
	std::string file{inList[2]};
	unsigned cmapID{lookupMap(inList[1])},
	    size{pFromStr(unsigned short, inList[6])};
	float x{pFromStr(float, inList[3])}, y{pFromStr(float, inList[4])},
	    width{pFromStr(float, inList[5])};
	spiral mode = parse_spiral(inList[0][1]);

	if (current_cmap[cmapID].second.size() > 256) {
		auto image = genMap_impl<png::rgb_pixel>(cmapID, mode, x, y, width, size);
		image.write(file);
	} else {
		auto image =
		    genMap_impl<png::index_pixel>(cmapID, mode, x, y, width, size);
		image.write(file);
	}
}

int main(int argc, char** argv) {
	// Add built-in functions to trie
	createInitTrie();

	// Aliases and saved commands:
	commands.execute(std::vector<std::string>{"save", "esc", "u"});
	commands.execute(std::vector<std::string>{"save", ":", "= ec"});
	commands.execute(std::vector<std::string>{"save", "ls", "= p p-"});

	commands.execute(std::vector<std::string>{"..", "long", "off"});
	commands.execute(std::vector<std::string>{"..", "prompt", "on"});
	commands.execute(std::vector<std::string>{"..", "s_prompt", "off"});
	commands.execute(std::vector<std::string>{"..", "verbose", "off"});

	commands.execute(std::vector<std::string>{".", "prompt", "$>"});

	string in;
	commands.insert(vector<std::pair<string, functdata*>>({{
	    std::pair<string, functdata*>(
	        "m", new functdata(
	                 [](vector<string> inList) {
		                 bool archimedian{true};
		                 unsigned cmapID{1};

		                 auto split = inList[0].find_first_of("0123456789abcdef");
		                 if (split == string::npos) {
			                 split = inList[0].size();
		                 }
		                 string fname{inList[0].substr(0, split)},
		                     cmapnum{inList[0].substr(split)};
		                 if (fname.find_first_of('l') != string::npos) {
			                 archimedian = false;
		                 }
		                 inList.insert(inList.begin() + 1, cmapnum);
		                 inList[0] = "d"s + fname;
		                 drawMap(inList);

		                 return vector<string>{};
	                 },
	                 5, 5, "Draw map (filename left upper width resolution)",
	                 functdata::FSingle)),
	    std::pair<string, functdata*>(
	        "d", new functdata(
	                 [](vector<string> inList) {
		                 drawMap(std::move(inList));
		                 return vector<string>{};
	                 },
	                 6, 6,
	                 "Draw map <cmap> <output.png> <left> <upper> <width> <res>",
	                 functdata::FSingle)),
	    std::pair<string, functdata*>(
	        "c", new functdata(
	                 [](vector<string> inList) {
		                 int maxlen{0};
		                 for (auto& m : current_cmap) {
			                 (m.second.size() > maxlen) ? maxlen = m.second.size()
			                                            : false;
		                 }
		                 png::image<png::rgb_pixel> image(maxlen,
		                                                  current_cmap.size());
		                 for (int i = 0; i < (signed)current_cmap.size(); ++i) {
			                 auto cmap = current_cmap[i].second;
			                 for (int x = 0; x < maxlen; ++x) {
				                 auto v = x * cmap.size() / maxlen;
				                 image[i][x] = {cmap[v].red, cmap[v].green,
				                                cmap[v].blue};
			                 }
		                 }
		                 image.write(inList[1]);

		                 return vector<string>{};
	                 },
	                 1, 1, "Print colormaps (<output.png>)",
	                 functdata::FSingle)),
	    std::pair<string, functdata*>(
	        "cr", new functdata(
	                  [](vector<string> inList) {
		                  auto cmaps = read_cmap(inList[1]);
		                  int maxlen{0};
		                  for (auto& m : cmaps) {
			                  (m.second.size() > maxlen) ? maxlen = m.second.size()
			                                             : false;
		                  }
		                  png::image<png::rgb_pixel> image(maxlen, cmaps.size());
		                  for (int i = 0; i < (signed)cmaps.size(); ++i) {
			                  auto& cmap = cmaps[i].second;
			                  for (int x = 0; x < maxlen; ++x) {
				                  auto v = x * cmap.size() / maxlen;
				                  image[i][x] = {cmap[v].red, cmap[v].green,
				                                 cmap[v].blue};
			                  }
		                  }
		                  image.write(inList[2]);

		                  return vector<string>{};
	                  },
	                  2, 2, "Print colormaps from file <cmapfile> <output.png>",
	                  functdata::FSingle)),
	    std::pair<string, functdata*>(
	        "pc", new functdata(
	                  []([[maybe_unused]] vector<string> inList) {
		                  vector<string> out;
		                  for (int i = 0; i < (signed)current_cmap.size(); ++i) {
			                  std::string name;
			                  png::palette cmap;
			                  std::tie(name, cmap) = current_cmap[i];
			                  out.emplace_back(
			                      kblib::concat(':', name, ':', cmap.size()));
			                  // cout << ":" << name << ":" << std::dec
			                  //	     << cmap.size() << std::hex;
			                  for (int x = 0; x < (signed)cmap.size(); ++x) {
				                  if (x % 8 == 0) {
					                  out.emplace_back("\t");
					                  // cout << endl
					                  //      << "\t";
				                  }
				                  std::ostringstream sout;
				                  sout << std::hex << std::setw(2)
				                       << std::setfill('0') << +cmap[x].red
				                       << std::setw(2) << std::setfill('0')
				                       << +cmap[x].green << std::setw(2)
				                       << std::setfill('0') << +cmap[x].blue << " ";
				                  out.back() += sout.str();
			                  }
			                  //	cout << endl;
		                  }
		                  //	cout << std::dec;
		                  return out;
	                  },
	                  0, 0, "Formats colormaps", functdata::Single)),
	    std::pair<string, functdata*>(
	        "pcr", new functdata(
	                   []([[maybe_unused]] vector<string> inList) {
		                   vector<string> out(1);
		                   auto cmaps = read_cmap(inList[1]);
		                   for (int i = 0; i < (signed)cmaps.size(); ++i) {
			                   std::string name;
			                   png::palette cmap;
			                   std::tie(name, cmap) = cmaps[i];
			                   for (int c = 0; c != (signed)name.size(); ++c) {
				                   if (name[c] == ':' || name[c] == '\\') {
					                   name.insert(c, "\\");
					                   ++c;
				                   }
			                   }
			                   out.back() +=
			                       kblib::concat(':', name, ':', cmap.size());
			                   // cout << ":" << name << ":" << std::dec
			                   //      << cmap.size() << std::hex;
			                   for (int x = 0; x < (signed)cmap.size(); ++x) {
				                   if (x % 8 == 0) {
					                   cout << endl << "\t";
				                   }
				                   std::ostringstream sout;
				                   sout << std::hex << std::setw(2)
				                        << std::setfill('0') << +cmap[x].red
				                        << std::setw(2) << std::setfill('0')
				                        << +cmap[x].green << std::setw(2)
				                        << std::setfill('0') << +cmap[x].blue
				                        << " ";
				                   out.back() += sout.str();
			                   }
			                   // cout << endl;
		                   }
		                   // cout << std::dec;
		                   return out;
	                   },
	                   0, 0, "Formats colormaps", functdata::FSingle)),
	    std::pair<string, functdata*>(
	        "rc", new functdata(
	                  [](vector<string> inList) {
		                  vector<string> out;
		                  try {
			                  current_cmap = read_cmap(inList[1]);
			                  out.emplace_back(kblib::concat(
			                      "Read ", current_cmap.size(), " cmaps"));
			                  // cout << "Read " << current_cmap.size() << " cmaps"
			                  //      << endl;
			                  for (auto& map : current_cmap) {
				                  out.emplace_back(kblib::concat(map.first, ": ",
				                                                 map.second.size(),
				                                                 " colors"));
				                  // cout << map.first << ": " << map.second.size()
				                  //      << " colors" << endl;
			                  }
		                  } catch (malformed_file_error& e) {
			                  out.emplace_back(e.what());
			                  // cout << e.what() << endl;
		                  }
		                  return out;
	                  },
	                  1, 1, "Read colormap <cmapfile>", functdata::FSingle)),
	}}));

	std::vector<string> scriptedCommands;

	bool cont_after = false;

	for (int i = 1; i < argc; i++) {
		// cout<<"["<<i<<"] "<<argv[i]<<endl;
		if (argv[i][0] == '-' && argv[i][1] != '\0' && argv[i][1] != ' ') {
			for (int j = 1; argv[i][j] != '\0'; ++j) {
				if (argv[i][j] == 'q') { // quiet (Don't display prompts)
					settings["prompt"] = false;
				} else if (argv[i][j] == 'h') { // help
					// from strings.h
					cout << HelpStr;
					Continue = false;
					// verbose (Simulate interactive display for scripted commands)
				} else if (argv[i][j] == 'V') {
					settings["s_prompt"] = true;
				} else if (argv[i][j] == 'v') {
					cout << vnum << '\n';
					Continue = false;
				} else if (argv[i][j] == 'c') { // continue after scripted commands
					cont_after = true;
				} else if (argv[i][j] == 'l') { // Long form output
					settings["long"] = true;
				}
			}
		} else { // interpret other strings as commands to be run
			scriptedCommands.emplace_back(argv[i]);
		}
	}

	Continue = Continue & !scriptedCommands.size();

	for (auto i : scriptedCommands) {
		// q overrides v
		if (settings["s_prompt"] && settings["prompt"])
			cout << vars["prompt"] << " " << i << endl;
		runCommand(i);
		if (!Continue) {
			break;
		}
	}

	// Since both are simple variables short-circuiting doesn't really help, and
	// bools are guaranteed to only be 1 or 0
	Continue = Continue | cont_after;
	if (Continue) {
		// Tecla (input lib) setup
		// Tecla handles input buffers, never delete this pointer
		char* line = nullptr;
		// setlocale(LC_TYPE, "");
		Tecla_gl gl(1024, 2048, ".Roman_hist");
		// No memory?
		if (!gl)
			return 1;
		string in;

	input_retry:
		// Actual input loop, large-scope try because all exceptions in main are
		// outside my code
		while (Continue) {
			try {
				// Yes, I know, I'm mixing STDIN/OUT and cin/out, but I'm not going
				// to rewrite this entire section in C just because I'm using a C
				// input library. It rarely matters anyway.
				if (settings["prompt"])
					line = gl.getline((vars["prompt"] + " ").c_str(), nullptr, -1);
				else
					line = gl.getline(nullptr, nullptr, -1);

				// Turn line into std::string
				if (line)
					in = line;
				else
					break;
				// Strip newline from end
				in.pop_back();

				if (in.empty()) {
					continue;
				}
				runCommand(in);
			} catch (const std::runtime_error& err) {
				cout << "Failed to read input. " << err.what() << endl;
			} catch (const std::exception& err) {
				cout << "Unknown error: " << err.what() << endl;
				throw err;
			} catch (...) {
				cout << "Unknown error" << endl;
				throw;
			}
		}
		switch (gl.status()) {
		// Non-exit (but unexpected) conditions
		case GLR_BLOCKED: // Blocking mode is default?
		case GLR_SIGNAL:  // If Tecla didn't already terminate the program, then
		                  // continue
		case GLR_TIMEOUT: // No inactivity timer is set, so this shouldn't happen
			goto input_retry;

		// Normal exit conditions:
		case GLR_NEWLINE: // Nothing went wrong, so exit must have been requested
		case GLR_EOF:     // EOF reached, exiting
			break;

		// Exceptional exit conditions
		case GLR_ERROR: // An error occurred, just exit
			std::cerr << "Error reading input:\n"
			          << gl.error_message() << std::endl;
			return 1;
		case GLR_FDABORT: // This should never happen
		                  // status = 1;
		// Anything else:
		default:
			break; // Exit normally
		}
		return 0;
	} else {
		return 0;
	}
}

void runCommand(string in) {
	if (in.empty()) {
		return;
	}

	// Split input on word boundaries
	vector<string> inList = tokenizeInput(in);
	vector<string> out = commands.execute(inList);
	for (auto i : out) {
		cout << i << endl;
	}
}

inline void createInitTrie() {
	auto a = initTrie1();
	commands.insert(a);
	// Commands that require the trie to already be initialized/reference it
	auto b = initTrie2();
	commands.insert(b);
}

inline std::vector<std::pair<std::string, functdata*>> initTrie1() {
	return std::vector<std::pair<std::string, functdata*>>({
	    std::pair<string, functdata*>(
	        "h", new functdata(
	                 [](vector<string> inList) -> vector<string> {
		                 if (inList.size() > 1) {
			                 int len = 0;
			                 functdata* found = commands.longestPrefix(
			                     kblib::toLower(inList[1]), &len);
			                 if (found) {
				                 if (found->mode != functdata::Composite)
					                 return {found->help};
				                 else
					                 return {"Alias of \"" + found->help + "\""};
			                 } else {
				                 return {string("Nothing found for \"") +
				                         kblib::toLower(inList[1]) + "\""};
			                 }
		                 } else {
			                 // from strings.h
			                 return iHelpStr;
		                 }
	                 },
	                 0, 1, std::string("Get help"), functdata::Single)),
	    std::pair<string, functdata*>(
	        "q", new functdata(
	                 [](vector<string> inList) -> vector<string> {
		                 Continue = false;
		                 return {};
	                 },
	                 0, std::string("Quit"))),
	    std::pair<string, functdata*>(
	        "..",
	        new functdata(
	            [](vector<string> inList) -> vector<string> {
		            inList[1].resize(inList[1].size());
		            if (inList.size() > 2)
			            settings[kblib::toLower(inList[1])] = truthy(inList[2]);
		            else
			            settings[kblib::toLower(inList[1])] =
			                !settings[kblib::toLower(inList[1])];
		            return {};
	            },
	            1, 2, std::string("Change setting (toggle if no argument)"),
	            functdata::Single)),
	    std::pair<string, functdata*>(
	        "..-", new functdata(
	                   [](vector<string> inList) -> vector<string> {
		                   inList[1].resize(inList[1].size());
		                   settings.erase(kblib::toLower(inList[1]));
		                   return {};
	                   },
	                   1, 1, std::string("Clear setting"), functdata::Single)),
	    std::pair<string, functdata*>(
	        "??", new functdata(
	                  [](vector<string> inList) -> vector<string> {
		                  if (inList.size() == 2) {
			                  inList[1].resize(inList[1].size());
			                  return {settings[kblib::toLower(inList[1])]
			                              ? std::string("on")
			                              : std::string("off")};
		                  } else {
			                  std::vector<std::string> ret;
			                  for (auto i : settings) {
				                  ret.push_back(std::string("\"") + i.first +
				                                "\": " +
				                                (i.second ? std::string("on")
				                                          : std::string("off")));
			                  }
			                  return ret;
		                  }
	                  },
	                  0, 1, std::string("Query setting"), functdata::Single)),
	    std::pair<string, functdata*>(
	        ".",
	        new functdata(
	            [](vector<string> inList) -> vector<string> {
		            inList[1].resize(inList[1].size());
		            if (inList.size() == 2)
			            vars.erase(kblib::toLower(inList[1]));
		            else
			            vars[kblib::toLower(inList[1])] = inList[2];
		            return {};
	            },
	            1, 2, std::string("Save/Clear variable"), functdata::Single)),
	    std::pair<string, functdata*>(
	        "?", new functdata(
	                 [](vector<string> inList) -> vector<string> {
		                 if (inList.size() == 2) {
			                 inList[1].resize(inList[1].size());
			                 return {vars[kblib::toLower(inList[1])]};
		                 } else {
			                 std::vector<std::string> ret;
			                 for (auto i : vars) {
				                 ret.push_back(std::string("\"") + i.first +
				                               "\": \"" + i.second + "\"");
			                 }
			                 return ret;
		                 }
	                 },
	                 0, 1, std::string("Query variable"), functdata::Single)),
	    std::pair<string, functdata*>("e", new functdata(
	                                           [](vector<string> inList) {
		                                           std::vector<std::string> ret;
		                                           string tmp = "[";
		                                           for (auto i : inList) {
			                                           (tmp += i) += ':';
		                                           }
		                                           tmp += ']';
		                                           ret.push_back(tmp);
		                                           return ret;
	                                           },
	                                           0, std::string("Echo inputs"))),
	    std::pair<string, functdata*>(
	        "el", new functdata(
	                  [](vector<string> inList) {
		                  // std::vector<std::string> ret;
		                  inList.erase(inList.begin());
		                  return inList;
		                  // for (auto i : inList) {
		                  //  ret.push_back(i);
		                  //}
		                  // return ret;
	                  },
	                  0, std::string("Echo inputs (1/line)"))),
	    std::pair<string, functdata*>(
	        "es", new functdata([](vector<string> inList)
	                                -> vector<string> { return {inList[1]}; },
	                            1, 1, std::string("Echo input (Single)"),
	                            functdata::Single)),
	    std::pair<string, functdata*>(
	        "ec", new functdata(
	                  [](vector<string> inList) -> vector<string> {
		                  std::string ret{inList[1]};
		                  inList.erase(inList.begin());
		                  inList.erase(inList.begin());
		                  for (auto i : inList) {
			                  ret += ' ' + i;
		                  }
		                  return {ret};
	                  },
	                  1, -1, std::string("Echo inputs (Collating)"),
	                  functdata::Batch)),
	    std::pair<string, functdata*>(
	        "#", new functdata(
	                 [](vector<string> inList) -> vector<string> { return {}; },
	                 0, std::string("Echo inputs (1/line)"))),
	    std::pair<string, functdata*>(
	        "dup", new functdata(
	                   [](vector<string> inList) -> vector<string> {
		                   return {inList[1], inList[1]};
	                   },
	                   1, 1, std::string("Duplicate"), functdata::Single)),
	    std::pair<string, functdata*>(
	        "r", new functdata(
	                 [](vector<string> inList) -> vector<string> {
		                 return {inList[2], inList[1]};
	                 },
	                 2, 2, std::string("Reverse"), functdata::Single)),
	    std::pair<string, functdata*>(
	        "k", new functdata(
	                 [](vector<string> inList) {
		                 std::vector<std::string> ret;
		                 inList.erase(inList.begin());
		                 std::vector<std::string> a;
		                 for (auto i : inList) {
			                 a = tokenizeInput(i);
			                 ret.insert(ret.end(), a.begin(), a.end());
		                 }
		                 return ret;
	                 },
	                 0, std::string("Tokenize input (again)"))),
	    std::pair<string, functdata*>(
	        "u", new functdata(
	                 [](vector<string> inList) {
		                 inList.erase(inList.begin());
		                 return std::vector<std::string>{deTokenize(inList)};
	                 },
	                 0, std::string("Detokenize/escape input"))),

	    std::pair<string, functdata*>(
	        "l", new functdata(
	                 [](vector<string> inList) {
		                 std::size_t c = 2, cons = 0;
		                 std::vector<std::string> ret;
		                 while (c < inList.size()) {
			                 auto b = std::vector<std::string>(inList.begin() + c,
			                                                   inList.end());
			                 b.insert(b.begin(), inList[1]);
			                 auto a = commands.execute(b, &cons);
			                 ret.insert(ret.end(), a.begin(), a.end());
			                 if (cons)
				                 c += cons;
			                 else
				                 return ret;
		                 }
		                 return ret;
	                 },
	                 2, -1, std::string("Loop Command"), functdata::Batch)),
	    std::pair<string, functdata*>(
	        "la",
	        new functdata(
	            [](vector<string> inList) -> vector<string> {
		            std::size_t c = 3, cons = 0;
		            std::string r = inList[2];
		            while (c < inList.size()) {
			            r = commands.execute({inList[1], r, inList[c]}, &cons)[0];
			            if (cons)
				            c += cons - 1;
			            else
				            return {r};
		            }
		            return {r};
	            },
	            2, -1, std::string("Loop-accumulate left"), functdata::Batch)),
	    std::pair<string, functdata*>(
	        "lar",
	        new functdata(
	            [](vector<string> inList) -> vector<string> {
		            std::size_t c = 3, cons = 0;
		            std::reverse(inList.begin() + 2, inList.end());
		            std::string r = inList[2];
		            while (c < inList.size()) {
			            r = commands.execute({inList[1], inList[c], r}, &cons)[0];
			            if (cons)
				            c += cons - 1;
			            else
				            return {r};
		            }
		            return {r};
	            },
	            2, -1, std::string("Loop-accumulate right"), functdata::Batch)),
	    std::pair<string, functdata*>(
	        "=", new functdata(
	                 [](vector<string> inList) {
		                 auto a = commands.execute(std::vector<std::string>(
		                     inList.begin() + 2, inList.end()));
		                 return commands.execute(
		                     kblib::arraycat(vector<string>{inList[1]}, a));
	                 },
	                 2, -1, std::string("Apply function"), functdata::Batch)),
	    std::pair<string, functdata*>(
	        "|",
	        new functdata(
	            [](vector<string> inList) -> vector<string> {
		            std::string f(inList[0],
		                          1); // f is all of inList[0] except '|'
		            if (f.empty()) {
			            return {"Please specify a funtion for \"|\""};
		            }
		            auto a = commands.execute(std::vector<std::string>(
		                inList.begin() + 1, inList.end()));
		            return commands.execute(
		                kblib::arraycat(vector<string>{f}, a));
	            },
	            1, -1, std::string("Apply (fixed) function"), functdata::Batch)),
	    std::pair<string, functdata*>(
	        "=p", new functdata(
	                  [](vector<string> inList) {
		                  auto a = commands.execute(std::vector<std::string>(
		                      inList.begin() + 2, inList.end()));
		                  return kblib::arraycat(vector<string>{inList[1]}, a);
	                  },
	                  2, -1, std::string("Pretend to apply function"),
	                  functdata::Batch)),
	    std::pair<string, functdata*>(
	        "p",
	        new functdata(
	            [](vector<string> inList) -> vector<string> {
		            if (inList.size() == 1) {
			            auto dump = commands.getIndex();
			            std::vector<std::string> ret;
			            string tmp;
			            for (unsigned i = 0; i != dump.size(); i++) {
				            (tmp += std::to_string(i)) += ": ";
				            for (unsigned char j = 0; j != 128; j++) {
					            if (dump[i][j].first || dump[i][j].second) {
						            tmp += (char)(j ? j : '/') +
						                   std::to_string(dump[i][j].first) +
						                   (dump[i][j].second ? '*' : ' ') + ' ';
					            }
				            }
				            ret.push_back(tmp);
				            tmp.clear();
				            if (inList[0][1] == 'l') {
					            for (unsigned char j = 0; j != 128; j++) {
						            tmp += (dump[i][j].first
						                        ? std::to_string(dump[i][j].first)
						                        : string(" ")) +
						                   (dump[i][j].second ? '*' : ' ') + ' ';
						            // print 16 to a line
						            if (j % 16 == 15) {
							            ret.push_back(tmp);
							            tmp.clear();
						            }
					            }
					            ret.push_back(tmp);
					            tmp.clear();
				            }
			            }
			            return ret;
		            } else {
			            int len = 0;
			            functdata* found = commands.longestPrefix(
			                kblib::toLower(inList[1]), &len);
			            if (found) {
				            if (found->mode == functdata::Composite)
					            return {string("\"") + inList[1].substr(0, len) +
					                    "\": Aliases \"" + found->help + "\"" +
					                    (found->call ? "   " : "[!]")};
				            else
					            return {string("\"") + inList[1].substr(0, len) +
					                    "\": " + found->help + " [takes " +
					                    std::to_string(found->argN) +
					                    ((found->argX != unsigned(-1))
					                         ? '-' + std::to_string(found->argX)
					                         : std::string("+")) +
					                    "; " + functdata::modeS(found->mode) + ']' +
					                    (found->call ? ' ' : '!')};
			            } else
				            return {std::to_string(len) + "; Nothing found for \"" +
				                    kblib::toLower(inList[1]) + "\""};
		            }
	            },
	            0, 1, std::string("Print/Probe input trie (Long)"),
	            functdata::Single)),
	    std::pair<string, functdata*>(
	        "p-", new functdata(
	                  [](vector<string> inList) {
		                  return commands.allWithPrefix(
		                      inList.size() > 1 ? inList[1] : "");
	                  },
	                  0, 1, std::string("List input trie"), functdata::Single)),
	});
}

inline std::vector<std::pair<std::string, functdata*>> initTrie2() {
	return std::vector<std::pair<std::string, functdata*>>({
	   INPUT_TRIE_DECL("x") {
	      return commands.execute(
	         std::vector<std::string>(inList.begin()+1, inList.end())
	      );
}
, 1, std::string("Execute Command") CPARENS, INPUT_TRIE_DECL("save") {
	int len = 0;
	commands.longestPrefix(inList[1], &len);
	if (static_cast<unsigned>(len) == inList[1].length()) {
		return {std::string("\"") + inList[1] + "\" is already a command."};
	} else {
		commands.insert(
		    std::string(inList[1]),
		    new functdata(
		        [inList](std::vector<std::string> inList2)
		            -> std::vector<std::string> {
			        return commands.execute(tokenizeInput(
			            inList[2] +
			            " "
			            //+
			            // commands.execute(arraycat(std::vector<std::string>(1,"ec"),
			            // std::vector<std::string>(inList2.begin()+1,
			            // inList2.end())))[0]
			            + deTokenize(std::vector<std::string>(inList2.begin() + 1,
			                                                  inList2.end()))));
		        },
		        0, -1, inList[2], functdata::Composite));
		return {"Warning: This feature is highly experimental."};
	}
}
, 2, 2, std::string("Save Command (Simple, EXP)"), functdata::Single CPARENS,
    INPUT_TRIE_DECL("del") {
	auto f = commands.longestPrefix(inList[1], nullptr);
	if (f != nullptr && f->mode == functdata::Composite) {
		commands.remove(inList[1]);
		return {"Deleted " + inList[1]};
	} else {
		return {"Did not delete built-in command " + inList[1]};
	}
}
, 1, 1, std::string("Delete saved Command"), functdata::Single CPARENS,
    INPUT_TRIE_DECL("x-") {
	auto f = commands.longestPrefix(inList[1], nullptr);
	if (f != nullptr) {
		if (f->mode == functdata::Composite) {
			// return tokenizeInput(f->help);
			return kblib::arraycat(
			    tokenizeInput(f->help),
			    std::vector<std::string>(inList.begin() + 2, inList.end()));
		} else {
			return {inList[1]};
		}
	} else {
		return {"Nothing found for \"" + inList[1] + "\""};
	}
}
, 1, 1, std::string("Expand Alias"), functdata::Single CPARENS,
    INPUT_TRIE_DECL("x=") {
	auto f = commands.longestPrefix(inList[1], nullptr);
	// auto allnames = commands.allWithPrefix(inList.size()>1?inList[1]:"");
	if (f != nullptr) {
		if (f->mode == functdata::Composite) {
			return kblib::arraycat(
			    tokenizeInput(f->help),
			    std::vector<std::string>(inList.begin() + 2, inList.end()));
		} else {
			// return {inList[1]};
			if (inList[1] == "=" && inList.size() > 3) {
				/*std::vector<std::string> a, b;
				a = arraycat(std::vector<std::string>({inList[1]}),
				commands.execute({"x=", inList[2]})); b =
				commands.execute(arraycat(std::vector<std::string>({"x="}),
				std::vector<std::string>(inList.begin()+3, inList.end()))); return
				arraycat(a,b);//*/
				return kblib::arraycat(
				    kblib::arraycat(std::vector<std::string>({inList[1]}),
				                    commands.execute({"x=", inList[2]})),
				    commands.execute(
				        kblib::arraycat(std::vector<std::string>({"x="}),
				                        std::vector<std::string>(inList.begin() + 3,
				                                                 inList.end()))));
			}
			return std::vector<std::string>(inList.begin() + 1, inList.end());
		}
	} else {
		return {"Nothing found for \"" + inList[1] + "\""};
	}
}
, 1, std::string("Expand Alias (smart)") CPARENS, INPUT_TRIE_DECL("pa") {
	auto allnames = commands.allWithPrefix(inList.size() > 1 ? inList[1] : "");
	// std::vector<std::pair<std::string,std::string>> aliases;
	std::vector<std::string> ret;
	for (auto i : allnames) {
		auto j = commands.longestPrefix(i, nullptr);
		// No need to test for null because all results are guaranteed to exist
		if (j->mode == functdata::Composite) {
			// aliases.push_back(std::make_pair(i,j->help);
			if (inList[0] == "pa") {
				ret.push_back(std::string("\"") + i + "\": " + j->help);
			} else {
				ret.push_back(i);
			}
		}
	}
	return ret;
}
, 0, 1, std::string("Print all aliases"), functdata::Single CPARENS,
});
}