sbool assisting;
static S generatorsID;

static JFrame frame;
static JTable table, chatTable;
//static JTextArea chat;
static JTextField input;
static L<S> log = synchroList();
static L<S> recommendations;
static L<Thread> thinkThreads = synchroList();
static JLabel status;
static S lastInput;
static Map matchingSuggestion;
static Map<S, ImmL<S>> allLogs = synchroMap();
static JFrame analyzersFrame;
static S dialogImageID;
static JFrame dialogImageFrame;

static int listDelay = 2000;
static int maxLineLength = 1000;
static int maxLongStringLength = 100*1000;

static Bool thinking;
static new Thinker thinker;
static bool showCPU = true;

static S systemPrefix = "[system]";

static S dialog = "new";

svoid randomMain {
  //substanceLAF("EmeraldDusk"); // Too dark!
  //substanceLAF("ChallengerDeep"); // So purple!
  //substance("MistAqua");
  substance("Moderate");

  table = tableWithTooltips();
  //chat = autoScroll(wordWrapTextArea());
  chatTable = tableWithTooltips();
  input = new JTextField;
  status = new JLabel(" ");
  
  S title = assisting ? "Assistance - " + autoFrameTitle() : autoFrameTitle();
  frame = showFrame(title, vgrid(centerAndSouth(
    //jtabs(1, "Chat", chat, "Details", chatTable),
    chatTable,
    input), centerAndSouth(table, status)));
  //setFrameIconLater(frame, "#1003593");
  
  addMenu(frame, "Random",
    "Delete last line (!delete)", r { post("!delete"); },
    "Reload generators (!gen)", r { post("!gen"); },
    "Restart app (!restart)", r { post("!restart"); },
    "Restart Java engine (!fresh)", r { post("!fresh"); },
    "Execute Java code (!j ...)", r { setInput("!j 1+2"); },
    "Switch dialog (!dialog ...)", r { setInput("!dialog bla"); },
    "Restore last input", r { if (nempty(lastInput)) setInput(lastInput); },
    "Show raw dialog", r { showText("Raw Dialog", rawDialog()); },
  );
  
  makeDialogsMenu();
  
  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 {
      chooseSuggestionForEditing(_i-1);
    });
    registerShiftFunctionKey(frame, i, r {
      chooseSuggestion(_i-1);
    });
    registerCtrlFunctionKey(frame, i, r {
      // post user input and then choose suggestion for editing
      Map<S, S> map = getTableLineAsMap(table, _i-1);
      if (map == null) ret;
      rankToTop(map);
      S s = trim(unnull(map.get("Suggestion")));
      logEvent("Suggestion chosen for editing with pre-post", mapPlus(map, "Row", _i, "Input", getInput(), "Top Suggesters", topSuggesters()));
      post();
      setInput(s);
    });
  }
  
  onDoubleClickOrEnter(chatTable, voidfunc(int row) {
    L line = getTableLine(chatTable, row);
    if (line != null)
      setInput(getString(line, 0));
  });
  
  onUpdate(input, r { updateOnce(); });
  
  loadDialog();
  logEvent("Starting");
  
  updateOnce();
  
  input.requestFocus();
  
  if (isAction(last(log)) && confirmYesNo(input, "Run action? " + last(log)))
    action(last(log));
}

static S getInput() {
  ret joinLines(" # ", input.getText().trim());
}

sv post() {
  postAsUser(getInput(), null);
}

static void postAsUser(S i, Map infos) {
  if (inputAllowedByUser(i))
    post(i, infos);
}

svoid chooseSuggestionForEditing(int row) {
  Map<S, S> map = getTableLineAsMap(table, row);
  if (map == null) ret;
  rankToTop(map);
  S s = trim(unnull(map.get("Suggestion")));
  logEvent("Suggestion chosen for editing", mapPlus(map, "Row", row+1, "Input", getInput(), "Top Suggesters", topSuggesters()));
  setInput(s);
}

