!759

static Map<S, S> theories; // lower case name -> text
static new MultiMap<S, S> signMap;

p {
  theories2 = new PersistentMap("theories2");
  if (theories2.isEmpty()) {
    Map<S, S> theoriesOld = new PersistentMap("theories");
    for (S name : keys(theoriesOld))
      theories.put(name.toLowerCase(), theoriesOld.get(name));
  }
  load("signMap");
}

static synchronized L<S> getTheoryNames() {
  ret new ArrayList(theories.keySet());
}

static synchronized boolean hasTheory(S name) {
  ret theories.containsKey(name.toLowerCase());
}

static synchronized S getTheoryOpt(S name) {
  ret theories.get(name.toLowerCase());
}

static synchronized S getTheory(S name) {
  S text = getTheoryOpt(name);
  if (text == null) fail("Theory * not found", name);
  ret text;
}

static synchronized L<S> getTheoriesSignedBy(S user) {
  ret signMap.reverseGet(user);
}

static synchronized void addTheory(S name, S text) {
  if (hasTheory(name)) fail("Theory * exists", name);
  theories.put(name, text);
}

synchronized answer {
  //if (!attn()) ret null;
  
  if "count theories"
    ret l(theories);
    
  if "list theories"
    ret structure(keys(theories));
    
  if "show theory *" exceptionToUser {
    ret showTheories(litlist(m.unq(0)));
  }
  
  if (matchStart("show theories", s, m)) exceptionToUser {
    ret showTheories(codeTokensOnly(javaTok(m.rest())));
  }
  
  if "modify theory * *" exceptionToUser {
    S name = m.unq(0), text = m.unq(1);
    ret saveTheory(name, text);
  }
  
  if "add theory * *" exceptionToUser {
    S name = m.unq(0), text = m.unq(1);
    addTheory(name, text);
    //boolean parses = doesTheoryParse(name);
    //ret format(parses ? "OK, added theory *" : "Added theory *. Warning: Doesn't parse", name);
    ret format("OK, added theory *", name);
  }
  
  if "sign theory *" exceptionToUser {
    S user = getUserName();
    if (empty(user)) ret "go to slack please";
    S name = m.unq(0);
    if (!hasTheory(name)) ret "Theory not found";
    L<S> users = signMap.get(name);
    if (users.contains(user))
      ret "You have already signed this theory!";
    signMap.put(name, user);
    save("signMap");
    ret "OK, signed! All signers: " + structure(signMap.get(name));
  }
  
  if "unsign theory *" exceptionToUser {
    S user = getUserName();
    if (empty(user)) ret "go to slack please";
    S name = m.unq(0);
    L<S> users = signMap.get(name);
    if (!users.contains(user)) {
      if (!hasTheory(name)) ret "Theory not found";
      ret "You have not signed this theory.";
    }
    signMap.remove(name, user);
    save("signMap");
    ret "OK, unsigned! Remaining signers: " + structure(signMap.get(name));
  }
  
  if "my signed theories" exceptionToUser {
    S user = getUserName();
    if (empty(user)) ret "go to slack please";
    ret structure(signMap.reverseGet(user));
  }

  if "theories signed by *" exceptionToUser {
    S user = m.unq(0);
    ret structure(signMap.reverseGet(user));
  }
  
  if (match("theories page", s) || match("theories url", s))
    ret getBotURL();

  if (!master()) ret null;
  
  if "delete theory *" exceptionToUser {
    S name = toLowerCase(m.unq(0));
    if (hasTheory(name)) {
      S text = theories.get(name);
      logMap("deleted", "name", name, "text", text, "time", now(), "signers", signMap.get(name));
      logMap("deleted", "name", name, "signers", signMap.get(name));
      theories.remove(name);
      
      signMap.remove(name);
      save("signMap");
      
      ret format("Theory * backed up & deleted", name);
    } else
      ret format("Theory * not found", name);
  }
  
  if "rename theory * to *" exceptionToUser {
    S name = toLowerCase(m.unq(0)), newName = toLowerCase(m.unq(1));
    if (hasTheory(newName))
      ret format("A theory named * already exists", newName);
    if (hasTheory(name)) {
      S text = theories.get(name);
      theories.put(newName, text);
      theories.remove(name);

      // update signMap
      L<S> signers = signMap.get(name);
      signMap.addAll(newName, signers);
      signMap.remove(name);
      save("signMap");
      
      ret format("Theory * renamed to *", name, newName);
    } else
      ret format("Theory * not found", name);
  }
}

static S showTheories(L<S> theoryNames) {
  new StringBuilder buf;
  for (S name: theoryNames) {
    if (!hasTheory(name))
      buf.append(format("Theory * not found\n", name));
    else {
      //boolean parses = doesTheoryParse(name);
      buf.append(quote(name) /* + " (" + (parses ? "PARSES" : "DOES NOT PARSE") + ")\n"*/ + "\n" + slackSnippet(theories.get(name)) + "\n\n");
    }
  }
  ret str(buf).trim();
}

static S html() {
  new L data;
  for (S name : theories.keySet()) {
    S text = unnull(theories.get(name));
    boolean multi = false;
    Exception error = null;
    try {
      multi = nlIsMultipleStatements(text);
    } catch (Exception e) {
      error = e;
    }
    Map map = litmap(
      "Name", htmlencode(name),
      "Theory", pre(htmlencode(minitrim(rtrim(text)))),
      "Signed by", htmlencode(structure(signMap.get(name))),
      "Multiple rules?", multi);
    if (error != null)
      map.put("Parse Error", str(error));
    data.add(map);
  }
  ret h3("Theories!") + htmlTable(data, false);
}

// preserves formatting of first line
static S minitrim(S s) {
  L<S> l = toLines(s);
  while (!empty(l) && empty(trim(first(l))))
    l.remove(0);
  ret autoUnindent(fromLines(l));
}

static S saveTheory(S name, S text) {
  boolean has = hasTheory(name);
  logMap(has ? "modified" : "added", "name", name, "text", text, "time", now());
  theories.put(name, text);
  ret format((has ? "OK, modified theory *" : "OK, added theory *"), name);
}