//===========
// Add OOPS |
//===========

parser.commandHistory = [] //KV added for modded parser functions
parser.enteredCmdArr = [] //KV added for modded parser functions


//  KV MODIFIED this function to allow OOPS (and to generally keep histories of commands)
  parser.parse = function(inputText) {
    parser.msg("Input string: " + inputText);
    parser.enteredCmdArr.push(inputText) //KV added to keep entered command history
    // This allows the command system to be temporarily overriden,
    // say if the game asks a question
    if (parser.override) {
      parser.msg("Parser overriden");
      parser.override(inputText)
      delete parser.override
      return
    }
    
    if (inputText) {
      const res = parser.convertInputTextToCommandCandidate(inputText);
      if (typeof res === "string") {
        parsermsg(res);
        world.endTurn(world.PARSER_FAILURE);
        return;
      }
      parser.commandHistory.push(parser.currentCommand) //KV added to keep command history
      parser.currentCommand = res;
    }
    
    // Need to disambiguate, until each of the lowest level lists has exactly one member
    let flag = false;
    for (let i = 0; i < parser.currentCommand.objects.length; i++) {
      for (let j = 0; j < parser.currentCommand.objects[i].length; j++) {
        if (parser.currentCommand.objects[i][j] instanceof Array) {
          if (parser.currentCommand.objects[i][j].length === 1) {
            parser.currentCommand.objects[i][j] = parser.currentCommand.objects[i][j][0];
          }
          else {
            flag = true;
            parser.currentCommand.disambiguate1 = i;
            parser.currentCommand.disambiguate2 = j;
            showMenu(lang.disambig_msg, parser.currentCommand.objects[i][j], function(result) {
              parser.currentCommand.objects[parser.currentCommand.disambiguate1][parser.currentCommand.disambiguate2] = result;
              parser.parse(null);
            });
          }
        }
      }
    }
    if (!flag) {
		
      parser.execute();
 
		parser.lastCmdWasExecuted = true //KV added for OOPS
		parser.Unfound = false //KV added for OOPS
		parser.failedCmd = false //KV added for OOPS
    }
  };
 