svoid setInput(final S s) {
  awtIfNecessary {
    lastInput = input.getText();
    input.setText(s);
    input.selectAll();
    input.requestFocus();
  }
}

svoid rankToTop(Map map) {
  rankToTop(map, false);
}

svoid rankToTop(Map map, bool removeISuggesters) {
  if (map == null) ret;
  O s = map.get("Suggesters");
  // Table cells have been structure'd by dataToTable
  L<S> sugg = s instanceof L ? (L) s : (L) unstructure((S) s);
  
  // These are cheaters!
  if (removeISuggesters)
    sugg = rejectWhere(func(S s) { s.endsWith("/i") }, sugg);
  
  thinker.rankToTop(first(sugg));
}

svoid chooseSuggestion(int row) {
  Map<S, S> map = getTableLineAsMap(table, row);
  if (map == null) ret;
  rankToTop(map);
  S s = trim(unnull(map.get("Suggestion")));
  if (empty(s)) ret;
  
  //logEvent("Suggestion chosen", mapPlus(map, "Row", row+1, "Input", getInput(), "Top Suggesters", topSuggesters));
  setInput(s);
  postAsUser(s, mapPlus(map, "Index", row+1));
}

static L topSuggesters() {
  int n = 20;
  n = min(n, tableRows(table));
  new L topSuggesters;
  for (int i = 0; i < n; i++)
    topSuggesters.add(getTableLineAsMap(table, i));
  //if (empty(topSuggesters)) topSuggesters = null;
  ret topSuggesters;
}

svoid logEvent(S type) {
  logEvent(type, litmap());
}

svoid logEvent(S type, Map map) {
  logStructure(new File(dialogDir(), "event.log"),
    ll(type, chatTime(), map));
}

static bool inputAllowedByUser(S i) {
  ret !swic(i, systemPrefix);
}

// may be called from other thread
static void postSystemMessage(final S msg) {
  if (empty(msg)) ret;
  awtIfNecessary {
    post(systemPrefix + " " + msg, litmap("By", "System"));
  }
}

static void post(S i) {
  post(i, null);
}

static void post(S i, Map infos) {
  try {
    i = trim(i);
    if (empty(i)) ret;
    //i = escapeNewLines(i);
    
    if (infos == null) {
      infos = matchingSuggestion;
      if (infos != null)
        print("Ranking to top: " + struct(infos));
      rankToTop(infos, true);
    }
    infos = mapPlus(infos, "Top Suggesters", topSuggesters());
    
    bool tooLong = l(i) > maxLongStringLength;
    
    if (l(i) > maxLineLength) {
      S id = saveLongString(i);
      i = substring(i, 0, maxLineLength) + "... [" + (tooLong ? "too " : "") + "long text " + id + "]";
    }
  } catch e {
    printStackTrace(e);
    i = systemPrefix + " " + exceptionToStringShort(e);
  }
  
  S s = i + "\n";
  //chat.append(escapeNewLines(i) + "\n");
  appendToFile(logFile(), "[" + chatTime() + "] " + s);
  logEvent("Posting", litmap("Text", i, "Infos", infos));
  log.add(i);
  updateChatTable();
  input.selectAll();
  updateOnce();
  try {
    action(i);
  } catch e {
    printStackTrace(e);
    postSystemMessage(exceptionToStringShort(e));
  }
}

static S dropActionPrefix(S s) {
  if (s == null) null;
  s = dropBracketPrefix(s); // e.g. "[bot]"
  if (!s.startsWith("!")) null;
  ret s.substring(1);
}

static bool isAction(S s) {
  ret dropActionPrefix(s) != null;
}

static void action(S s) {
  s = dropActionPrefix(s);
  if (s == null) ret;

  final S _s = s;
  thread "Action" {
    JWindow _loading_window = showLoadingAnimation();
    try {
      genLog_set(getLog()); // 'case user needs it
      gOtherLogs_set(getOtherLogs()); // ditto
      randomsOwnCmds(_s);
      systemCommands(_s, mc());
    } catch e {
      printStackTrace(e);
      postSystemMessage("Error - " + exceptionToStringShort(e));
    } finally {
      genLog_clear();
      gOtherLogs_clear();
      disposeWindow(_loading_window);
    }
  }
}

