#include <iostream>

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

#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;

void runCommand(input_trie commands, string in);

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){
        if (inList.size() > 1) {
          int len = 0;
          functdata *found = commands.longestPrefix(toLower(inList[1]), &len);
          if (found) {
            cout<<found->help<<endl;
          } else {
            cout<<"Nothing found for "<<toLower(inList[1])<<endl;
          }
        } else {
          //from strings.h
          cout<<iHelpStr;
      }},
      0, std::string("Get help"))),
    std::pair<std::string, functdata*>(std::string("q"), new functdata(
      [](std::vector<std::string> inList){
        Continue = false;
      },
      0, std::string("Quit"))),
    std::pair<std::string, functdata*>(std::string("e"), new functdata(
      [](std::vector<std::string> inList){
        cout<<'[';
        for (unsigned i = 0; i != inList.size(); i++) {
          cout<<inList[i]<<':';
        }
        cout<<']'<<endl;
      },
      0, std::string("Echo inputs"))),
    std::pair<std::string, functdata*>(std::string("x"), new functdata(
      [](std::vector<std::string> inList){
        inList.erase(inList.begin());
        int len = 0;
        functdata *found = commands.longestPrefix(toLower(inList[0]), &len);
        if (found) {
          if (inList.size() > (unsigned)found->argC) {
            (*found)(inList);
          } else {
            cout<<"Please specify all "<<found->argC<<" arguments for "<<inList[0]<<endl;
            cout<<"Tokens recieved (e notation): "<<endl<<'[';
            for (auto i : inList) {
              cout<<i<<':';
            }
            cout<<']'<<endl;
          }
        } else {
          cout<<"Nothing found for "<<toLower(inList[0])<<endl;
      }},
      1, std::string("Execute Command (Very sophisticated no-op)"))),
    std::pair<std::string, functdata*>(std::string("p"), new functdata(
      [](std::vector<std::string> inList){
        if (inList.size() == 1) {
        auto dump = commands.getIndex();
          for (unsigned i = 0; i != dump.size(); i++) {
            cout<<i<<": ";
            for (unsigned char j = 0; j != 128; j++) {
              if (dump[i][j].first || dump[i][j].second) {
                cout<<(char)(j?j:'/')<<dump[i][j].first<<(dump[i][j].second?'*':' ')<<' '<<std::flush;
              }
            }
            cout<<endl;
            if (inList[0][1] == 'l') {
              for (unsigned char j = 0; j != 128; j++) {
                (dump[i][j].first?cout<<dump[i][j].first:cout<<' ')<<(dump[i][j].second?'*':' ')<<' '<<std::flush;
                if (j%16 == 15)
                  cout<<endl;
              }
              cout<<endl;
            }
          }
        } else {
          int len = 0;
          functdata *found = commands.longestPrefix(toLower(inList[1]), &len);
          if (found)
            cout<<"Matched \""<<inList[1].substr(0,len)<<'"'<<endl
              <<found->help<<" [takes "<<found->argC<<']'<<(found->call?' ':'!')<<endl;
          else
            cout<<len<<";Nothing found for "<<toLower(inList[1])<<endl;
      }},
      0, std::string("Print/Probe input trie"))),
    std::pair<std::string, functdata*>(std::string("p-"), new functdata(
      [](std::vector<std::string> inList){
        auto t = commands.allWithPrefix(inList[1]);
        for (auto i : t) {
          cout<<i<<endl;
        }
      },
      1, std::string("List input trie"))),

    std::pair<std::string, functdata*>(std::string("t"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<unsigned long long>(inList[i])<<" = "
            <<toERoman(fromStr<unsigned long long>(inList[i]), 0)<<std::endl;
      }}, 1, std::string("Convert decimal to extended roman"))),
    std::pair<std::string, functdata*>(std::string("te"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<unsigned long long>(inList[i])<<" = "
            <<toERoman(fromStr<unsigned long long>(inList[i]), 0)<<std::endl;
      }}, 1, std::string("Convert decimal to extended RN"))),
    std::pair<std::string, functdata*>(std::string("ts"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<unsigned short>(inList[i])<<" = "
            <<toSRoman(fromStr<unsigned short>(inList[i]))<<std::endl;
      }}, 1, std::string("Convert decimal to absolutely standard RN"))),
    std::pair<std::string, functdata*>(std::string("tc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<unsigned long long>(inList[i])<<" = "
            <<toERoman(fromStr<unsigned long long>(inList[i]), 0, 4)<<std::endl;
      }}, 1, std::string("Convert decimal to \"compatible\" RN"))),
    std::pair<std::string, functdata*>(std::string("tl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<unsigned long long>(inList[i])<<" = "
            <<toLRoman(fromStr<unsigned long long>(inList[i]))<<std::endl;
      }}, 1, std::string("Convert decimal to lowercase-extended RN"))),

    std::pair<std::string, functdata*>(std::string("tf"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<long double>(inList[i])<<" = "
            <<toERoman(fromStr<long double>(inList[i]), 0)<<std::endl;
      }}, 1, std::string("Convert floating-point to extended RN (Rounding errors may occur.)"))),
    std::pair<std::string, functdata*>(std::string("tfc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<long double>(inList[i])<<" = "
            <<toERoman(fromStr<long double>(inList[i]), 0, 4)<<std::endl;
      }}, 1, std::string("Convert floating-point to \"compatible\" RN"))),
    std::pair<std::string, functdata*>(std::string("tfl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<fromStr<long double>(inList[i])<<" = "
            <<toLRoman(fromStr<long double>(inList[i]))<<std::endl;
      }}, 1, std::string("Convert floating-point to lowercase-extended RN"))),

    std::pair<std::string, functdata*>(std::string("tt"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<sanitizeNumeric(inList[i])<<" = "
            <<toERoman(sanitizeNumeric(inList[i]), 0)<<std::endl;
      }}, 1, std::string("Convert text number to extended RN"))),
    std::pair<std::string, functdata*>(std::string("ttc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<sanitizeNumeric(inList[i])<<" = "
            <<toERoman(sanitizeNumeric(inList[i]), 0, 4)<<std::endl;
      }}, 1, std::string("Convert text number to \"compatible\" RN"))),
    std::pair<std::string, functdata*>(std::string("ttl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<sanitizeNumeric(inList[i])<<" = "
            <<toLRoman(sanitizeNumeric(inList[i]))<<std::endl;
      }}, 1, std::string("Convert text number to lowercase-extended RN"))),

    std::pair<std::string, functdata*>(std::string("f"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<inList[i]<<" = "
            <<fromERomanTI(sanitizeNumeral(inList[i]), 24)<<std::endl;
      }}, 1, std::string("Convert extended RN to decimal"))),
    std::pair<std::string, functdata*>(std::string("fc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<inList[i]<<" = "
            <<fromERomanTI(sanitizeNumeral(inList[i]), 4)<<std::endl;
      }}, 1, std::string("Convert \"compatible\" RN to decimal"))),
    std::pair<std::string, functdata*>(std::string("fl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<inList[i]<<" = "
            <<fromERomanTI(sanitizeNumeral(inList[i]), 10)<<std::endl;
      }}, 1, std::string("Convert lowercase-extended RN to decimal"))),

      std::pair<std::string, functdata*>(std::string("ff"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<inList[i]<<" = "
            <<fromERomanTF(sanitizeNumeral(inList[i]))<<std::endl;
      }}, 1, std::string("Convert extended RN to floating-point (Rounding errors may occur.)"))),
    std::pair<std::string, functdata*>(std::string("ffc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<inList[i]<<" = "
            <<fromERomanTF(sanitizeNumeral(inList[i]), 4)<<std::endl;
      }}, 1, std::string("Convert \"compatible\" RN to floating-point (Rounding errors may occur.)"))),
    std::pair<std::string, functdata*>(std::string("ffl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<inList[i]<<" = "
            <<fromERomanTF(sanitizeNumeral(inList[i]), 10)<<std::endl;
      }}, 1, std::string("Convert lowercase-extended RN to floating-point (Rounding errors may occur.)"))),

      std::pair<std::string, functdata*>(std::string("ft"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<sanitizeNumeral(inList[i])<<" = "
            <<fromERomanTS(sanitizeNumeral(inList[i]), 24)<<std::endl;
      }}, 1, std::string("Convert extended RN to decimal"))),
    std::pair<std::string, functdata*>(std::string("ftc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<sanitizeNumeral(inList[i])<<" = "
            <<fromERomanTS(sanitizeNumeral(inList[i]), 4)<<std::endl;
      }}, 1, std::string("Convert \"compatible\" RN to decimal"))),
    std::pair<std::string, functdata*>(std::string("ftl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          std::cout<<sanitizeNumeral(inList[i])<<" = "
            <<fromERomanTS(sanitizeNumeral(inList[i]), 10)<<std::endl;
      }}, 1, std::string("Convert lowercase-extended RN to decimal"))),

    std::pair<std::string, functdata*>(std::string("v"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = fromStr<unsigned long long>(inList[i]);
          auto b = toERoman(a, 0);
          auto c = fromERomanTI(b, 24);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify extended int"))),
    std::pair<std::string, functdata*>(std::string("vs"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = fromStr<unsigned long long>(inList[i]);
          auto b = toSRoman(a);
          auto c = fromERomanTI(b, 24);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify standard int"))),
    std::pair<std::string, functdata*>(std::string("vc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = fromStr<unsigned long long>(inList[i]);
          auto b = toERoman(a, 0, 4);
          auto c = fromERomanTI(b, 4);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify compatible int"))),
    std::pair<std::string, functdata*>(std::string("vl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = fromStr<unsigned long long>(inList[i]);
          auto b = toLRoman(a);
          auto c = fromERomanTI(b, 10);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify lowercase-extended int"))),

    std::pair<std::string, functdata*>(std::string("vf"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = fromStr<long double>(inList[i]);
          auto b = toERoman(a, 0);
          auto c = fromERomanTF(b, 24);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify extended float"))),
    std::pair<std::string, functdata*>(std::string("vfc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = fromStr<long double>(inList[i]);
          auto b = toERoman(a, 0, 4);
          auto c = fromERomanTF(b, 4);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify compatible float"))),
    std::pair<std::string, functdata*>(std::string("vfl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = fromStr<long double>(inList[i]);
          auto b = toLRoman(a);
          auto c = fromERomanTF(b, 10);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify lowercase-extended float"))),

    std::pair<std::string, functdata*>(std::string("vt"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeric(inList[i]);
          auto b = toERoman(a, 0);
          auto c = fromERomanTS(b, 24);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify extended text"))),
    std::pair<std::string, functdata*>(std::string("vtc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeric(inList[i]);
          auto b = toERoman(a, 0, 4);
          auto c = fromERomanTS(b, 4);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify compatible text"))),
    std::pair<std::string, functdata*>(std::string("vtl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeric(inList[i]);
          auto b = toLRoman(a);
          auto c = fromERomanTS(b, 10);
          if (a != c) {
            std::cout<<a<<" ("<<b<<") "<<"\t!=\t"<<c<<std::endl;
          }
      }}, 1, std::string("Verify lowercase-extended text"))),

    std::pair<std::string, functdata*>(std::string("c"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeral(inList[i]);
          auto b = fromERomanTI(a, 24);
          auto c = toERoman(b, 0);
          cout<<a<<" ("<<b<<") = "<<c<<endl;
      }}, 1, std::string("Canonical Form (extended, integer)"))),
    std::pair<std::string, functdata*>(std::string("cc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeral(inList[i]);
          auto b = fromERomanTI(a, 4);
          auto c = toERoman(b, 0, 4);
          cout<<a<<" ("<<b<<") = "<<c<<endl;
      }}, 1, std::string("Canonical Form (compatible, integer)"))),
    std::pair<std::string, functdata*>(std::string("cl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeral(inList[i]);
          auto b = fromERomanTI(a, 10);
          auto c = toLRoman(b);
          cout<<a<<" ("<<b<<") = "<<c<<endl;
      }}, 1, std::string("Canonical Form (lowercase-extended, integer)"))),
//No floating-point mode because of rounding
    std::pair<std::string, functdata*>(std::string("ct"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeral(inList[i]);
          auto b = fromERomanTS(a, 24);
          auto c = toERoman(b, 0);
          cout<<a<<" ("<<b<<") = "<<c<<endl;
      }}, 1, std::string("Canonical Form (extended, text)"))),
    std::pair<std::string, functdata*>(std::string("ctc"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeral(inList[i]);
          auto b = fromERomanTS(a, 4);
          auto c = toERoman(b, 0);
          cout<<a<<" ("<<b<<") = "<<c<<endl;
      }}, 1, std::string("Canonical Form (compatible, text)"))),
    std::pair<std::string, functdata*>(std::string("ctl"), new functdata(
      [](std::vector<std::string> inList){
        for (unsigned i = 1; i != inList.size(); i++) {
          auto a = sanitizeNumeral(inList[i]);
          auto b = fromERomanTS(a, 10);
          auto c = toLRoman(b);
          cout<<a<<" ("<<b<<") = "<<c<<endl;
      }}, 1, std::string("Canonical Form (lowercase-extended, text)"))),

    }}));
  
  std::vector<string> scriptedCommands;
  
  bool display_promt = true, display_promt_s = false, cont_after = false;
  
  for (int i = 1; i < argc; i++) {
    //cout<<"["<<i<<"] "<<argv[i]<<endl;
    if (argv[i][0] == '-') {
      for (int j = 1; argv[i][j] != '\0'; ++j) {
        if (argv[i][j] == 'q') { //quiet (Don't display prompts)
          display_promt = 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') {
          display_promt_s = true;
        } else if (argv[i][j] == 'c') { //continue after scripted commands
          cont_after = true;
        }
      }
    } else { //interpret other strings as commands to be run
      scriptedCommands.emplace_back(argv[i]);
    }
  }
  
  Continue = Continue & !scriptedCommands.size();
  
  for (auto i : scriptedCommands) {
    if (display_promt_s && display_promt) 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 are outside my code
    while (cin && Continue) {
      try {
        if (display_promt)
          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);
  //inList[0] = toLower(inList[0]);
  std::transform(inList[0].begin(), inList[0].end(), inList[0].begin(), ::tolower);
  
  int len = 0;
  functdata *found = commands.longestPrefix(toLower(inList[0]), &len);
  if (found) {
    if (inList.size() > (unsigned)found->argC) {
      (*found)(inList);
    } else {
      cout<<"Please specify all "<<found->argC<<" arguments for "<<inList[0]<<endl;
      cout<<"arguments recieved: [";
      for (auto i : inList) {
        cout<<i<<':';
      }
      cout<<']'<<endl;
    }
  } else {
    cout<<"Nothing found for "<<toLower(inList[0])<<endl;
  }
}