//!include once #1022817 // Attractor Classes

abstract sclass AttractorBot extends AbstractSayAndInputBot implements Runnable {

  transient LS inputQueue = synchroLinkedList();

  transient Set<Thread> activeThreads = synchroSet();

  // functions taking a string and returning a string or collection of strings

  transient L preprocessors = synchroList();

  transient F1<S, Bool> isYes = f<S, Bool> isYes_1;

  new LinkedHashSet<S> facts;

  new LinkedHashSet<S> assumptions;

  transient L<Attractor> standardAttractors = synchroList(); // permanent

  transient L<Attractor> standardLowPrioAttractors = synchroList(); // permanent

  transient L<Attractor> activeAttractors = synchroList();   // temporary

  transient L<Attractor> lowPrioAttractors = synchroList();  // temporary

  S line;

  *() {

    input = f<S> getInput;

    standardPreprocessors();

  }

  void remember(S fact) {

    if (facts.add(fact))

      print("[Bot learned:] " + fact);

  }

  void assume(S fact) {

    if (assumptions.add(fact))

      print("[Bot assumes:] " + fact);

  }

  S getInput() {

    while (empty(inputQueue))

      sleep(10);

    ret trim(popFirst(inputQueue));

  }

  bool yes() {

    ret callF(isYes, input());

  }

  // call this instead of run() so thread is marked

  void run_public() {

    temp tempAddToCollection(activeThreads, currentThread());

    run();

  }

  void addInput(S s) {

    inputQueue.add(s);

    line = s;

    if (empty(activeThreads))

      attractorBattle();

  }

  void attractorBattle {

    if (empty(inputQueue)) ret;

    S input = getInput();

    print("Input: " + input);

    // high prio active, then standing attractors, then low prio active

    L<Attractor> attractors = getAndClearList(activeAttractors);

    addAll(attractors, standardAttractors);

    addAll(attractors, getAndClearList(lowPrioAttractors));

    addAll(attractors, standardLowPrioAttractors);

    if (empty(attractors)) ret with print("No attractors, ignoring input");

    new L<Attractor> matchingAttractors;

    for (Attractor a : attractors) pcall {

      if (a.matches_public(input)) {

        matchingAttractors.add(a);

      }

    }

    if (empty(matchingAttractors))

      ret with print("No matching attractors, ignoring input");

    print("Got " + n2(matchingAttractors, "matching attractor") + ": " + matchingAttractors);

    Attractor winner = first(matchingAttractors);

    if (l(matchingAttractors) > 1) print("Choosing first attractor: " + winner);

    runAttractor(winner);

  }

  // attractors can use AttractorBot.this.say() [old] or emitAnswer() [preferred]

  void runAttractor(Attractor a) {

    say(getVars(getEmittedAnswers(a)));

  }

  void addAttractor(Attractor a) { addAttractors(a); }

  void tempAttractor(Attractor a) { addAttractors(a); }

  void addAttractors(Attractor... attractors) {

    addAll(activeAttractors, attractors);

  }

  void addLowPrioAttractor(Attractor a) { add(lowPrioAttractors, a); }

  void lowPrioAttractor(Attractor a) { addLowPrioAttractor(a); }

  void defaultAttractor(Attractor a) { addLowPrioAttractor(a); }

  void addStandardAttractor(Attractor a) { add(standardAttractors, a); }

  void standardAttractor(Attractor a) { addStandardAttractor(a); }

  void standardAttractors(Attractor... attractors) {

    addAll(standardAttractors, attractors);

  }

  void standardLowPrioAttractor(Attractor a) { add(standardLowPrioAttractors, a); }

  void addPreprocessors(O... l) {

    addAll(preprocessors, l);

  }

  void standardPreprocessors() {

    addPreprocessors(f ai_dropLeadingAndTrailingAppellations_sortedByLength);

  }

  // override me for start-up behavior

  run {}

}