#include <iostream>

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

#include "roman.h"
#include "FRC.h"
#include "input.h"

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

using std::string;
using std::vector;
using std::cin;
using std::cout;
using std::endl;

bool Continue = true;
input_trie commands;
std::map<std::string, std::string> vars;
std::map<std::string, bool> settings;

void runCommand(input_trie commands, string in);

#define INPUT_TRIE_DECL(x) std::pair<std::string, functdata*>(std::string(x), new functdata(\
      [](std::vector<std::string> inList) -> std::vector<std::string>{

int main(int argc, char** argv)
{
  string in;
  commands.insert(
  std::vector<std::pair<std::string, functdata*>>({
    std::pair<std::string, functdata*>(std::string("h"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        if (inList.size() > 1) {
          int len = 0;
          functdata *found = commands.longestPrefix(toLower(inList[1]), &len);
          if (found) {
            return {found->help};
          } else {
            return {string("Nothing found for \"")+toLower(inList[1])+"\""};
          }
        } else {
          //from strings.h
          return iHelpStr;
      }},
      0, 1, std::string("Get help"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("q"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        Continue = false;
        return {};
      },
      0, std::string("Quit"))),
    std::pair<std::string, functdata*>(std::string("set"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        inList[1].resize(inList[1].size());
        if (inList.size() > 2)
          settings[toLower(inList[1])] = truthy(inList[2]);
        else
          settings[toLower(inList[1])] = !settings[toLower(inList[1])];
        return {};
      },
      1, 2, std::string("Change settings (toggle if no argument)"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("?"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        if (inList.size() == 2) {
          inList[1].resize(inList[1].size());
          return {settings[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+"\":"+std::to_string(i.second));
          }
          return ret;
        }
      },
      0, 1, std::string("Query setting"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("e"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        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<std::string, functdata*>(std::string("el"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        std::vector<std::string> ret;
        inList.erase(inList.begin());
        for (auto i : inList) {
          ret.push_back(i);
        }
        return ret;
      },
      0, std::string("Echo inputs (Long)"))),
    std::pair<std::string, functdata*>(std::string("es"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {inList[1]};
      },
      1, 1, std::string("Echo inputs (Single)"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("ec"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::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<std::string, functdata*>(std::string("k"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        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<std::string, functdata*>(std::string("s"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        std::vector<std::string> ret;
        inList.erase(inList.begin());
        for (auto i : inList) {
          ret.push_back(sanitizeAN(toLower(i)));
        }
        return ret;
      },
      0, std::string("Sanitize inputs"))),
    std::pair<std::string, functdata*>(std::string("sa"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        std::vector<std::string> ret;
        inList.erase(inList.begin());
        for (auto i : inList) {
          ret.push_back(sanitizeAlpha(toLower(i)));
        }
        return ret;
      },
      0, std::string("Sanitize inputs to only alphabeticals"))),
    std::pair<std::string, functdata*>(std::string("sn"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        std::vector<std::string> ret;
        inList.erase(inList.begin());
        for (auto i : inList) {
          ret.push_back(sanitizeNumeric(i));
        }
        return ret;
      },
      0, std::string("Sanitize input number"))),
    std::pair<std::string, functdata*>(std::string("sr"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        std::vector<std::string> ret;
        inList.erase(inList.begin());
        for (auto i : inList) {
          ret.push_back(Roman::E.sanitizeNumeral(i));
        }
        return ret;
      },
      0, std::string("Sanitize input RN"))),
    std::pair<std::string, functdata*>(std::string("srl"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        std::vector<std::string> ret;
        inList.erase(inList.begin());
        for (auto i : inList) {
          ret.push_back(Roman::L.sanitizeNumeral(i));
        }
        return ret;
      },
      0, std::string("Sanitize input RN"))),
    std::pair<std::string, functdata*>(std::string("x"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return commands.execute(
          std::vector<std::string>(inList.begin()+1, inList.end())
        );
      },
      1, std::string("Execute Command"))),
    std::pair<std::string, functdata*>(std::string("l"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
      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<std::string, functdata*>(std::string("la"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::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<std::string, functdata*>(std::string("lar"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::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<std::string, functdata*>(std::string("="), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        auto a = commands.execute(
          std::vector<std::string>(inList.begin()+2, inList.end()) );
        std::vector<std::string> n = {inList[1]};
        n.insert(n.end(),a.begin(), a.end());
        return commands.execute(n);
      },
      2, -1, std::string("Apply function"), functdata::Batch)),
    std::pair<std::string, functdata*>(std::string("=p"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        auto a = commands.execute(
          std::vector<std::string>(inList.begin()+2, inList.end()) );
        std::vector<std::string> n = {inList[1]};
        n.insert(n.end(),a.begin(), a.end());
        return n;
      },
      2, -1, std::string("Pretend to apply function"), functdata::Batch)),
    std::pair<std::string, functdata*>(std::string("p"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::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(toLower(inList[1]), &len);
          if (found)
            return {string("Matched \"") + inList[1].substr(0,len) + "\": "
              + found->help+" [takes " + std::to_string(found->argN) + '-'
              + std::to_string(found->argX) + "; "
              + functdata::modeS(found->mode) + ']'
              + (found->call?' ':'!')};
          else
            return {std::to_string(len) + "; Nothing found for \""
              + toLower(inList[1])+"\""};
      }},
      0, 1, std::string("Print/Probe input trie"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("p-"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return commands.allWithPrefix(inList.size()>1?inList[1]:"");
      },
      0, 1, std::string("List input trie"), functdata::Single)),

    std::pair<std::string, functdata*>(std::string("+"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {toStr(fromStr<mpz_class>(sanitizeNumeric(inList[1]))
          + fromStr<mpz_class>(sanitizeNumeric(inList[2])))};
      }, 2, 2, std::string("Add numbers"), functdata::FSingle)),
    std::pair<std::string, functdata*>(std::string("-"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {toStr(fromStr<mpz_class>(sanitizeNumeric(inList[1]))
          - fromStr<mpz_class>(sanitizeNumeric(inList[2])))};
      }, 2, 2, std::string("Subtract numbers"), functdata::FSingle)),
    std::pair<std::string, functdata*>(std::string("*"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {toStr(fromStr<mpz_class>(sanitizeNumeric(inList[1]))
          * fromStr<mpz_class>(sanitizeNumeric(inList[2])))};
      }, 2, 2, std::string("Multiply numbers"), functdata::FSingle)),
    std::pair<std::string, functdata*>(std::string("/"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {toStr(fromStr<mpz_class>(sanitizeNumeric(inList[1]))
          / fromStr<mpz_class>(sanitizeNumeric(inList[2])))};
      }, 2, 2, std::string("Divide numbers"), functdata::FSingle)),
    std::pair<std::string, functdata*>(std::string("%"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {toStr(fromStr<mpz_class>(sanitizeNumeric(inList[1]))
          % fromStr<mpz_class>(sanitizeNumeric(inList[2])))};
      }, 2, 2, std::string("Modulo numbers"), functdata::FSingle)),

    std::pair<std::string, functdata*>(std::string("t"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(sanitizeNumeric(inList[1]) + " = "):std::string("")) + 
          Roman::E(fromStr<mpz_class>(sanitizeNumeric(inList[1])))};
      }, 1, 1, std::string("Convert decimal to extended roman"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("tc"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(sanitizeNumeric(inList[1]) + " = "):std::string("")) + 
          Roman::C(fromStr<mpz_class>(sanitizeNumeric(inList[1])))};
      }, 1, 1, std::string("Convert decimal to \"compatible\" roman"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("tl"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(sanitizeNumeric(inList[1]) + " = "):std::string("")) + 
          Roman::L(fromStr<mpz_class>(sanitizeNumeric(inList[1])))};
      }, 1, 1, std::string("Convert decimal to lowercase-extended roman"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("ta"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(sanitizeNumeric(inList[1]) + " = "):std::string("")) + 
          Roman::S.toR(fromStr<mpz_class>(sanitizeNumeric(inList[1])))};
      }, 1, 1, std::string("Convert decimal to absolutely standard roman"), functdata::Single)),

    std::pair<std::string, functdata*>(std::string("f"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::E.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::E(Roman::E.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Convert extended RN to decimal"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("fc"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::C.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::C(Roman::C.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Convert \"compatible\" RN to decimal"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("fl"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::L.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::L(Roman::L.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Convert lowercase-extended RN to decimal"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("fa"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::S.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::S(Roman::S.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Convert absolutely standard RN to decimal"), functdata::Single)),

    std::pair<std::string, functdata*>(std::string("c"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::E.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::E.reduce(Roman::E.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Canonicize extended RN"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("cc"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::C.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::C.reduce(Roman::C.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Canonicize \"compatible\" RN"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("cl"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::L.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::L.reduce(Roman::L.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Canonicize lowercase-extended RN"), functdata::Single)),
    std::pair<std::string, functdata*>(std::string("ca"), new functdata(
      [](std::vector<std::string> inList) -> std::vector<std::string>{
        return {(settings["long"]?(Roman::S.sanitizeNumeral(inList[1]) + " = "):std::string("")) +
          toStr(Roman::S.reduce(Roman::S.sanitizeNumeral(inList[1])))};
      }, 1, 1, std::string("Canonicize absolutely standard RN"), functdata::Single)),

    }));
  
  settings["long"] = false;
  settings["prompt"] = true;
  settings["s_prompt"] = false;
  
  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 interaftive display for scripted commands)
        } else if (argv[i][j] == 'v') {
          settings["s_prompt"] = true;
        } 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]);
    }
  }
  
  unsigned int line = 0;
  
  Continue = Continue & !scriptedCommands.size();
  
  for (auto i : scriptedCommands) {
    //q overrides v
    if (settings["s_prompt"] && settings["prompt"])
      cout<<"$> "<<i<<endl;
    runCommand(commands, i);
  }
  
  //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;
  
  //Don't end when cin fails, clear and move on
  while (Continue) {
    //Actual input loop, large-scope try because all exceptions in main are outside my code
    while (cin && Continue) {
      try {
        if (settings["prompt"])
          cout<<"$> ";
        getline(cin, in);
        if (in.empty()) {
          continue;
        }
        runCommand(commands, 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;
      }
    }
    if (!cin.eof())
      cin.clear();
    else {
      cout<<endl;
      break;
    }
  }
  return 0;
}

void runCommand(input_trie commands, 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;
  }
}