!759

!include #1003606 // GenTesting

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;

p-awt {

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

  substanceLAF("ChallengerDeep");

  loadLog();

  final L<S> _log = cloneList(log);

  thread "Scoring!" {

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

    print("Yo: " + callF(oneAssoc(dropLast(_log))));

    gt.scoreGenerator(_log, "1 assoc");

    gt.scoreGenerators(_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;

    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;

}

// also called from outside

static void recommendSolver(S solverID) {

  if (!isRecommendedSolver(solverID = fsi(solverID))) {

    print("Adding recommended solver: " + solverID);

    logQuoted("recommendations.txt", solverID);

  } else

    print("Solver already recommended: " + solverID);

}

static bool isRecommendedSolver(S solverID) {

  ret contains(scanLog("recommendations.txt"), fsI(solverID));

}

static void makeListData(L<S> l) {

  try {

    new L<Gen> gens;

    makeGenerators(gens, log);

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

  };

}