!759

static JList list;

static JTextArea chat;

static JTextField input;

static File logFile;

static new L<S> log;

static L<S> recommendations;

static int listDelay = 2000, listMakingTimeout = 2000;

static int maxListLength = 100;

static Bool thinking;

static new Thinker thinker;

p-awt {

  //substanceLAF("EmeraldDusk"); // Too dark!

  substanceLAF("ChallengerDeep");

  loadLog();

  thinker.startUp(log);

  list = new JList;

  chat = autoScroll(wordWrapTextArea());

  chat.setText(joinLines(log));

  input = new JTextField;

  JFrame frame = showFrame(vgrid(centerAndSouth(chat, input), list));

  //setFrameIconLater(frame, "#1003593");

  onEnter(input, r {

    post();

  });

  onDoubleClick(list, voidfunc(S s) {

    if (empty(s)) ret;

    input.setText(s);

    post();

  });

  fillList();

  input.requestFocus();

}

static S getInput() {

  ret joinLines(" # ", input.getText().trim());

}

static void post() {

  S i = getInput();

  S s = i + "\n";

  chat.append(s);

  appendToFile(logFile, "[" + chatTime() + "] " + s);

  log.add(i);

  input.selectAll();

}

static void fillList() {

  bool t = shouldUpdateList();

  if (neq(t, thinking)) {

    thinking = t;

    setFrameIcon(list, t ? "#1003603" : "#1003593");

  }

  if (!t)

    againl8r();

  else thread "Fill List" {

    final new L<S> data;

    thinker.makeListData(data);

    awt {

      fillListWithStrings(list, data);

      againl8r();

    }

  }

}

static void againl8r() {

  swingAfter(list, listDelay, r { fillList(); });

}

static bool shouldUpdateList() {

  //print("List bounds: " + boundsOnScreen(list));

  ret getFrame(list).isFocused()

    && !mouseInComponent(list);

}

// also called from outside

static L<S> loadLog() {

  if (logFile == null)

    logFile = getProgramFile("log.txt");

  for (S s : toLines(loadTextFile(logFile))) pcall {

    log.add(substring(s, s.indexOf(']')+1).trim());

  }

  ret log;

}

!include #1003606 // GenTesting

sclass Thinker {

  new MultiSet<S> scores;

  void startUp(L<S> log) {

    final L<S> _log = cloneList(log); // Clone to be safe

    thread "Scoring!" {

      GenTesting gt = new GenTesting(voidfunc(L<Gen> gens, L<S> log) { makeGenerators(gens, log); });

      scores = gt.scoreGenerators(_log);

    }

  }

  // 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));

  }

  L<Gen> sortGenerators(L<Gen> gens, final MultiSet<S> scores) {

    ret sortedList(gens, func(Gen a, Gen b) {

      scores.get(b.name)-scores.get(a.name)

    });

  }

  void makeListData(L<S> l) {

    try {

      new L<Gen> gens;

      makeGenerators(gens, log);

      gens = sortGenerators(gens, scores);

      if (empty(gens)) {

        l.add("No generators");

        ret;

      }

      long timeout = now() + listMakingTimeout;

      int i = -1;

      new HashSet<S> seen;

      while (now() < timeout && l(l) < maxListLength && nempty(gens)) {

        i = (i+1) % l(gens);

        Gen gen = gens.get(i);

        try {

          S s = cast callF(gen.func);

          if (empty(s) || seen.contains(s))

            gens.remove(i);

          else {

            seen.add(s);

            l.add(s);

          }

        } catch {

          gens.remove(i);

        }

      }

    } catch e {

      printStackTrace(e);

      l.add(e.toString());

    }

  }

}

// CREATIVE PART!

// put func {}'s returning a string in there

static void makeGenerators(L<Gen> l, final L<S> log) {

  gen(l, "hello random", func { "Hello " + randomID(10) });

  gen(l, quine(func { last(log) }));

  gen(l, quine(func { oneOf(log) }));

  gen(l, "1 assoc", oneAssoc(log));

  gen(l, "most popular", mostPopular(log));

  addLoadedSolvers(l);

}

svoid addLoadedSolvers(L<Gen> l) {

  if (recommendations == null) { 

    recommendations = new L;

    for (S s : scanLog("recommendations.txt"))

      if (isSnippetID(s))

        recommendations.add(s);

  }

  for (final S solverID : recommendations)

    gen(l, solverID, func {

      O c = hotwireCached(solverID);

      ret call(c, "calc", log);

    });

}

static O oneAssoc(final L<S> log) {

  ret func {

    for (int i = l(log)-2; i >= 0; i--)

      if (eqic(log.get(i), last(log)))

        ret log.get(i+1);

    null;

  };

}

static O mostPopular(final L<S> log) {

  ret func {

    ret new MultiHashSet<S>(log).getMostPopularEntry();

  };

}