//  KV MODIFIED this function to allow OOPS (and to generally keep histories of commands)
  parser.matchItemsToCmd = function(s, cmd) {
    const res = {cmd:cmd, objectTexts:[], objects:[], matches:[]};
    res.score = cmd.score ? cmd.score : 0;
    
    const arr = cmd.regexes.find(el => el.test(s)).exec(s)
    //for (let regex of el.regexes) {
    //  if (regex.test(cmdString)) arr = regex.exec(s)
    //}

    
    const fallbackScope = parser.scope(parser.isVisible);
    arr.shift();  // first element is the whole match, so discard
    
    parser.msg("..Base score: " + res.score);

    for (let i = 0; i < arr.length; i++) {
      if (!cmd.objects[i]) {
        errormsg("That command seems to have an error. It has more capture groups than there are elements in the 'objects' attribute.");
        return false;
      }
      if (cmd.objects[i].ignore) {
        // this capture group has been flagged to be ignored
        continue;
      }
      let objectNames, score = 0;
      res.objectTexts.push(arr[i]);
      if (cmd.objects[i].text) {
        // this capture group has been flagged to be text
        res.objects.push(arr[i]);
        score = 1;
      }
      
      else if (lang.all_regex.test(arr[i]) || lang.all_exclude_regex.test(arr[i])) {
        // Handle ALL and ALL BUT
        if (!cmd.objects[i].scope) console.log("WARNING: Command without scope - " + cmd.name)
        let list = cmd.objects[i].scope ? parser.scope(cmd.objects[i].scope) : fallbackScope;
        let exclude = [game.player];
        
        // anything flagged as scenery should be excluded
        for (let item of list) {
          if (item.scenery || item.excludeFromAll) {
            exclude.push(item);
          }
        }
        
        if (list.length === 0) {
          res.error = cmd.nothingForAll ? cmd.nothingForAll : lang.nothing_msg;
          res.score = -1;
          return res;
        }
        if (lang.all_exclude_regex.test(arr[i])) {
          // if this is ALL BUT we need to remove some things from the list
          // excludes must be in isVisible
          // if it is ambiguous or not recognised it does not get added to the list
          let s = arr[i].replace(all_exclude_regex, "").trim();
          objectNames = s.split(joiner_regex).map(function(el){ return el.trim(); });
          for (let s in objectNames) {
            items = parser.findInList(s, fallbackScope);
            if (items.length === 1) {
              exclude.push(items[0]);
            }
          }
        }
        list = list.filter(function(el) { return !exclude.includes(el); });
        if (list.length > 1 && !cmd.objects[i].multiple) {
          res.error = no_multiples_msg;
          res.score = -1;
          return res;
        }
        score = 2;
        res.objects.push(list.map(function(el) { return [el]; }));
        res.matches.push(arr[i]);
        res.all = true;
      }
      
      else {
        objectNames = arr[i].split(lang.joiner_regex).map(function(el){ return el.trim() });
        if (objectNames.length > 1 && !cmd.objects[i].multiple) {
          res.error = no_multiples_msg;
          res.score = -1;
          return res;
        }
        if (!cmd.objects[i].scope) console.log("WARNING: No scope (or scope not found) in command " + cmd.name)
        let scopes = cmd.objects[i].scope ? [parser.scope(cmd.objects[i].scope), fallbackScope] : [fallbackScope];
        //console.log(scopes)
        
        let objs = [], matches = [];
        let objs2, n;
        for (let s of objectNames) {
          const objNameMatch = lang.article_filter_regex.exec(s);
          if (objNameMatch === null) {
            errormsg("Failed to match to article_filter_regex with '" + s + "', - probably an error in article_filter_regex!");
            return null;
          }
          [objs2, n] = this.findInScope(objNameMatch[1], scopes, cmd.objects[i]);
          if (n === 0) {
			  console.log("KV says: unfound object (s) set to parser.unFound!") //KV added for OOPS
			  parser.unFound = s // KV added for OOPS
			  parser.lastCmdWasExecuted = false //KV added for OOPS
			  parser.failedCmd = cmd  //KV added for OOPS
            res.error = cmd.noobjecterror(s);
            res.score = -1;
            return res;
          }
          else {
            if (n > score) { score = n; }
            objs.push(objs2);
            matches.push(s);
          }
        }
        res.objects.push(objs);
        res.matches.push(matches);
      }
      parser.msg("...Adding to the score: " + score);
      res.score += score;
    }
    return res;
  };

//=============
// OOPS command 
//-------------
//  Added by KV
// 
//  I believe an  OOPS command is essential.
//
//  Even if the player is not using a mobile browser,
//  it's still nice to be able to enter OOPS RALPH after
//  accidentally entering GIVE GREEN LASER SWORD TO ALPH.
//
//  Even with a full keyboard and the up arrow, the player
//  would still have to edit existing text.  OOPS is much easier.
//
//  TODO:  Should OOPS handle commands with no objects?
//
//
//  REQUIREMENTS!
//  -------------
//
//  My modded 'parser.matchItemsToCmd' and 'parser.parse' functions.
//
//  A new array: parser.commandHistory
//  Another new array:  parser.enteredCmdArr
//
//==========================================

commands.push(new Cmd('Oops', {
  regex:/^(?:oops) (.+)$/,
  objects:[
    {scope:parser.isPresent},
  ],
  default:function(item) {
	if (parser.lastCmdWasExecuted) {
		metamsg("There is nothing to correct.");
		return false;
	}
	parser.quickCmd(parser.failedCmd,item)
	return true
  },
}));

//==================
// END OF Add OOPS |
//==================

//KV added this function to make life simple.
function lastCmd(){
	return parser.commandHistory[parser.commandHistory.length-1]
}

//KV added this function to make life simple.

function lastCmdEntered(){
	return parser.enteredCmdArr[parser.enteredCmdArr.length-2]
}

version 3