!752

answer {
  if (!attn()) ret null;
  
  s = s.trim();
  if (s.startsWith("snl ")) exceptionToUser {
    S input = dropPrefix("snl ", s).trim();
    Explain e = snlParse(input);
    if (e == null) ret "No parse";
    
    //L<S> classes = getClasses(e);
    //ret "Top classes: " + structure(classes);
    
    L<Explain> parts = topParts(e);
    
    L<S> topOperators = getOperators(parts);

    ret "Top parts: " + structure(mapString(parts))
     + ". Top operators: " + structure(topOperators);
  }
}

static L<S> mapString(L<Explain> e) {
  new L<S> l;
  for (Explain ex : e) l.add(ex == null ? "null" : ex.string());
  ret l;
}

static L<Explain> topParts(Explain e) {
  if (e == null) ret litlist();
  L<S> classes = getClasses(e);
  //ret "Classes: " + structure(classes);
  if (classes.contains("juxta")) {
    Explain juxta = descend(e, "juxta");
    L<Explain> parts = scanJuxta(juxta);
    if (allAre(parts, "subword")) // sentences!
      ret topParts(parts);
    else
      ret litlist(juxta); // it's actually one sentence
  } /*else if (classes.contains("subword"))
    ret descend(e, "subword");*/
  else
    ret litlist(e); // just return whatever we have as a top part
}

static L<Explain> topParts(L<Explain> list) {
  new L<Explain> l;
  for (Explain e : list)
    l.addAll(topParts(e));
  ret l;
}

static L<Explain> scanJuxta(Explain e) {
  if (isA(e, "juxta")) {
    Explain juxta = descend(e, "juxta");
    Explain a = juxta.sub(0), b = juxta.sub(1);
    ret concatLists(scanJuxta(a), scanJuxta(b));
  } else
    ret litlist(e);
}

static L<S> getClasses(Explain e) {
  new L<S> l;
  while (e != null) {
    l.add(e.className());
    if (l(e.subs) == 1)
      e = e.sub(0);
    else
      break;
  }
  ret l;
}

static Explain castTo(Explain e, S className) {
  ret descend(e, className);
}

static Explain descend(Explain e, S className) {
  new L<S> l;
  while (e != null) {
    if (eq(e.className(), className))
      ret e;
    if (l(e.subs) == 1)
      e = e.sub(0);
    else
      break;
  }
  ret null;
}

static boolean isA(Explain e, S className) {
  ret getClasses(e).contains(className);
}

static boolean allAre(L<Explain> l, S className) {
  for (Explain e: l)
    if (!isA(e, className))
      ret false;
  ret true;
}

static boolean anyAre(L<Explain> l, S className) {
  for (Explain e: l)
    if (isA(e, className))
      ret true;
  ret false;
}

static L<S> getOperators(L<Explain> parts) {
  new L<S> l;
  for (Explain e : parts)
    l.add(makeOperator(e));
  ret l;
}

static S makeOperatorFromJuxta(L<Explain> parts) {
  new L<S> l;
  int i = 0;
  for (Explain e : parts) {
    //print("Operator part " + (++i) + ": " + e.string() + " / " + structure(getClasses(e)));
    
    if (!isA(e, "subword") && isA(e, "idword"))
      l.add(e.string());
    else
      l.add("*");
  }
  ret join(" ", l);
}

static L<Explain> getJuxtaArgs(L<Explain> parts) {
  new L<Explain> l;
  int i = 0;
  for (Explain e : parts)
    if (!isA(e, "subword") && isA(e, "idword")) {
      // operator part, skip
    } else
      l.add(e);
  ret l;
}

static S makeOperator(Explain e) {
  if (isA(e, "realarrow"))
    ret descend(e, "realarrow").sub(0).string() + " *";
  else if (isA(e, "juxta")) {
    L<Explain> j = scanJuxta(e);
    //print("scanJuxta => " + structure(j));
    ret makeOperatorFromJuxta(j);
  } else
    ret e.string();
}

static Lisp getTree(Explain e) {
  print("getTree " + structure(getClasses(e)));
  
  if (isA(e, "realarrow")) {
    print("realarrow");
    Explain a = castTo(e, "realarrow");
    ret lisp("<", getTree(a.sub(0)), getTree(a.sub(1)));
  }
  
  if (isA(e, "realarrowr")) {
    print("realarrowr");
    Explain a = castTo(e, "realarrowr");
    ret lisp(">", getTree(a.sub(0)), getTree(a.sub(1)));
  }
  
  if (isA(e, "square")) {
    print("square");
    Explain a = castTo(e, "square");
    ret lisp("[]", getTree(a.sub(0)));
  }
  
  if (isA(e, "round")) {
    Explain a = castTo(e, "round");
    ret lisp("()", getTree(a.sub(0)));
  }
  
  if (isA(e, "juxta")) {
    Explain juxta = descend(e, "juxta");
    L<Explain> parts = scanJuxta(juxta);
    
    print("juxta " + e.string());
    
    if (anyAre(parts, "subword")) {
      L<Explain> args = getJuxtaArgs(parts);
      Lisp l = lisp(makeOperatorFromJuxta(parts));
      for (Explain arg : args)
        l.add(removeBrackets(getTree(arg)));
      ret l;
    }
    
    print("  no subwords");

    // no subwords, fall back to simple string
  }
  
  ret lisp(e.string());
}

static Lisp removeBrackets(Lisp l) {
  if (eq(l.head, "[]"))
    ret l.get(0);
  ret l;
}