!752

static boolean equipWithSigned = true; // add Stefan's signed theories to all AIs

static new Map<S, AI> aiMap;

static O prolog;

static class AI {

  S theory;

  boolean enabled;

  S icon;

  long iconFetched;

  *() {}

  *(S *theory) {}

}

p {

  load("aiMap");

}

static S createAI(S name, S theory) {

  if (getTheory(theory) == null)

    ret format("Theory * not found", theory);

  AI ai = new AI(theory);

  ai.enabled = true;

  aiMap.put(name, ai);

  logStructure("log", litlist("add", name, ai));

  save("aiMap");

  ret format("OK, AI * is created & enabled!", name);

}

synchronized answer { exceptionToUser {

  if "create ai * *" {

    S name = m.unq(0), theory = m.unq(1);

    ret createAI(name, theory);

  }

  if "create ai *" {

    S name = m.unq(0);

    ret createAI(name, name);

  }

  if "update ai * *" {

    S name = m.unq(0), theory = m.unq(1);

    if (getTheory(theory) == null)

      ret format("Theory * not found", theory);

    AI ai = lookupPossiblyIgnoreCase(aiMap, name);

    if (ai == null) ret format("AI * not found", name);

    ai.theory = theory;

    save("aiMap");

    ret format("AI * updated to *", name, theory);

  }

  if "disable ai *" {

    S name = m.unq(0);

    AI ai = lookupPossiblyIgnoreCase(aiMap, name);

    if (ai == null) ret format("AI * not found", name);

    if (!ai.enabled) ret "AI not enabled anyway";

    ai.enabled = false;

    save("aiMap");

    ret "AI disabled.";

  }

  if "enable ai *" {

    S name = m.unq(0);

    AI ai = lookupPossiblyIgnoreCase(aiMap, name);

    if (ai == null) ret format("AI * not found", name);

    if (ai.enabled) ret "AI already enabled";

    ai.enabled = true;

    save("aiMap");

    ret "AI enabled.";

  }

  if "rename ai * to *" {

    S name = m.unq(0), newName = m.unq(1);

    AI ai = lookupPossiblyIgnoreCase(aiMap, name);

    if (ai == null) ret format("AI * not found", name);

    name = reverseLookup(aiMap, ai);

    AI ai2 = lookupPossiblyIgnoreCase(aiMap, newName);

    if (ai2 != null)

      ret format("Target name * exists!", newName);

    aiMap.remove(name);

    aiMap.put(newName, ai);

    save("aiMap");

    ret format("AI * renamed to *", name, newName);

  }

  if "list ais" {

    ret slackSnippet(structureLines(aiMap));

  }

  if "theory of *" {

    S name = m.unq(0);

    AI ai = lookupPossiblyIgnoreCase(aiMap, name);

    if (ai != null) {

      L<S> names = getTheoryNames(name, ai);

      new StringBuilder buf;

      for (S theory : names)

        buf.append(getTheory(theory) + "\n");

      ret reverseLookup(aiMap, ai) + " / " + quote(ai.theory) + "\n" + slackSnippet(buf);

    }

  }

  if "test ai * *" exceptionToUser {

    S name = m.unq(0), input = m.unq(1);

    AI ai = aiMap.get(name);

    if (ai == null) ret format("AI * not found", name);

    S answer = queryAI(name, input, nlParse(input), true);

    S x = answer + "\n" + slackSnippet((L) get(prolog, "log"));

    prolog = null;

    ret x;

  }

  if "time ai * *" exceptionToUser {

    S name = m.unq(0), input = m.unq(1);

    AI ai = aiMap.get(name);

    if (ai == null) ret format("AI * not found", name);

    S answer;

    time {

      answer = queryAI(name, input, nlParse(input), false);

    }

    S x = answer + "\n" + lastTiming() + " ms";

    prolog = null;

    ret x;

  }

  if "ai program *" exceptionToUser {

    S name = m.unq(0);

    AI ai = aiMap.get(name);

    if (ai == null) ret format("AI * not found", name);

    makeProlog(name, ai, false);

    S x = cast call(prolog, "showProgram");

    prolog = null;

    ret x;

  }

  // do the job

  Lisp input = null;

  for (S name : aiMap.keySet()) pcall {

    AI ai = aiMap.get(name);

    if (!ai.enabled) continue;

    if (input == null)

      input = nlParse(s);

    S answer = queryAI(name, s, input, false);

    prolog = null; // clean up prolog interpreter

    if (nempty(answer)) {

      callOpt(getMainBot(), "postAs", name);

      if ((ai.icon == null || ai.iconFetched < now()-(empty(ai.icon) ? 1 : 24)*60*60*1000) && canGetIcons()) {

        if (ai.icon == null) ai.icon = ""; // for safety if request fails

        ai.iconFetched = now();

        pcall { makeIcon(name, ai); }

        save("aiMap");

      }

      if (nempty(ai.icon))

        callOpt(getMainBot(), "botIcon", ai.icon);

      ret answer;

    }

  }

}}

static boolean makeProlog(S name, AI ai, boolean logOn) {

  L<S> theoryNames = getTheoryNames(name, ai);

  if (empty(theoryNames)) ret false;

  prolog = call(prologBot(), "newProlog", theoryNames, logOn);

  ret true;

}

// input = nlParse(s)

static S queryAI(S name, S s, Lisp input, boolean logOn) {

  AI ai = aiMap.get(name);

  if (!makeProlog(name, ai, logOn)) ret null;

  set(prolog, "outTheory", name + ".data");

  //S in = "user says " + nlUnparse(input, false);

  /*call(prolog, "addClause", in);

  S question = "say $x";*/

  S question = "[think [user says " + nlUnparse(nlEscapeVariables(input), false) + "]] and [say $x]";

  Map<S, Lisp> solution = cast quickImport(call(prolog, "solve", question));

  if (solution != null) {

    print("SOLUTION: " + structure(solution));

    Lisp x = solution.get("$x");

    if (x != null)

      ret nlUnparse(x);

  }

  ret null;

}

static L<S> getTheoryNames(S name, AI ai) {

  new L<S> l;

  l.add(name + ".data");

  if (equipWithSigned)

    l.add("signedstefan");

  S theory = getTheory(ai.theory);

  if (theory == null) ret litlist();

  // hack to make directly linked theories work

  L<S> tok = codeTokens(snlTok(theory));

  if (eq(get(tok, 0), "if") || eq(get(tok, 1), "if"))

    l.add(ai.theory);

  else {

    Lisp t = nlParse(theory);

    for (Lisp x : t.args)

      if (neq(x.head, ","))

        l.add(unquote(x.head));

  }

  ret l;

}

static O prologBot() {

  ret getBot("#1002841");

}

static S getTheory(S name) {

  ret (S) callOpt(getBot("#1002762"), "getTheoryOpt", name);

}

static boolean canGetIcons() {

  ret getBot("#1002511") != null;

}

static void makeIcon(S name, AI ai) {

  print("Making icon for AI: " + name);

  S url = cast call(getBot("#1002511"), "findImageNoShorten", name);

  if (nempty(url)) ai.icon = url;

}