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

sclass Gen {
  S name;
  O func;
  
  *(S *name, O *func) {}
  
  public S toString() {
    ret name;
  }
}

p-awt {
  loadLog();

  final L<S> _log = cloneList(log);
  thread "Scoring!" {
    print("Yo: " + callF(oneAssoc(dropLast(_log))));
    scoreGenerator(_log, "1 assoc");
    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 s = getInput() + "\n";
  chat.append(s);
  appendToFile(logFile, "[" + chatTime() + "] " + s);
  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());
  }
}

// VERIFICATION PART

static void scoreGenerators(L<S> log) {
  new MultiSet<S> scores;
  for (int i = 1; i <= l(log); i++)
    scoreGenerators1(subList(log, 0, i), scores);
  print(asciiHeading2("SCORES"));
  for (S name : scores.getTopTen())
    print("  [" + scores.get(name) + "] " + name);
  print();
}
  
static void scoreGenerators1(L<S> log, MultiSet<S> scores) {
  if (empty(log)) ret;
  S line = last(log);
  log = dropLast(log);
  
  new L<Gen> gens;
  makeGenerators(gens, log);
  
  for (Gen gen : gens) {
    try {
      if (eq(callF(gen.func), line))
        scores.add(gen.name);
    } catch {}
  }
}

static S callSingle(L<S> log, O genName) {
  new L<Gen> gens;
  makeGenerators(gens, log);
  Gen gen = findByField(gens, "name", genName);
  if (gen == null) null;
  
  ret (S) callF(gen.func);
}

static bool verifySingle(L<S> log, O genName) {
  if (empty(log)) false;
  S line = last(log);
  log = dropLast(log);
  
  new L<Gen> gens;
  makeGenerators(gens, log);
  Gen gen = findByField(gens, "name", genName);
  if (gen == null) false;
  
  try {
    if (eq(callF(gen.func), line))
      true;
  } catch {}
  
  false;
}

static void scoreGenerator(L<S> log, S genName) {
  for (int i = 1; i < l(log); i++) {
    S expect = log.get(i);
    S s = callSingle(subList(log, 0, i), genName);
    bool ok = eq(s, expect);
    if (ok)
      print(genName + " OK: " + expect);
    else
      print(genName + " NO [" + s + "]: " + expect);
  }
}

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