static volatile bool again;

// This logic is bad...
static void fillList(bool force) {
  bool t = force || shouldUpdateList();
  if (neq(t, thinking)) {
    thinking = t;
    setFrameIcon(table, t ? "#1003603" : "#1003593");
  }
  
  if (!t) {
    if (!force)
      againl8r();
  } else {
    if (nempty(thinkThreads)) { again = true; ret; }
    fillListImpl();
  }
}

static void addKeys(L<Map> data) {
  for (int i = 0; i < l(data); i++) {
    int k = i+1;
    S key = k <= 12 ? "F" + k : null;
    Map m = litorderedmap("Key", key);
    m.putAll(data.get(i));
    data.set(i, m);
  }
}

static void removeMatchingLine(L<Map> data) {
  S input = getInput();
  matchingSuggestion = null;
  for (int i = 0; i < l(data); i++)
    if (eq(input, data.get(i).get("Suggestion"))) {
      matchingSuggestion = mapPlus(data.get(i), "Index", i+1);
      data.remove(i);
      ret;
    }
}

static void fillListImpl() {
  thread "Fill List" {
    try {
      thinkThreads.add(currentThread());
      final new L<Map> data;
      
      thinker.makeListData(cloneList(log), getInput(), getOtherLogs(), data);
      
      awt {
        pcall {
          removeMatchingLine(data);
          addKeys(data);
          dataToTable_uneditable(table, data);
          tableColumnMaxWidth(table, 0, 30); // "Key" column
        }
        againl8r();
      }
    } finally {
      thinkThreads.remove(currentThread());
    if (again) { again = false; fillListImpl(); }
    }
  }
}

static void updateOnce() { fillList(true); }

static void againl8r() {
  swingAfter(table, listDelay, r { fillList(false); });
}

static bool shouldUpdateList() {
  bool result = false;
  S text = " ";
  if (getFrame(table).isFocused()) {
    result = !mouseInComponent(table);
    text = result ? " Thinking..." + (showCPU /*&& thinker.load != 0*/ ? " (" + thinker.load + "% CPU)" : "")
      : "Not thinking cause you got the mouse in there";
  }
  status.setText(text);
  ret result;
}

// also called from outside
static L<S> loadLog() {
  log.clear();
  log.addAll(scanEventLogForText(dialogDir()));
  ret log;
}

static void loadAllLogs() {
  allLogs.clear();
  for (File f : findAllFiles(getProgramDir()))
    if (f.getName().equals("event.log"))
      allLogs.put(f.getParentFile().getName(), new ImmL(scanEventLogForText(f)));
}

synchronized static L<S> getLastFromLog(int n) {
  ret cloneList(getLast(log, n));
}

synchronized static L<S> getLog() {
  ret cloneList(log);
}

static File dialogDir() {
  ret prepareProgramFile(dialog);
}

static File logFile() {
  ret new File(dialogDir(), "log.txt");
}

static void switchDialog(final S name) {
  swingAndWait(r {
    dialog = name;
    touchFile(new File(dialogDir(), "event.log"));
    loadDialog();
    loadAllLogs();
    makeDialogsMenu();
    setFrameTitle(dialog + " - " + getProgramTitle());

    // show special stuff for dialog, like an image
    dialogImageID = trim(readTextFile(new File(dialogDir(), "image-id.txt")));
    showDialogImage();
  });
}

static void loadDialog() {
  loadLog();
  thinker = new Thinker;
  thinker.startUp(log);
  //chat.setText(joinLines(log));
  updateChatTable();
}

