// Note: use module, not cmodule - we want our own structure() because of DynamicObject

set flag DynModule.

abstract sclass DynGazelleWebServer > DynPrintLogAndEnabled {
  new Set<S> authedCookies;
  bool allowVisitors = true;
  int httpPort = 80;
  transient int absoluteMaxResults = 1000, defaultMaxResults = 100;
  
  transient MyHTTPD server;
  transient new GazelleContextCache_v2 contextCache;

  transient LS searchTypes = ll("", "Rule", "Line");
  
  S switchableFields() { ret "allowVisitors httpPort"; }
  
  transient new HTTPSpamBlocker1 spamBlocker;
  transient double spammerSleep = 60.0;

  void start() ctex {
    super.start();
    if (!enabled) ret;
    
    vm_cleanPrints();
    dm_useLocalMechListCopies();
    
    ownResource(contextCache.listenToMessages());
    contextCache.alwaysFullRefresh();
    
    server = new MyHTTPD(httpPort);
    server.serveFunction = func(S uri, SS parms) {
      serve(uri, parms)
    };
    server.start();
    print("HTTP server started on port " + server.getPort());
  }
  
  void cleanMeUp {
    server.stop();
    server = null;
  }
  
  O serve(S uri, SS params) enter {
    print exceptions {
      ret newRequest().serve(uri, params);
    }
  }
  
  Request newRequest() {
    ret new Request;
  }
  
  S lineURL(long msgID) { ret msgID == 0 ? null : "/line/" + msgID; }
  S lineURL(S context) { ret empty(context) ? null : "/line/" + urlencode(context); }
  S ruleURL(S ruleID) { ret "/rule/" + urlencode(ruleID); }

  long contextToMsgID(S s) {
    new Matches m;
    if "discord msg *" if (isInteger($1)) ret parseLong($1);
    ret 0;
  }
  
  class Request {
    bool authed;
    S uri;
    SS params;
    O[] bodyParams;
    Pair<Int, Bool> spamCheck;

    O spamTest() {    
      spamCheck = spamBlocker.checkRequest(uri, clientIP());
      if (spamCheck.b) {
        sleepSeconds(spammerSleep);
        ret print("go away");
      }
      
      null;
    }

    O serve(S uri, SS params) {
      this.uri = uri;
      this.params = params;
      new Matches m;
      
      try object spamTest();
      
      S domain = serveHttp_domainName();
      for (S a, S b : parseDoubleArrowLinkedHashMap(loadTextFile(javaxDataDir("gazelle-redirects.txt")))) {
        if (swic(domain, a))
          ret hrefresh(doubleToSingleSlashesInURL(b + uri));
      }
      
      S cookie = serveHttp_cookieHandling();
      authed = nempty(cookie) && syncContains(authedCookies, cookie);
      print("Cookie: " + cookie + ", authed: " + authed + ", spam count: " + pairA(spamCheck));
      S master = trim(loadTextFile(javaxSecretDir("gazelle-master-pw")));
      S attempt = params.get('_pass);
      if (nempty(attempt) && nempty(cookie) && nempty(master)) {
        if (eq(attempt, master)) {
          print("Login SUCCEEDED");
          syncAdd(authedCookies, cookie);
          change();
          authed = true;
        } else
          print("Login FAILED");
      }
      
      bodyParams = litobjectarray(style := "font-family: Roboto Mono; " + (authed ? "background-image: url(\"" + imageServerLink(#1101575) + "\")" : "background-color: #FFFF88"));
      
      if (eq(uri, "/logout")) {
        authedCookies.remove(cookie);
        ret "OK, logged out";
      }
      
      if (eq(uri, "/login"))
        ret hframe("Login",
          hfullcenter(h3(htmlEncode2(gazelle_name()) + " Login")
          + (nempty(master) ? hpostform(hpasswordfield('_pass), action := or(params.get('uri), "/")) : "No master PW")));
      
      if (eq(uri, "/favicon.ico"))
        ret serveFile(loadLibrary(gazelle_faviconID()), faviconMimeType());
        
      if (!allowVisitors && !authed)
        ret hrefresh("/login" + hquery(+uri));
        
      ret serve2();
    }
    
    O serve2() {
      new Matches m;
      
      if (eq(uri, "/tests"))
        ret serveTests();
        
      if (swic(uri, "/texts/", m)) {
        S textID = m.rest();
        if (!possibleMD5(textID)) ret serve404();
        ret serveTextFileAsUTF8(javaxDataDir("Gazelle Texts/" + textID));
      }
      
      if (eq(uri, "/testInput"))
        ret serveTestInput();
      
      if (eq(uri, "/lastOutput")) {
        L<GazelleLine> lines = reversed(takeLast(10, dm_discord_allBotLines()));
        ret hframe("Last Output", hcenter(hheading("Last Output")
          + htmlTable2(
            map(lines, line -> {
              L applications = dm_gazelle_applicationsForMsgID(line.msgID);
              //print("Got " + n2(applications, "application") + " for " + line.msgID + " from " + dm_gazelle_longFeedbackCRUD());
              ret litorderedmap(
                "Date" := spanTitle("Message ID: " + line.msgID, htmlencode2(localDateWithMinutes(line.timestamp))),
                "Gazelle said:" := ahref(lineURL(line.msgID), htmlencode2(line.text)),
                "Applied rules" := joinWithSpace(map(f<S, S> ruleLink, collect ruleID(applications)))
              );
            }), htmlEncode := false, tableParams := litparams(cellpadding := 5))
        ));
      }
        
      if (eq(uri, "/json/rawInputLines"))
        ret serveText(jsonEncode(collect text(dm_discord_allLines())));
        
      if (eq(uri, "/channels"))
        ret serveJSON(collectMulti_notNulls(ll('channelID, 'name), dm_discord_channels()));

      if (eq(uri, "/allDistinctInputs"))
        ret serveJSON(uniquify(dm_discord_allTexts()));
        
      if (eq(uri, "/allLines")) {
        LS fields = tok_splitAtComma_emptyOnEmpty(params.get('fields));
        if (empty(fields)) ret serve500("Need fields param");
        // TODO: restrict fields? seems OK though, it's just fields of GazelleLine
        ret serveJSON(collectMulti_notNulls(fields, selectLines(params)));
      }
        
      if (eq(uri, "/lastInput")) {
        L<GazelleLine> lines = reversed(takeLast(30, dm_discord_allLines()));
        ret hframe("Last Input", hcenter(hheading("Last Input")
          + htmlTable2(
            map(lines, line -> {
              //L applications = dm_gazelle_applicationsForMsgID(line.msgID);
              ret litorderedmap(
                "Date" := spanTitle("Message ID: " + line.msgID, htmlencode2(localDateWithMinutes(line.timestamp))),
                "Author" := htmlencode2(line.user),
                "Bot?" := htmlencode2(line.bot ? "yes" : ""),
                "Line" := ahref(lineURL(line.msgID), htmlencode2(escapeNewLines(line.text))),
                //"Applied rules" := joinWithSpace(map(f<S, S> ruleLink, collect ruleID(applications))),
                "More" := moreForMsgID(line.msgID)
              );
            }), htmlEncode := false, tableParams := litparams(cellpadding := 5))
        ));
      }
      
      if (eq(uri, "/commentPatterns"))
        ret hframeAndHeading("Comment patterns that mean something",
          htmlTable2(listToMapsWithSingleKey("Pattern", gazelle_commentPatterns())));
    
      if (eq(uri, "/ruleComments"))
        ret serveRuleComments();
      
      if (swic(uri, "/revisit/", m)) {
        long msgID = assertNotZero(parseLong(m.rest()));
        GazelleLine line = dm_discord_lineForMsgID(msgID);
        if (line == null) ret "Message not found: " + msgID;
        long startTime = sysNow();
        L<virtual GazelleTree> tree = evalWithTimeoutOrNull(30.0, func -> L<virtual GazelleTree> {
          /*dm_gazelle_revisitChatLine(msgID, contextMaker := contextCache, skipBad := false)*/
          (L) dm_call('gazelleLineRevisiter, 'revisitChatLine, msgID, skipBad := false)
        });
        long endTime = sysNow();
        
        S tv = lines(map(f<O, S> gazelleTreeToHTML, tree));
        
        ret hframe("Revisiting msg " + msgID,
          hheading("Revisiting message " + msgID + ": " + htmlEncode2(line.text))
          + nlToBr_withIndents(tv)
          + p((endTime-startTime) + " ms"));
      }
      
      if (swic(uri, "/rule/", m)) {
        S ruleID = assertGlobalID(m.rest());
        ret serveRule(ruleID);
      }
      
      if (swic(uri, "/ruleApplication/", m)) {
        S globalID = assertGlobalID(m.rest());
        ret serveRuleApplication(globalID);
      }
      
      if (swic(uri, "/rawReasoning/", m)) {
        S context = urldecode(m.rest());
        File f = gazelle_discord_reasoningFileForContext(context);
        ret serveText(loadGZippedTextFile(f));
      }
      
      if (eq(uri, "/createRule")) ret createRule();
      
      if (swic(uri, "/line/", m)) {
        ret serveLine(urldecode(m.rest()));
      }
      
      if (eq(uri, "/search") || eq(uri, "/") && nemptyAfterTrim(params.get('q)))
        ret search(params);
      
      if (eq(uri, "/wikipedia"))
        ret serveWikipedia();
      
      if (eq(uri, "/commands"))
        ret hframe("Commands",
          linesLL(hheading("Commands"),
            h3("!eval"),
          
            p([[You can evaluate Java code directly through Discord.
            Unless you are specifically authorized, only a ]] + ahref(rawSelfLink("safeIdentifiers"), "safe subset of identifiers") + " is allowed."),
            
            p("Example: " + tt("!eval 1+2")),
            p("In rare cases " + tt("!eval") + " may fail and you need to type " + tt("!real-eval") + " instead (which invokes an actual Java compiler).")));
  
      if (eq(uri, "/safeIdentifiers"))
        ret hframe("Safe Java Identifiers | Gazelle",
          linesLL(
            hheading("Safe Java(X) identifiers for !eval"),
            hpre(lines(sortedIC(codeAnalysis_allSafeIdentifiers())))));
            
      if (!eq(uri, "/"))
        ret serve404();
      
      //final Map<S, Int> feedbackStats = dm_gazelle_feedbackStats();
      final Map<S, Int> feedbackStats2 = unnull(dm_gazelle_feedbackStatsByJudgement());
      final Map<S, Int> feedbackStats3 = unnull(dm_gazelle_feedbackStatsForNonJudged());
      
      // Main Page / Rules List
      
      S filterByPurpose = params.get('purpose);
      L<T3<S>> rules = empty(filterByPurpose)
        ? dm_allRulesFromRulesModuleWithCommentsAndIDs()
        : dm_gazelle_allRulesWithPurpose(filterByPurpose);
        // dm_gazelle_allRulesWithComment("discord");
        
      bool showAll = eq("1", params.get('showAll));
        
      L<Map> mapped = mapReversed(rules,
        func(T3<S> t) -> SS {
          S ruleID = t.c;
          ret litorderedmap(
            "Rule ID" := !showAll ? null : htmlEncode2(ruleID),
            "Rule Text" := ahref(ruleURL(ruleID), htmlEncode_nlToBr(t.a)),
            "Comments" := !showAll ? null : nlToBr(
              mapEachLine(/*withoutLine("discord",*/ t.b/*)*/, func(S s) -> S {
                new Matches m;
                if "use helper table mech list *"
                  ret "use helper table mech list " +
                    ahref(neatMechListURL($1), m.get(0));
                ret htmlEncode2(s);
              })),
            "# of applications" := strOr(feedbackStats3.get(ruleID), "-"),
            "Feedback" := ahref(rawSelfLink("rule/" + ruleID),
              "+" + toInt(feedbackStats2.get(ruleID + "/good"))
                /*+ " / " +
              toInt(feedbackStats3.get(ruleID))*/
                + " / " + 
              "-" + toInt(feedbackStats2.get(ruleID + "/bad"))));
        });
      
      S sortBy = params.get('sortBy);
      bool desc = eq("1", params.get('desc));
      if (nempty(sortBy))
        if (eq(sortBy, "Feedback"))
          mapped = sortByCalculatedField(mapped, func(Map map) -> Int {
            S s = cast map.get("Feedback");
            ret parseFirstInt(s) - parseSecondInt(s);
          });
        else if (eq(sortBy, "# of applications"))
          mapped = sortByMapKeyAlphaNum(mapped, sortBy);
        else
          mapped = sortByMapKey(mapped, sortBy);
      if (desc) reverseInPlace(mapped);
      
      int start = parseInt(params.get("start")), step = 50;
      S nav = pageNav2(hquery(mapMinus(params, 'start)), l(mapped), start, step, 'start,
        /*leftArrow := span(htmlencode2(unicode_leftPointingTriangle()), style := "font-family: Lucida Sans"),
        rightArrow := span(htmlencode2(unicode_rightPointingTriangle()), style := "font-family: Lucida Sans")*/);
      mapped = subList(mapped, start, start+step);
        
      ret hhtml_head_title_body(gazelle_name() + " - Next-Gen Chat Bot",
        hprelude() +
        hopeningTag link(rel :="icon", href := "/favicon.ico?v=2") +
        hcenter(
          p(b(ahref_unstyled("http://gazelle.botcompany.de", htmlEncode2(gazelle_fullName())), style := "font-size: 5em")) +
          p(hsnippetimg(gazelle_imageID(), height := 150, title := gazelle_name()))
          + greeting()
          + navLine()

          + h3("Rules " + (nempty(filterByPurpose) ? " for purpose " + quote(filterByPurpose) : "") + " (" + l(rules) + ")")
          + p("By purpose: " + joinWithVBar(map(listPlus_inFront(gazelle_allRulePurposes_cached(), 'default), purpose ->
            ahref(hquery(mapPlus(params, +purpose)), htmlEncode2(purpose)))))
          + nav
        + htmlTable2(mapped,
            htmlEncode := false,
            paramsByColName := litmap(
              "Feedback" := litobjectarray(align := 'center),
              "# of applications" := litobjectarray(align := 'center)),
            replaceHeaders := litmap(
              "Rule Text" := "Rule (input + more input => output)",
              "# of applications" := sortLink(params, "# of applications"),
              "Feedback" := sortLink(params, "Feedback")),
            tdParams := litobjectarray(valign := 'top)
            )
            + p(ahref(hquery(mapPlus(params, showAll := 1)), "Show technical stuff"))
            ), bodyParams);
    }
  
    S ruleLink(S ruleID) {
      if (!isGlobalID(ruleID)) ret htmlEncode2(ruleID);
      ret ahref("/rule/" + ruleID, ruleID);
    }
    
    S commentToHTML(S s) {
      new Matches m;
      LS tok = javaTok(s);
      S t = nextToLast(tok);
      S html = null;
      if (dm_gazelle_ruleExists(t))
        html = htmlEncode2(joinSubList(tok, 0, l(tok)-2)) + ruleLink(t);
      else if (matchX("... list *", s, m) && isQuoted(m.get(0)))
        html = htmlEncode2(joinSubList(tok, 0, l(tok)-2)) + ahref(neatMechListURL($1), t);
      if (html == null) html = htmlEncode2(s);
      ret html;
    }

    S gazelleTreeToHTML(virtual GazelleTree tree) {
      if (tree == null) ret "*";
      ret (getBool isSplitNode(tree) ? "[split] " : "")
        + htmlEncode2(getString line(tree)) + appendSquareBracketed(
        joinWithComma(listPlus(
          map htmlEncode2((LS) call(tree, "renderQualityElements")),
          ruleLink((S) call(tree, "ruleID")))));
    }
    
    S moreForMsgID(long msgID) {
      ret ahref(rawSelfLink("revisit/" + msgID), "revisit", rel := "nofollow");
    }
    
    S search(SS params) {
      S q = trim(params.get('q));
      Set<S> types = singletonCISetIfNempty(params.get('type));
      int maxResults = min(absoluteMaxResults, toIntOr(params.get('max), defaultMaxResults));
      L results = empty(q) ? null : dm_gazelle_fullSearch(q, +types, maxResults := maxResults+1);
      S title = empty(q) ? "Search" : "Search results for: " + q;
      ret hframe(title,
        hheading(htmlEncode2(title)) +
        hform("Terms: " + hinputfield('q, value := q, autofocus := true)
          + " Type: " + hselect_list(searchTypes, params.get('type), name := 'type)
          + " " + hsubmit("Search"), action := "/search") +
        (empty(results) ?
          (empty(q) ? "" : "No results") : p(
            l(results) > maxResults ? maxResults + "+ results" : n2(results, "result"))
            + htmlTable2(map(takeFirst_lazy(maxResults, results), o -> {
          S type = shortClassName(o);
          bool isLine = eq(type, "Line");
          long msgID = isLine ? getLong msgID(o) : 0;
          Map map = litorderedmap("Type" :=
            isLine ? spanTitle("Message ID: " + msgID, type) : type);
          S text = htmlEncode2OrNull(getStringOpt text(o));
          if (isLine)
   {
            map.put("Date" := localDateWithMinutes(getLong created(o)));
            map.put("By" := (S) call(o, 'userName));
          }
          if (text != null) {
            if (eq(type, "Rule"))
              text = ahref("/rule/" + getString globalID(o), text);
            else if (isLine)
              text = ahref(lineURL(msgID), text);
            mapPut(map, "Text", text);
          }
          if (isLine)
            map.put("More" := moreForMsgID(msgID));
          ret map;
        }), htmlEncode := false)));
    }

    S serveLine(S contextOrMsgID) {
      GazelleLine l = isInteger(contextOrMsgID)
        ? dm_discord_lineForMsgID(parseLong(contextOrMsgID))
        : gazelle_lineForContext(contextOrMsgID);
        
      if (l == null) ret "Line " + contextOrMsgID + " not found";
      L context = dm_discord_contextAroundLine(l.msgID, -3, 3);
      L applications = 
        nempty(l.context)
          ? gazelle_applicationsForContext(l.context)
          : dm_gazelle_applicationsForMsgID(l.msgID);
      saveFeedback(applications);
      L<GazelleFulfillment> fulfillments = dm_gazelle_fulfillmentsForMsg(l.msgID);
      
      File reasoningFile = gazelle_discord_reasoningFileForContext(l.context);
      bool hasRawReasoning = fileExists(reasoningFile);

      ret hframe("Line " + l.context,
        hheading("Line @ " + localDateWithMinutes(l.timestamp) + ": " + htmlEncode2("<" + l.user + "> " + l.text))
        + p(moreForMsgID(l.msgID))
        + (empty(context) ? "" :
          h3("Context")
          + nlToBr(lines(map(context, line2 -> {
            GazelleLine line = dm_discord_importLine(line2);
            S s = localDateWithMinutes(line.timestamp) + ": " + ahref(line.msgID == l.msgID ? null : lineURL(line.msgID),
              htmlEncode2("<" + line.user + "> " + line.text));
            ret line.msgID == l.msgID ? b(s) : s;
          }))))
        + (hasRawReasoning ? p(ahref("/rawReasoning/" + urlencode(l.context), "Raw reasoning.")) : "")
        + (empty(applications) ? "" : h3("Reasoning")
        + htmlTable2(map(applications, app -> {
            S ruleID = getString ruleID(app);
            Map map = new LinkedHashMap;
            if (nempty(ruleID)) {
              S ruleText = dm_textForRule(ruleID);
              map.put("Rule" := ahref("/rule/" + urlencode(ruleID),
                empty(ruleText) ? "?" : htmlEncode2_nlToBr(ruleText)));
            }
            map.putAll(applicationToMap(app, null, null));
            map.remove("Context");
            map.remove("Generated Output");
            ret map;
          }),
          tdParams := litobjectarray(align := 'center, valign := 'top), htmlEncode := false))
        + (empty(fulfillments) ? "" : h3("Fulfillments")
        + htmlTable2(map(fulfillments, f -> {
            new LinkedHashMap map;
            if (neq(f.line, l.text)) map.put("Originally seen line" := f.line);
            mapPut(map, "Rule" := f.rule);
            mapPut(map, "Judgement" := f.judgement);
            mapPut(map, "Mapping" := dropPrefix("cimap", f.varMap));
            ret map;
          }), tdParams := litobjectarray(align := 'center, valign := 'top), htmlEncode := false))
      );
    }
    
    S createRule() {
      S text = trim(params.get('text)), comments = params.get('comments);
      if (nempty(text)) {
        LS _comments = tlft(comments);
        _comments = map unSquareBracket(_comments);
        if (!authed)
          _comments = map(_comments, s -> "[anon] " + s);
        text = gazelle_processSquareBracketAnnotations(text, _comments);
        S ruleID = pairA(dm_gazelle_addRuleWithComment(text, lines_rtrim(_comments)));
        ret hredirect(ruleURL(ruleID));
      }
      
      S copyFrom = params.get('copyFrom);
      PairS p = empty(copyFrom) ? pair("in => out", "")
        : dm_textAndCommentForRule(copyFrom);
      if (nempty(p.b))
        p.b = appendWithNewLine(withoutLinesStartingWithIC("copied from rule ", p.b),
        "copied from rule " + copyFrom);
      
      ret hframeAndHeading("Create Rule",
        hpostform(
          h3("Rule")
          + htextarea(p.a,
            name := 'text, cols := 80, rows := 10) + "<br><br>" +
          h3("Comments")
          + htextarea(p.b, name := 'comments, cols := 80, rows := 10) +
          "<br><br>" +
          hsubmit("Create Rule")
        )
        + p(targetBlank("/commentPatterns", "Comment patterns.")));
    }
    
    O serveRuleApplication(S globalID) {
      O app = gazelle_applicationForID(globalID);
      if (app == null) ret serve404();
      S title = "Rule Application " + globalID;
      S mrStruct = getString matchedRuleStruct(app);
      O mr = safeUnstruct(mrStruct);
      ret hframe(title,
        hheading(title) +
        htmlTable2(map(objectToMap(mr), func(S field, O value) -> Map {
          litorderedmap("Field" := field, "Value" := sfu(value))
        })));
    }
  
    S serveRule(S ruleID) {
      // add rule comment
      
      S comment = trim(params.get("comment"));
      if (nempty(comment)) {
        if (!authed) comment = "[anon] " + comment;
        dm_gazelle_addRuleComments_verbose(ruleID, ll(comment));
      }
      
      // delete rule comment
      
      S del = params.get("deleteComment");
      if (authed && nempty(del))
        gazelle_removeCommentFromRule(ruleID, del);
  
      PairS textAndComment = unnull(dm_textAndCommentForRule(ruleID));
      L feedback = dm_gazelle_feedbackForRule(ruleID);
      L applications = dm_gazelle_applicationsForRule(ruleID);
      Map<S, O> feedbackByContext = indexByFieldNotNull context(feedback);
      L<GazelleFulfillment> fulfillments = dm_gazelle_fulfillmentsForRule_imported(ruleID);
      L list = cloneList(feedback);
      for (O o : applications)
        if (!containsKey(feedbackByContext, getString context(o)))
          list.add(o);
          
      // add feedback comments + judgement
      
      for (S applicationID, S text : subMapStartingWith_dropPrefix(params, "comment_")) {
        continue if empty(text = trim(text));
        if (!authed) text = "[anon] " + text;
        O app = findByField(list, globalID := applicationID);
        print("Processing comment for " + applicationID + " - " + app);
        if (app == null) continue;
        Set<S> comments = asSet(tlft(getString comments(app)));
        if (!contains(comments, text))
          call(app, '_setField, comments := appendWithNewLine(getString comments(app), text));
      }
      
      saveFeedback(list);
      
      // change rule text
      
      S newRuleText = params.get('ruleText);
      if (authed && nempty(newRuleText)) {
        LS _comments = tlft(textAndComment.b);
        newRuleText = gazelle_processSquareBracketAnnotations(newRuleText, _comments);
        gazelle_setRuleText(ruleID, newRuleText);
        gazelle_setRuleComment(ruleID, lines_rtrim(_comments));
        textAndComment = unnull(dm_textAndCommentForRule(ruleID));
      }
      
      if (authed && nempty(params.get('expandMultiRule))) {
        gazelle_splitMultiRule(ruleID);
        textAndComment = unnull(dm_textAndCommentForRule(ruleID));
      }

      // Serve Rule & Applications & Feedback
      
      GazelleEvalContext ctx = dm_gazelle_evalContextForSingleRule(ruleID);
      GazellePredictor predictor = dm_gazelle_standardPredictor();
      
      L<Map> mapped = map(list, app -> applicationToMap(app, ctx, predictor));
      
      S sortBy = params.get('sortBy);
      if (nempty(sortBy))
        mapped = sortByMapKey(mapped, sortBy);
        
      MultiSet<S> statements = dm_gazelle_statementsForRule_multiSet(ruleID);
      
      LS comments = tlft(textAndComment.b);
      
      // warnings
      Collection<S> warnings = null;
      pcall {
        warnings = (Collection<S>) dm_call('gazelleThoughtHelper, 'autoTestRule, ruleID);
      }
  
      // comment suggestions
      Collection<S> suggestedComments = null;
      pcall {
        //suggestedComments = gazelle_suggestRuleComments(TextCommentsID(textAndComment.a, textAndComment.b, ruleID));
        suggestedComments = (Collection<S>) dm_findAndCall("#1022585/GRuleCommentSuggester", 'suggestComments, textAndComment.a, textAndComment.b, ruleID);
        suggestedComments = listMinusSet(suggestedComments, comments);
      }
      
      S title = "Rule " + ruleLink(ruleID) + ": " + htmlEncode2(newLinesToSpaces_trim(textAndComment.a));
      ret hframe(htmldecode_dropAllTags(title),
        form(p(searchBox2(), style := "text-align: right"), action := "/search")
        + hheading(title)
        + hpostform(
          h3("Rule")
        + div(hblock(textAndComment.a), id := 'ruleText)
        + (authed ? "<br>" + hbuttonOnClick_returnFalse("Edit",
          [[
            $(this).text('Save');
            $(this).attr('onclick', '');
            $('#ruleText').html(]] + jsQuote(htextarea(textAndComment.a, name := 'ruleText, rows := 5, cols := 80)) + [[);
            $('#ruleText textarea').focus();]]) : "")
            
        // Render comments
        
        + (nempty(textAndComment.b) ? h3("Comments") + nlToBr(mapEachLine(textAndComment.b, s -> {
          S html = commentToHTML(s);
          if (authed)
            html += " " + ahref(ruleURL(ruleID) + hquery(deleteComment := s), "[x]");
          ret html;
        })) : "")
        + "<br><br>"
        + "Add comment: " + htextfield("comment") + " " + hsubmit())
        
        // Render warnings
        
        + (empty(warnings) ? ""
          : h3("Warnings") +
          nlToBr(lines(map(f<S, S> commentToHTML, warnings))))
        
        // Render suggested comments
        
        + (empty(suggestedComments) ? ""
          : h3("Suggested comments") +
            nlToBr(lines(map(suggestedComments, c ->
              htmlEncode2(c) + " " + ahref(ruleURL(ruleID) + hquery(comment := c), "[accept]")))))

        + p(ahref("/createRule" + hquery(copyFrom := ruleID), "Duplicate rule.")
          + " " + targetBlank("/commentPatterns", "Comment patterns."))
        
        + (authed && cic(comments, "multi-rule")
          ? hpostform(hsubmit("Deploy Multi-Rule") + hhidden(expandMultiRule := 1))
          : "")
        
        // Serve Feedback
        
        + (empty(mapped) ? "" : h3("Feedback")
        + htmlTable2(mapped,
          tdParams := litobjectarray(align := 'center, valign := 'top),
          htmlEncode := false)
)
        // Serve Fulfillments
        
        + (empty(fulfillments) ? "" : h3("Fulfillments")
        + htmlTable2(map(fulfillments, f -> {
            new LinkedHashMap map;
            mapPut(map, "Line" := ahref(lineURL(contextToMsgID(f.context)), htmlEncode2_nlToBr(f.line)));
            mapPut(map, "Judgement" := f.judgement);
            mapPut(map, "Mapping" := dropPrefix("cimap", f.varMap));
            mapPut(map, "Context" := f.context);
            ret map;
          }),
          tdParams := litobjectarray(align := 'center, valign := 'top),
          paramsByColName := litmap("Line" := litparams(align := 'left)),
          htmlEncode := false))
        + (empty(statements) ? "" : h3("Analysis 1")
        + hblock(multiSetToLines(statements))
)
        + (empty(statements) ? "" : h3("Analysis 2")
        + hblock(sfuLines(mapWithout(objectToMap(
          ai_gazelle_analyzeStatementsForRule_multiSet(statements)), 'statements)))));
    }
    
    S serveWikipedia() {
      /*hheading("All Simple English Wikipedia Topics")
        + htmlTable2(map(simpleWikipediaTopics_cached(), topic -> litorderedmap("Topic" := topic))));*/
      ret hframe("Wikipedia",
        hheading("Retrieved Simple Wikipedia Pages")
        + htmlTable2(map(simpleWikipedia_allCachedTopics(), topic -> litorderedmap("Topic" := topic))));

    }

    Map applicationToMap(O o, GazelleEvalContext ctx, GazellePredictor predictor) {
      bool showStruct = eq("1", params.get('struct));
      S prediction = null;
      if (ctx != null && predictor != null) {
        prediction = "?";
        pcall {
          RuleEngine2_MatchedRule mr = cast unstruct(getString matchedRuleStruct(o));
          if (mr != null)
            prediction = or(predictor.get(ctx, mr), prediction);
        }
      }
      
      S judgement = getString judgement(o);
      S globalID = getString globalID(o);
      S context = getString context(o);

      ret litorderedmap(
        "Judgement" := nempty(judgement) || !authed ? htmlEncode2(judgement) :
          ahref(uri + hqueryWithoutNanoHTTPDStuff(mapPlus(params, "judgeFeedback_" + globalID, 'good)), "mark good") + " " +
          ahref(uri + hqueryWithoutNanoHTTPDStuff(mapPlus(params, "judgeFeedback_" + globalID, 'bad)), "mark bad"),
        "Prediction" := prediction,
        "Generated Output" := getString_htmlEncode outText(o),
        "Rewritten Rule" := ahref("/ruleApplication/" + globalID, getString_htmlEncode modifiedRule(o)),
        "Mapping" := dropPrefix("cimap", getString_htmlEncode varMap(o)),
        "Context" := ahref(lineURL(context), htmlEncode2(context)),
        "Comments" := hform(
          appendIfNempty(nlToBr(rtrim(getString_htmlEncode comments(o))), "<br>")
          + htextfield("comment_" + globalID)),
        "Struct" := showStruct ? getString matchedRuleStruct(o) : null);
    }
    
    S serveRuleComments() {
      ret hframe("All Rule Comments",
        hheading("All Rule Comments")
        + htmlTable2(map(dm_gazelle_allRuleComments(), comment -> litorderedmap("Comment" := comment))));
    }
    
    S hframeAndHeading(S title, O body) {
      ret hframe(title, hheading(htmlEncode2(title)) + body);
    }

    // html-encoded title
    S hframeAndHeading2(S title, O body) {
      ret hframe(htmldecode_dropAllTags(title),
        hheading(title) + body);
    }

    S hframe(S title, O body) {
      //print("Params: " + sfu(bodyParams));
      ret hhtml_head_title_body(title + " | " + htmlEncode2(gazelle_name()),
        loadJQuery() +
        hprelude() +
        body,
        bodyParams);
    }
    
    S searchBox() {
      ret hinputfield('q, style := "width: 120px", autofocus := true)
        + " " + hselect_list(searchTypes, "Rule", name := 'type)
        + " " + hsubmit("Search");
    }
    
    S searchBox2() {
      ret "[search] " + hinputfield('q, style := "width: 120px")
        + " " + hselect_list(searchTypes, "Rule", name := 'type);
    }
    
    void saveFeedback(L list) {
      if (authed) for (S applicationID, S judgement : subMapStartingWith_dropPrefix(params, "judgeFeedback_")) {
        // TODO: copy to feedback module
        continue if !eqOneOf(judgement, 'good, 'bad);
        O app = findByField(list, globalID := applicationID);
        if (dm_isConceptOfModule(app, dm_gazelle_longFeedbackCRUD())) {
          print("Migrating to feedback CRUD");
          app = dm_call(dm_gazelle_feedbackCRUD(), 'uniqConcept, (O) getFieldsAsParams(app, conceptFields_gen(app)));
        }
        print("Judging feedback for " + applicationID + " - " + app);
        call(app, '_setField, +judgement);
      }  
    }
    
    S serveTestInput() {
      S input = params.get('input);
      L<virtual GazelleTree> out = null;
      new L<virtual GInterpretable> interpretables;
      
      if (nempty(input)) {
        // Hopefully safe!
        
        O inputTester = vmBus_query('gazelleInputTester);
        if (inputTester != null)
          out = (L) dm_call(inputTester, 'reason, input,
            interpretables_out := listCollector(interpretables),
            noEvals := true);

        /*out = gazelle_reason_repeat(input,
          interpretables_out := listCollector(interpretables),
          noEvals := true,
          contextMaker := contextCache);*/
      }
        
      ret hframeAndHeading("Test Input",
        hform("Input: " + htextfield('input)
        + " " + hsubmit("Test"))
        + (empty(input) ? "" : p("Processed input: " + b(htmlEncode2(input)))
        + (empty(interpretables) ? "" :
          h3("Results of preprocessing")
          + htmlTable2(
            map(interpretables, func(virtual GInterpretable intp) -> Map {
              litorderedmap(
                "Text" := htmlEncode2(getString text(intp)),
                "Rule" := ruleLink(getString ruleID(intp)))
            }), htmlEncode := false))
        + h3("Output")
        + htmlTable2(
          map(out, func(virtual GazelleTree t) -> Map {
            litorderedmap(
              "Output" := htmlEncode2(getString line(t)),
              "Rule" := ruleLink(getString ruleID(t)),
              "Quality" := htmlEncode2(joinWithComma((LS) call(t, 'renderQualityElements))))
          }
        ), htmlEncode := false)));
    }

    S greeting() {
      ret p(span("<b>Hello! I am a next-generation chat bot in training.</b>", style := "font-size: 1.4em")
        + (!gazelle_isOriginal() ? "" : "<br>"
          + span(targetBlank("https://BotCompany.de", "Maker.") + " "
          + targetBlank("https://slides.com/stefanreich/how-about-thinking-machines/", "Slides.")
          + " "
          + targetBlank("https://discordapp.com/invite/SEAjPqk", b("Join my Discord server!")), style := "font-size: 1.2em")));
    }
    
    S navLine(O... _) {
      bool showAll = eq("1", params.get('showAll));
        
      ret hform(p(ahref(rawSelfLink("commands"), "Commands.")
      + " " + ahref(rawSelfLink("lastInput"), "Last input.")
      + " " + ahref(rawSelfLink("lastOutput"), "Last output.")
      + " " + ahref(rawSelfLink("testInput"), "Test input.")
      + " " + ahref("/tests", "Tests.")
      + stringParOrEmpty more(_)
      + (authed ? " " + ahref(rawSelfLink("createRule"), "Create rule.") : "")
      + (!showAll ? "" : " " + ahref(rawSelfLink("ruleComments"), "Rule comments."))
      + " | " + searchBox()), action := "/search");
    }
    
    S testsModule() { ret gazelle_testsModule(); }
    
    O serveTests() {
      L tests = cast dm_call(testsModule(), 'concepts);
      
      S show = params.get('test);
      S runTest = params.get('runTest);
      if (nempty(runTest)) {
        show = runTest;
        dm_call(testsModule(), 'runTestAndWait, runTest);
      }
      
      O showing = empty(show) ? null : firstWhere(tests, name := show);
      S showingName = getString name(showing);
      
      Pair<Int> stats = cast quickImport(dm_callOpt(testsModule(), 'countAndSuccesses));
      
      bool running = isTrue(dm_getOpt(testsModule(), 'running));
      ret hframeAndHeading2(ahref("/tests", "Tests")
        + (empty(showingName) ? "" : htmlEncode2(" => ") + ahref("/tests" + hquery(test := showingName), htmlEncode2(showingName))),
        (running ? p(tag('blink, "TESTS RUNNING")) : "")
        + (stats == null ? "" : p(n2(stats.a, "test") + ", " + stats.b + " OK"))
        + hSingleRowTable_withSpacing(50, 
            htmlTable2(map(tests, test -> litorderedmap(
            "Test" := ahref(hquery(test := getString name(test)), htmlEncode2(getString name(test))),
            "Last Run" := localDateWithMinutes(getLong lastRun(test)),
            //"Duration" := getLong runtime(test) + " ms",
            "Success" := yesNo2(getBool success(test)),
            "Any Success Ever" := yesNo2(getBool anySuccess(test)))
          ), htmlEncode := false),
          
          (showing == null ? null :
            h3(htmlEncode2("Test " + quote(showingName) + " [" + (getBool success(showing) ? "OK" : "FAILED") + "]"))
          + hpostform(hsubmit("Run Test"), action := hquery(runTest := showingName))
          + htmlEncode_nlToBr(getString contents(showing)))
      ));
    }
    
    // end of Request
  }
} // end of class

sS rawSelfLink(S uri) { ret addSlashPrefix(uri); }

sS hheading(O contents) {
  ret h2(ahref(rawSelfLink(""), htmlEncode2(gazelle_name())) + " | " + contents);
}

sS hprelude() {
  ret [[<link href="https://fonts.googleapis.com/css?family=Roboto+Mono" rel="stylesheet">]] +
    hmobilefix();
}

sS hblock(S s) {
  ret htmlEncode_nlToBr(s);
}

sS sortLink(SS params, S key) {
  params = cloneMap(params);
  mapPutOrRemove(params, 'desc,
    eq(params.get('sortBy), key) && !eq("1", params.get('desc)) ? "1" : null);
  params.put(sortBy := key);
  ret ahref(hquery(params), htmlEncode2(key));
}

static L<GazelleLine> selectLines(SS params) {
  long modifiedAfter = getLong modifiedAfter(params);
  if (modifiedAfter != 0) ret dm_discord_linesModifiedAfter(modifiedAfter);
  ret dm_discord_allLines();
}

Began life as a copy of #1021679