!752

static PersistentMap<S, S> map;

static new HashSet<S> joiners;

static PersistentMap<S, S> splitters;

p {

  map = new PersistentMap("map");

  splitters = new PersistentMap("splitters");

  load("joiners");

}

static S dialog(S snl, S line) {

  new Map<S, Lisp> m;

  Lisp input = snlToTree(line);

  if (snlMatch("A < says < i < love < *", input, m))

    ret "oh < that < is < nice";

  if (snlMatch("A < says < i < hate < *", input, m))

    ret snlApply("? < why < do < you < hate < *", m);

  ret line;

}

synchronized static S answer(S s) {

  new Matches m;

  print("1002700 user=" + getUserName() + " attn=" + attn() + ", dedicated=" + dedicated());

  if (!attn()) ret null;

  if "are we dedicated"

    ret yn(dedicated());

  if "add joiner * *" {

    S j = preSimplify(m.unq(0) + " " + m.unq(1));

    if (joiners.contains(j))

      ret format("Joiner * exists", j);

    joiners.add(j);

    save("joiners");

    ret format("OK, joiner * added", j);

  }

  if "add splitter * = * *" {

    S a = preSimplify(m.unq(0));

    S b = preSimplify(m.unq(1) + " " + m.unq(2));

    S old = splitters.get(a);

    if (eq(old, b))

      ret format("Splitter * => * exists", a, b);

    splitters.put(a, b);

    ret format("OK, splitter * => * added" + (old != null ? " (old: " + structure(old) + ")" : ""), a, b);

  }

  if (!dedicated()) ret null;

  exceptionToUser {

    /*if (isSNL(s))

      ret "SNL";*/

    s = preSimplify(s);

    S snl = map.get(s);

    S snlSource = "map";

    if (snl == null) {

      snlSource = "naive";

      snl = naiveSNL(s);

    }

    print("1002700: got snl");

    S user = getUserName();

    if (user == null)

      user = master() ? "master" : "user";

    //user = user.replaceAll("[0-9]", "");

    S line = snlSimplifyBrackets(user + " < says < [" + snl + "]");

    print("1002700: calling dialog, line = " + line + ", user=" + user + ", snl=" + snl);

    S answer = dialog(snl, line);

    print("1002700: answer=" + answer);

    ret answer;

  }

}

//static L<S> keepPunctuation = litlist("*", "<", ">", "[", "]", "?", "!", ":", "@");

static L<S> tokensForSNL(S s) {

  L<S> tok = nlTok(s);

  //ret codeTokensOnly(dropPunctuationExcept(tok, keepPunctuation));

  ret codeTokensOnly(tok);

}

static synchronized S naiveSNL(S s) {

  print("Input: " + s);

    s = preSimplify(s);

  L<S> l = tokensForSNL(s);

  print("Tokens: " + structure(l));

  processJoiners(l);

  processSplitters(l);

  addArrows(l);

  ret join(" ", l);

}

// just a preprocessing for NL (does not generate SNL)

static S preSimplify(S s) {

  ret join(" ", codeTokensOnly(/*wordTokensToLowerCase*/(nlTok(s))));

}

static void processJoiners(L<S> l) {

  for (int i = 0; i < l(l)-1; i++) {

    S x = l.get(i) + " " + l.get(i+1);

    if (joiners.contains(x)) {

      l.set(i, x);

      l.remove(i+1);

      --i;

    }

  }

}

static void processSplitters(L<S> l) {  

  for (int i = 0; i < l(l); i++) {

    S x = splitters.get(l.get(i));

    if (x != null) {

      L<S> tokens = tokensForSNL(x);

      l.remove(i);

      l.addAll(i, tokens);

      i += l(tokens)-1;

    }

  }

}

static void addArrows(L<S> l) {

  for (int i = 0; i < l(l)-1; i++) {

    if (isWord(l.get(i)) && isWord(l.get(i+1)))

      l.add(++i, "<");

  }

}

static boolean isWord(S s) {

  if (empty(s)) ret false;

  if (isQuoted(s)) ret true;

  char c = s.charAt(0);

  ret Character.isLetter(c) || c == '\'';

}

static boolean isSNL(S s) {

  L<S> tok = javaTok(s);

  ret tok.contains("<") || tok.contains("[");

}

static S snlSimplifyBrackets(S s) {

  ret snlFromTree(snlToTree(s));

}