!759

static JTable table;

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 bool updateOnce = true;

static new Thinker thinker;

static S systemPrefix = "[system]";

p-awt {

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

  substanceLAF("ChallengerDeep");

  loadLog();

  thinker.startUp(log);

  table = tableWithTooltips();

  chat = autoScroll(wordWrapTextArea());

  chat.setText(joinLines(log));

  input = new JTextField;

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

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

  onEnter(input, r {

    post();

  });

  onDoubleClick(table, voidfunc(int row) {

    chooseSuggestion(row);

  });

  for (int i = 1; i <= 12; i++) {

    final int _i = i;

    registerFunctionKey(frame, i, r {

      chooseSuggestion(_i-1);

    });

  }

  fillList();

  input.requestFocus();

}

static S getInput() {

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

}

static void post() {

  S i = getInput();

  if (inputAllowedByUser(i))

    post(i);

}

svoid chooseSuggestion(int row) {

  L<S> line = getTableLine(table, row);

  if (line == null) ret;

  S s = line.get(0);

  if (empty(s)) ret;

  input.setText(s);

  post();

}

static bool inputAllowedByUser(S i) {

  ret !swic(i, systemPrefix);

}

static void postSystemMessage(S msg) {

  post(systemPrefix + " " + msg);

}

static void post(S i) {

  S s = i + "\n";

  chat.append(s);

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

  synchronized(mc()) {

    log.add(i);

  }

  input.selectAll();

  updateOnce = true;

  action(i);

}

static void action(S s) {

  if (!s.startsWith("!")) ret;

  s = dropPrefix("!", s);

  new Matches m;

  if "start program *" {

    S progID = m.fsi(0);

    S title = getSnippetTitle(progID);

    // TODO: Show author!

    S msg = "Run program " + progID + " - " + title + "?";

    if (confirmOKCancel(chat, msg)) {

      postSystemMessage("Starting program " + progID + " - " + quote(title));

      nohupJavax(progID);

    } else

      postSystemMessage("Program start cancelled by user (was: " + progID + ")");

  }

}

static void fillList() {

  bool t = shouldUpdateList() || updateOnce;

  updateOnce = false;

  if (neq(t, thinking)) {

    thinking = t;

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

  }

  if (!t)

    againl8r();

  else thread "Fill List" {

    final new L<S> data;

    thinker.makeListData(data);

    dataToTable_uneditable(table, data);

    againl8r();

  }

}

static void againl8r() {

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

}

static bool shouldUpdateList() {

  ret getFrame(table).isFocused()

    && !mouseInComponent(table);

}

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

  new MultiSet<S> quickScores;

  int quickAnalysisDepth = 100;

  int logLengthSeen;

  void startUp(L<S> log) {

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

    thread "Full Scoring!" {

      scores = makeGT().scoreGenerators(_log);

    }

  }

  GenTesting makeGT() {

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

  }

  void updateQuickScores() {

    if (l(log) > logLengthSeen) {

      logLengthSeen = l(log);

      quickScores = makeGT().scoreGenerators(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)

    });

  }

  void makeListData(L l) {

    try {

      updateQuickScores();

      new L<Gen> gens;

      makeGenerators(gens, log);

      gens = sortGenerators(gens, scores);

      if (empty(gens)) {

        l.add(ll("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);

            int k = l(l)+1;

            S key = k <= 12 ? "F" + k : null;

            l.add(litorderedmap("Suggestion", s, "Suggester", gen.name, "Key", key));

          }

        } 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();

  };

}

synchronized static L<S> getLastFromLog(int n) {

  ret cloneList(getLast(log, n));

}