!include #1003606 // GenTesting

sclass Thinker {
  new MultiSet<S> scores;
  new MultiSet<S> quickScores;
  bool useQuickScores;
  int quickAnalysisDepth = 100;
  int listMakingTimeout = 2000;
  int maxListLength = 100;
  int logLengthSeen;
  bool showExceptions, debug;
  
  void startUp(L<S> log) {
    final L<S> _log = cloneList(log); // Clone to be safe
    
    thread "Full Scoring!" {
      scores = scores(_log);
    }
  }
  
  MultiSet<S> scores(L<S> log) {
    ret makeGT().scoreGenerators(log);
  }
  
  MultiSet<S> scores(L<S> log, BitSet interestingLines) {
    ret makeGT().scoreGenerators(log, interestingLines);
  }
  
  GenTesting makeGT() {
    ret new GenTesting(voidfunc(L<Gen> gens, L<S> log) { makeGenerators(gens, log); });
  }
  
  void updateQuickScores(L<S> log) {
    if (!useQuickScores) ret;
    if (l(log) > logLengthSeen) {
      logLengthSeen = l(log);
      quickScores = makeGT().scoreGenerators((L<S>) call(mc(), "getLastFromLog", quickAnalysisDepth));
    }
  }

  // also called from outside
  void recommendSolver(S solverID) {
    if (!isRecommendedSolver(solverID = fsi(solverID))) {
      print("Adding recommended solver: " + solverID);
      logQuoted("recommendations.txt", solverID);
    } else
      print("Solver already recommended: " + solverID);
  }
  
  bool isRecommendedSolver(S solverID) {
    ret contains(scanLog("recommendations.txt"), fsI(solverID));
  }
  
  // Scoring formula!
  int formula(S genName) {
    ret quickScores.get(genName)+scores.get(genName);
  }
  
  L<Gen> sortGenerators(L<Gen> gens, final MultiSet<S> scores) {
    ret sortedList(gens, func(Gen a, Gen b) {
      formula(b.name)-formula(a.name)
    });
  }

  // log = what's in the chat
  // input = what user is typing
  void makeListData(L<S> thelog, S input, L l) {
    try {
      long timeout = now() + listMakingTimeout;
      new HashSet<S> seen;
      
      updateQuickScores(log); // not used atm
      
      // extended log including what user is typing
      L<S> xlog = listPlus(thelog, input);
        
      for (L<S> log : litlist(thelog, xlog)) {
        // Make and sort generators
  
        new L<Gen> gens;
        try {
          genLog_set(log);
          gCompleting_set(log == xlog);
          makeGenerators(gens, log);
          gens = sortGenerators(gens, scores);
          if (empty(gens)) {
            l.add(ll("No generators"));
            ret;
          }
          
          // Generators made. Start making list.
          
          int i = -1;
          while (now() < timeout && l(l) < maxListLength && nempty(gens)) {
            i = (i+1) % l(gens);
            bool remove = false;
            Gen gen = gens.get(i);
            if (debug)
              print("Trying generator " + gen.name);
            try {
              S s = callGen(gen);
              if (empty(s) || seen.contains(s))
                remove = true;
              else {
                seen.add(s);
                int k = l(l)+1;
                S key = k <= 12 ? "F" + k : null;
                l.add(litorderedmap("Key", key, "Suggestion", s, "Suggester", gen.name));
              }
            } catch e {
              if (showExceptions)
                l.add(litorderedmap("Suggestion", "[error] " + exceptionToStringShort(e), "Suggester", gen.name));
              remove = true;
            }
            if (remove)
              gens.remove(i--);
          }
        } finally {
          genLog_clear();
          gCompleting_set(null);
        }
      }
    } catch e {
      printStackTrace(e);
      l.add(e.toString());
    }
  }
}