// createVerb.js

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

  var p = AdventureJS.Dictionary.prototype;

  /**
   * Native verbs are stored as non-classed objects, aka preverbs.
   * This method calls the <a href="/doc/AdventureJS.Dictionary.Verb.html">Verb()</a>
   * constructor and passes data from
   * preverb to verb, then adds the new verb to game.dictionary.verbs.
   * @memberOf AdventureJS.Dictionary
   * @method AdventureJS.Dictionary#createVerb
   * @kind function
   * @param  {object} preverb A generic object.
   * @returns {object} The constructed verb
   */
  p.createVerb = function Dictionary_createVerb(preverb) {
    // add new verb to the dictionary
    if ("undefined" === typeof preverb) {
      var msg = "Dictionary.createVerb received a bad value: " + preverb;
      this.game.log("L1287", "warn", 0, msg, "dictionary");
      return false;
    }
    if ("undefined" === typeof preverb.name) {
      var msg =
        "Dictionary.createVerb received a preverb without a name: " + preverb;
      this.game.log("L1288", "warn", 0, msg, "dictionary");
      return false;
    }
    if (this.verbs[preverb.name]) {
      var msg =
        "Dictionary.createVerb Found an existing verb named " +
        preverb.name +
        ". ";
      this.game.log("L1289", "warn", "critical", msg, "dictionary");
      return false;
    }

    // accommodate for "try to verb"
    if (preverb.can_try) {
      if (!preverb.try_to_verb) preverb.try_to_verb = [];
      if (!preverb.try_to_verb.includes(`try to ${preverb.name}`))
        preverb.try_to_verb.push(`try to ${preverb.name}`);
      if (!preverb.try_to_verb.includes(`try and ${preverb.name}`))
        preverb.try_to_verb.push(`try and ${preverb.name}`);
      if (
        preverb.prettyname &&
        !preverb.try_to_verb.includes(`try to ${preverb.prettyname}`)
      )
        preverb.try_to_verb.push(`try to ${preverb.prettyname}`);
      if (
        preverb.prettyname &&
        !preverb.try_to_verb.includes(`try and ${preverb.prettyname}`)
      )
        preverb.try_to_verb.push(`try and ${preverb.prettyname}`);
      if (preverb.synonyms?.length) {
        for (let i in preverb.synonyms) {
          if (!preverb.try_to_verb.includes(`try to ${preverb.synonyms[i]}`))
            preverb.try_to_verb.push(`try to ${preverb.synonyms[i]}`);
          if (!preverb.try_to_verb.includes(`try and ${preverb.synonyms[i]}`))
            preverb.try_to_verb.push(`try and ${preverb.synonyms[i]}`);
        }
      }

      // accommodate for gerund aka "try verbing"
      if (preverb.gerund) {
        if (!preverb.try_gerund) preverb.try_gerund = [];
        if (!preverb.try_gerund.includes(`try ${preverb.gerund}`))
          preverb.try_gerund.push(`try ${preverb.gerund}`);
      }
    }

    const verb = (this.verbs[preverb.name] = new AdventureJS.Dictionary.Verb(
      this.game
    ));
    verb.set(preverb);
    verb.validate();
    verb.initialize();
    this.verb_lookup[verb.name] = {
      synonyms: verb.synonyms,
    };

    this.verb_form_lookup[verb.name] = {
      verb: verb.name,
      source: verb.name,
      name: true,
      first: true,
    };
    let third = this.getThirdPersonSingular(verb.name);
    if (third && third !== verb.name) {
      this.verb_form_lookup[third] = {
        verb: verb.name,
        source: verb.name,
        third: true,
      };
    }

    if (!verb.type.direction && !verb.type.utility) {
      // directions and utilities don't get conjugated
      // let words = [verb.name].concat(verb.synonyms);
      let words = verb.synonyms;
      for (let item in words) {
        let word = words[item];
        let third = "";
        let other = "";
        if (word.length < 2) continue; // 1-char aliases don't get conjugated
        if ("undefined" === typeof this.verb_form_lookup[word]) {
          this.verb_form_lookup[word] = {
            verb: verb.name,
            source: word,
            synonym: true,
            first: true,
          };
        }
        let split = word.split(" ");
        if (split.length > 1) {
          // ex: ask about -> asks about
          word = split[0];
          other = " " + split.slice(1).join(" ");
        }
        third = this.getThirdPersonSingular(word);
        if (third && other) third = `${third} ${other}`;
        if (
          third &&
          third !== word &&
          "undefined" === typeof this.verb_form_lookup[third]
        ) {
          this.verb_form_lookup[third] = {
            verb: verb.name,
            source: word,
            synonym: true,
            third: true,
          };
        }
      }
    }

    if (verb.gerund) {
      this.verb_lookup[verb.name].synonyms.push(verb.gerund);
    }

    return verb;
  };
})();