#include <iostream>
#include <fstream>
#include "Parser.h"

using namespace std;

string StripWord(string word) {
    int i;
    string newWord;

    for(i =0; i < static_cast<int>(word.size()); ++i) {
         // changed test, forgot that +,*, ... were our commands
         if (not isspace(word[i])) {
            newWord = newWord + static_cast<char>(tolower(word[i]));
        }
    }
    return newWord;
}

OperatorT StringToOperatorT(std:: string word){
      string strippedWord = StripWord(word);
      OperatorT op{OperatorT::NONE};

      if (strippedWord == "dump") {
          op = OperatorT::DUMP; 
      } else if (strippedWord == "+") {
          op = OperatorT::ADD; 
      } else if (strippedWord == "-") {
          op = OperatorT::SUBTRACT; 
      } else if (strippedWord == "*") {
          op = OperatorT::MULTIPLY; 
      } else if (strippedWord == "^") {
          op = OperatorT::EXP; 
      } else if (strippedWord == "/") {
          op = OperatorT::DIVIDE; 
      } else if (strippedWord == "%") {
          op = OperatorT::MOD; 
      } else if (strippedWord == "print") {
          op = OperatorT::PRINT; 
      } else if (strippedWord == "input") {
          op = OperatorT::INPUT; 
      } else if (strippedWord == "output_base") {
          op = OperatorT::BASE; 
      } else if (strippedWord == "load") {
          op = OperatorT::LOAD; 
      } else if (strippedWord == "store") {
          op = OperatorT::STORE; 
      } else if (strippedWord == "quit") {
          op = OperatorT::QUIT; 
      } else if (strippedWord == "none") {
          op = OperatorT::NONE; 
      }

      return op;
}

string OperatorTToString( OperatorT op){
    string value;
    switch (op) {
        case OperatorT::DUMP:
          value = "dump";
          break;
        case OperatorT::PRINT:
          value = "print";
          break;
        case OperatorT::QUIT:
          value = "quit";
          break;
        case OperatorT::NONE:
          value = "none";
          break;
        case OperatorT::INPUT:
          value = "input";
          break;
        case OperatorT::BASE:
          value = "output_base";
          break;
        case OperatorT::STORE:
          value = "store";
          break;
        case OperatorT::LOAD:
          value = "load";
          break;
        case OperatorT::ADD:
          value = "+";
          break;
        case OperatorT::SUBTRACT:
          value = "-";
          break;
        case OperatorT::MULTIPLY:
          value = "*";
          break;
        case OperatorT::EXP:
          value = "^";
          break;
        case OperatorT::DIVIDE:
          value = "/";
          break;
        case OperatorT::MOD:
          value = "%";
          break;
        default:
           value = "unknown command";
        
    }
    return value;
    
}

CommandT ParseNextLine(std::ifstream & inFile) {
     CommandT cmd;
     string opCode;

     inFile >> opCode;

     if (not inFile) {
         cmd.op = OperatorT::QUIT;
     } else {
         cmd.op = StringToOperatorT(opCode);
         switch(cmd.op) {
            case OperatorT::ADD:
            case OperatorT::SUBTRACT:
            case OperatorT::MULTIPLY:
            case OperatorT::EXP:
            case OperatorT::DIVIDE:
            case OperatorT::MOD:
                inFile >> cmd.operands[0] >> cmd.operands[1];
                cmd.operandCount = 2;
                break;
            case OperatorT::INPUT:
            case OperatorT::BASE:
            case OperatorT::STORE:
            case OperatorT::LOAD:
                inFile >> cmd.operands[0];
                cmd.operandCount = 1;
                break;
            case OperatorT::DUMP:
            case OperatorT::PRINT:
            case OperatorT::QUIT:
            case OperatorT::NONE:
            default:
                 cmd.operandCount = 0;
                 break;
         }
     }

     return cmd;
}