// handleWord.js

(function () {
  /*global adventurejs A*/

  var p = adventurejs.Parser.prototype;

  /**
   * Handle single-word input.
   * @memberOf adventurejs.Parser
   * @method adventurejs.Parser#handleWord
   */
  p.handleWord = function Parser_handleWord() {
    this.game.log(
      "L1211",
      "log",
      "high",
      "handleWord.js > Begin parse.",
      "Parser"
    );
    var this_turn = this.input_history[0];
    var one_word = this_turn.found_word;
    var parsed_noun, verb_name;
    var last_turn = this.input_history[1];
    var number = Number(one_word);
    var msg = "";
    var found_match = false;

    if (last_turn.soft_prompt.noun) parsed_noun = this.parseNoun(one_word);

    /* *
     * Did the last turn prompt for a preposition?
     * See if this turn's input satisfies that.
     * This ran after the verb check until 3/8/23
     * when I noticed an example that needed this
     * to run before the verb check.
     * Example: "put pen table" where? "in"
     * "in" gets parsed as direction verb but should be preposition
     * @TODO keep an eye on this in case it results in verbs failing to parse
     */
    for (let i = 1; i <= 3; i++) {
      if (
        last_turn.soft_prompt["preposition" + i] &&
        this.game.dictionary.isPreposition(one_word)
      ) {
        // was sentence structure explicitly set with soft prompt? use that. otherwise use last turn's structure
        this_turn.verified_sentence_structure =
          last_turn.soft_prompt.structure ||
          last_turn.verified_sentence_structure;
        this_turn.input_verb =
          last_turn.soft_prompt.input_verb || last_turn.input_verb;
        this_turn.verb_phrase =
          last_turn.soft_prompt.verb_phrase || last_turn.verb_phrase;
        this_turn.soft_prompt.satisfied = true;
        this_turn.setOneWord({ ["preposition" + i]: one_word });
        this.game.log(
          "L1212",
          "log",
          "high",
          `handleWord.js > last turn soft prompted for preposition${i} and ${one_word} recognized as preposition`,
          "Parser"
        );

        return this.handleSentence();
      }
    } // preposition

    /**
     * is it a verb that is also a noun that satisfies
     * a travel verb like "go" as in "go east"?
     */
    verb_name = this.parseVerb(one_word);

    this.game.log(
      "L1213",
      "log",
      "high",
      `handleWord.js > ${verb_name} `,
      "Parser"
    );
    if (
      verb_name &&
      last_turn.soft_prompt.noun1 &&
      this.game.dictionary.verbs[verb_name].type.direction
    ) {
      this.game.log(
        "L1214",
        "log",
        "high",
        `handleWord.js > soft_prompt received ${one_word} which is direction+noun and satisfies ${last_turn.input_verb}`,
        "Parser"
      );

      this_turn.setOneWord({ noun1: verb_name });
      this_turn.input_verb =
        last_turn.soft_prompt.input_verb || last_turn.input_verb;
      this_turn.verb_phrase =
        last_turn.soft_prompt.verb_phrase || last_turn.verb_phrase;
      if (last_turn.soft_prompt.verb) {
        this_turn.setOneWord({ verb: last_turn.soft_prompt.verb });
        // this_turn.input_verb =
        //   this.game.dictionary.verbs[last_turn.soft_prompt.verb].prettyname;
        // this_turn.verb_phrase = last_turn.verb_phrase;
      }
      this.game.log(
        "L1215",
        "log",
        "high",
        `handleWord.js > handle soft prompt for noun1`,
        "Parser"
      );
      // was sentence structure explicitly set with soft prompt? use that.
      // otherwise use last turn's structure
      this_turn.verified_sentence_structure =
        last_turn.soft_prompt.structure ||
        last_turn.verified_sentence_structure;
      this_turn.soft_prompt.satisfied = true;
      return this.handleSentence();
    }

    /**
     * Is it a verb?
     * Check our one word input against dictionary verbs.
     * parseVerb returns either the base form of the verb,
     * or false if no matching verb.
     * (Unless last turn was a soft prompt,
     * which is almost always looking for a noun. )
     */
    if (verb_name && !(parsed_noun && parsed_noun.matches.all.length)) {
      //let verb = this.dictionary.verbs[verb_name];

      let verb = this.qualifyParsedVerb({
        parsed_verb_name: verb_name,
      });
      if (!verb) return false;

      if (-1 === verb.accepts_structures.indexOf("verb")) {
        this.game.debug(
          `D1052 | handleWord.js | ${verb_name} doesn't accept structure > verb `
        );
        msg += `${verb.type.travel ? "Where" : "What"} did $(we) want to ${
          verb.prettyname
        }? `;
        msg = msg || verb.msgNoObject;
        this_turn.setSoftPrompt({
          index: 1,
          type: "noun",
          verb: verb.name,
          noun1: true,
          structure: "verb noun",
        });
        this.game.print(msg, this_turn.output_class);
        return false;
      }
      this_turn.setVerb(1, verb_name);
      this_turn.setStructure("verb");
      this.game.log(
        "L1216",
        "log",
        "high",
        `handleWord.js > ${verb_name} recognized as verb`,
        "Parser"
      );
      this.game.dictionary.doVerb(verb_name);
      return true;
    } // verb_name

    // Is it a number?
    // One way or another, let's find a noun.
    if (Number.isInteger(number) && last_turn.disambiguate.index) {
      // add "integer" class to input line
      this.game.display.appendClassesToLastInput("integer");

      one_word = last_turn.getParsedNoun(last_turn.disambiguate.index).matches
        .qualified[number - 1];

      // this can be asset:aspect:substance
      // if so we want to get the asset and this is an ID
      // so we should be able to get the asset
      // without doing another lookup
      // getAsset returns the container not the substance

      // @TODO We don't have any other context for numbers
      // though we might in future handle something like:
      // "Which key did you want to press? > 1"

      if (!one_word) {
        this.game.debug(
          `D1555 | handleWord.js | ${number} is not a valid choice`
        );
        msg += number + " doesn't seem to make sense. ";
        if (msg) this.game.print(msg, this_turn.output_class);
        return false;
      }

      found_match = one_word;
      parsed_noun = new adventurejs.ParsedNoun(this.game.getAsset(one_word));
    } else {
      parsed_noun = this.parseNoun(one_word);
    }

    //No matching key found in world_lookup
    //so we can't do anything with it.
    if (!parsed_noun.matches.all.length) {
      this.game.log(
        "L1217",
        "log",
        "high",
        `handleWord.js > no matching key found in world_lookup `,
        "Parser"
      );
      msg += this.game.settings.getUnparsedMessage(one_word);
      this.game.print(msg, this_turn.output_class);
      return false;
    }

    /**
     * Did the last turn prompt for noun disambiguation?
     * See if this turn's input satisfies that.
     */
    if (last_turn.disambiguate.enabled) {
      this.game.log(
        "L1218",
        "log",
        "high",
        `handleWord.js > handle noun disambiguation`,
        "Parser"
      );
      if (!found_match) {
        found_match = this.findMatchIn(
          parsed_noun.matches.qualified,
          last_turn["parsedNoun" + last_turn.disambiguate.index].matches
            .qualified
        );
      }
      if (found_match) {
        this_turn.verified_sentence_structure =
          last_turn.verified_sentence_structure;

        // what other properties should carry through?
        this_turn.strings = last_turn.strings;

        // @TODO revise this for mo'bettah substance handling
        // that uses asset:aspect:substance
        let type = last_turn.disambiguate.container ? "container" : "noun";

        // set this turn's noun and parsed_noun to what we just found
        this_turn.setOneWord({
          [type + last_turn.disambiguate.index]: found_match,
          [`parsedNoun${last_turn.disambiguate.index}`]: parsed_noun,
        });
        this_turn.input_verb = last_turn.input_verb;
        this_turn.verb_phrase = last_turn.verb_phrase;

        this.game.log(
          "L1219",
          "log",
          "high",
          `handleWord.js > disambiguate found_match ${found_match} `,
          "Parser"
        );
        return this.handleSentence();
      } else {
        // last turn called for disambiguation but no match was found
        this.game.debug(`D1556 | handleWord.js | disambiguation failed`);
        msg += `${number} doesn't seem to make sense. `;
        if (msg) this.game.print(msg, this_turn.output_class);
        return false;
      }
    }

    /**
     * Did the last turn soft prompt for anything?
     * See if this turn's input satisfies that.
     */
    if (last_turn.soft_prompt.enabled) {
      this.game.log(
        "L1220",
        "log",
        "high",
        `handleWord.js > soft_prompt received ${one_word}`,
        "Parser"
      );

      let p = last_turn.soft_prompt;
      let found = p.noun1
        ? "noun1"
        : p.noun2
          ? "noun2"
          : p.noun3
            ? "noun3"
            : p.container1
              ? "container1"
              : p.container2
                ? "container2"
                : p.container3
                  ? "container3"
                  : p.preposition1
                    ? "preposition1"
                    : p.preposition2
                      ? "preposition2"
                      : p.preposition3
                        ? "preposition3"
                        : false;

      if (found) this_turn.setOneWord({ [found]: one_word });
      this_turn.input_verb =
        last_turn.soft_prompt.input_verb || last_turn.input_verb;
      this_turn.verb_phrase =
        last_turn.soft_prompt.verb_phrase || last_turn.verb_phrase;
      if (last_turn.soft_prompt.verb) {
        this_turn.setOneWord({ verb: last_turn.soft_prompt.verb });
        // this_turn.input_verb =
        //   this.game.dictionary.verbs[last_turn.soft_prompt.verb].prettyname;
        // this_turn.verb_phrase = last_turn.verb_phrase;
      }
      this.game.log(
        "L1221",
        "log",
        "high",
        "handleWord.js > handle soft prompt for " + found,
        "Parser"
      );
      // was sentence structure explicitly set with soft prompt? use that.
      // otherwise use last turn's structure
      this_turn.verified_sentence_structure =
        last_turn.soft_prompt.structure ||
        last_turn.verified_sentence_structure;
      this_turn.soft_prompt.satisfied = true;
      return this.handleSentence();
    }

    /**
     * Did we receive a string that hasn't satisfied any prompts?
     */
    if (parsed_noun.object_id === "global_string") {
      this.game.log(
        "L1222",
        "log",
        "high",
        `handleWord.js > received string`,
        "Parser"
      );
      msg += this_turn.strings.toString() + "...?";
      this.game.print(msg, this_turn.output_class);
      return;
    }

    /**
     * Is settings.if_input_is_an_asset_name_examine_it true?
     *
     * If so, naming a noun with no verb is
     * treated as if player had said "examine x"
     */
    if (this.game.settings.if_input_is_an_asset_name_examine_it) {
      this.game.log(
        "L1223",
        "log",
        "high",
        "handleWord.js > if_input_is_an_asset_name_examine_it",
        "Parser"
      );

      parsed_noun = this.qualifyParsedNoun({
        parsedNoun: parsed_noun,
        parsedVerb: "examine",
        nounIndex: "1",
      });

      if (false === parsed_noun) {
        // if qualifyParsedNoun returned false, it also
        // printed an error message, so we can just...
        return false;
      } else {
        // unambiguous object, print default description
        if (1 === parsed_noun.matches.qualified.length) {
          this_turn.setParsedNoun(1, parsed_noun);
          this.game.dictionary.doVerb("examine");
          return;
        }
      }
    } // if( this.game.settings.if_input_is_an_asset_name_examine_it )

    // default
    msg += this.game.settings.getUnparsedMessage(one_word);
    this.game.print(msg, this_turn.output_class);
    return false;
  };
})();