// don't reuse, create a new instance for each completion

srecord noeq LeftArrowScriptAutoCompleter(GazelleV_LeftArrowScriptParser parser) > Meta {

  LS tok;

  CharInToken cursor;

  S typedCharacters;

  ScoredStringSearcher searcher;

  settable G22Utils g22utils;

  new TreeMap<Int, Cl<S>> knownVarsByTokenIdx;

  new Map<Int, LASValueDescriptor> typeHooks;

  event adaptingSearcher;

  *(G22Utils *g22utils, GazelleV_LeftArrowScriptParser *parser) {}

  void seekEnd(S text) { seek(text, l(text)); }

  void seek(S text, int iChar) {

    if (tok != null) fail("Don't reuse instance");

    parser.setText(text);

    parser.init();

    tok = parser.tok;

    cursor = charIndexToCharInToken(tok, iChar);

    // pointing to space? move left to code token    

    if (even(cursor.iTok) && cursor.iTok > 0 && cursor.iChar == 0) {

      cursor.iTok--;

      cursor.iChar = l(token());

    }

    // move one token left if necessary

    if (cursor.iTok > 1 && cursor.iChar == 0 && empty(space())) {

      cursor.iTok -= 2;

      cursor.iChar = l(token());

    }

    typedCharacters = takeFirst(cursor.token(), cursor.iChar);

    // Attempt a (partial) parse of the document

    // to find out which variables are available where

    parser.onKnownVarsSnapshot(knownVars ->

      knownVarsByTokenIdx.put(parser.tokIdx(), cloneKeys(knownVars)));

    parser.onTypeHook(type -> typeHooks.put(parser.tokIdx(), type));

    pcall-short { parser.parse(); }

  }

  S typedCharacters() {

    ret typedCharacters;

  }

  S space() { ret get(tok, cursor.iTok-1); }

  S token() { ret get(tok, cursor.iTok); }

  S prevToken() { ret get(tok, cursor.iTok-2); }

  bool beginningOfCmd() {

    ret eqOneOf(prevToken(), ";", "{", "}")

      || containsNewLine(space());

  }

  Cl<S> getCompletions() {

    //ret searcher()!;

    ret searcher().get_transformListWithinScore(l1 stringsSortedByLength);

  }

  ScoredStringSearcher searcher() {

    searcher = new ScoredStringSearcher(typedCharacters);

    searcher.uniquify(true);

    if (empty(typedCharacters)) searcher.returnAll = true;

    S prev = prevToken();

    // Get type hook (what type is left of cursor?)

    LASValueDescriptor typeHook = typeHooks.get(cursor.iTok);

    if (scaffoldingEnabled(this)) {

      pnl(+typeHooks);

      printVars LeftArrowScriptAutoCompleter(+beginningOfCmd(), +prev, +cursor, +typedCharacters, +typeHook, globalClassNames := l(parser.globalClassNames()));

    }

    if (typeHook != null && !beginningOfCmd()) {

      Class c = typeHook.javaClass();

      if (c == null) c = O.class;

      addToSearcher(methodNames(c));

      addToSearcher(fieldNames(c));

    } else {

      // No type hook - add global stuff

      // add global methods

      if (beginningOfCmd() || !isIdentifier(prev) || eqOneOf(prev, "if", "else"))

        addToSearcher(globalMethodNames());

      // add global classes

      addToSearcher(keys(parser.globalClassNames()));

      // add the predefined identifiers

      addToSearcher(predefinedExpressions());

      // add locally known variables

      Cl<S> knownVars = floorValue(knownVarsByTokenIdx, cursor.iTok);

      addToSearcher(knownVars);

    }

    adaptingSearcher();

    ret searcher;

  }

  Cl<S> predefinedExpressions() {

    ret ll("true", "false", "null");

  }

  swappable Cl<S> globalMethodNames() {

    new L<S> names;

    for (fc : parser.functionContainers)

      addAll(names, methodNames(fc));

    addAll(names, keys(parser.functionDefs));

    ret names;

  }

  void addToSearcher(Iterable<S> or S... l) {

    fOr (s : l)

      if (!eq(s, typedCharacters))

        searcher.add(s);

  }

}