static void randomsOwnCmds(S s) {
  new Matches m;
  
  if "dialog *" {
    switchDialog(m.unq(0));
    // TODO: show current dialog somewhere else
    //postSystemMessage("OK, dialog switched to " + quote(dialog));
  }
  
  if "gen"
    generators = null;
  
  if "delete"
    updateChatTable();
    
  if "analyzers"
    showAnalyzers();
    
  if (matchOneOf(s, m, "img *", "image *")) {
    S imageID = m.fsi(0);
    saveTextFile(new File(dialogDir(), "image-id.txt"), imageID);
    dialogImageID = imageID;
    showDialogImage();
  }
  
  if (matchOneOf(s, m, "img", "image")) {
    if (empty(dialogImageID))
      postSystemMessage("No image set for this dialog");
    else
      postSystemMessage("Image for this dialog: " + fsI(dialogImageID));
  }
}

static void showAnalyzers() {
  if (analyzersFrame == null)
    analyzersFrame = showFrame("Analyzers");
}

static void updateChatTable() {
  awtIfNecessary {
    new L data;
    L<L> l = scanLog_safeUnstructure(new File(dialogDir(), "event.log"));
    for (int i = 0; i < l(l); i++) pcall {
      L a = l.get(i), prev = get(l, i-1);
      if (firstIs(a, "Posting")) {
        Map map = cast get(a, 2);
        S text = getString(map, "Text").trim();
        if (eq(text, "!delete")) { removeLast(data); continue; }
        S idx = "";
        Map infos = cast map.get("Infos");
        if (infos != null && infos.containsKey("Index"))
          idx = str(infos.get("Index"));
        else pcall {
          //printStruct("prev: ", prev);
          if (prev != null && firstIs(prev, "Suggestion chosen for editing")) {
            Map m = getMap(prev, 2);
            S suggestion = getString(m, "Suggestion");
            //print("Suggestion: " + structure(suggestion));
            idx = str(get(m, "Row"));
            if (neq(suggestion, text))
              idx += "?";
          }
        }
        data.add(litorderedmap("Text", escapeNewLines(text), "Sugg." /* Suggestion Index */, idx));
      }
    }
    dataToTable_uneditable(chatTable, data);
    tableColumnMaxWidth(chatTable, 1, 40); // enough for 2 digits and a "?"
    scrollTableDownIn(chatTable, 50);
  }
}

static synchronized S saveLongString(S s) {
  s = substring(s, 0, maxLongStringLength);
  S id;
  File f;
  do {
    id = randomID(10);
    f = getProgramFile("long-strings/" + id);
  } while (f.exists());
  
  saveTextFile(f, s);
  ret id;
}

static O generators;

static void makeGenerators(L<Gen> l) {
  synchronized(main.class) {
    if (!isSnippetID(generatorsID)) fail("No generators ID set");
    if (generators == null)
      generators = hotwire(generatorsID);
  }
  new L l2;
  callOpt(generators, "makeGenerators", l2);
  callOpt(generators, "deterministicGenerators", l2);
  l.addAll((L) quickImport(l2));
}

static S rawDialog() {
  ret fromLines(log);
}

static void makeDialogsMenu() {
  new L items;
  for (File dir : listDirs(getProgramDir()))
    if (containsFile(dir, "event.log")) {
      fS dialog = dir.getName();
      items.add(dialog);
      items.add(r { switchDialog(dialog); });
    }
    
  addMenu(frame, "Dialogs", items);
}

static L<ImmL<S>> getOtherLogs() {
  // TODO: sort by latest or smth?
  ret valuesList(mapMinus(allLogs, dialog));
}      

static void hideDialogImage() {
  if (dialogImageFrame != null) {
    disposeFrame(dialogImageFrame);
    dialogImageFrame = null;
  }
}

static void showDialogImage() {
  hideDialogImage();
  if (nempty(dialogImageID)) {
  S title = getSnippetTitle(dialogImageID) + " [" + fsI(dialogImageID) + "/" + dialog + "]";
    dialogImageFrame = getFrame(showImage(dialogImageID, title));
  }
}