!7

static Map<S, Set<S>> theSet;
static new LinkedHashSet<Updatable> allObjects;
static long changes;
static new MultiMap<S, Pair<S>> groupingsByA;
static new MultiMap<S> subClasses;

static S groupings = [[
  <preposition> + <noun> = <adverbial_phrase>
  <determiner> + <noun> = <noun>
  <adverb> + <verb_phrase> = <verb_phrase>
  <verb> = <verb_phrase>
  <verb> + <noun> = <verb_phrase>
  <noun> + <verb_phrase> = <sentence>
  <adverbial_phrase> + <sentence> = <sentence>
]];

sclass Updatable {
  void update {}
  
  void setField(S field, O value) {
    if (eq(get(this, field), value)) ret;
    set(this, field, value);
    change();
  }
}

sclass Expectation {
  S ifClass;
  Runnable action;
  
  *() {}
  *(S *ifClass, Runnable *action) {}
}

sclass Word extends Updatable {
  S text; // or null if unknown
  new LinkedHashSet<Word> prev;
  new LinkedHashSet<Word> next;
  L<Word> constituents; // if group
  new L<Expectation> expectations;
  new L<Expectation> fulfilledExpectations;
  new TreeSet<S> classes;
  int classesConvertedToTraits;
  new LinkedHashSet<Word> groups; // I am part of
  new L<Trait> traits;
  
  void update {
    // Add direct word classes
    if (text != null)
      for (S c : reverseLookupInMapToSets(theSet, text))
        addClass(c);
    
    // Make text for group  
    if (isGroup() && text == null) {
      L<S> l = collect(constituents, 'text);
      if (!anyNull(l)) setField(text := joinWithSpace(l));
    }
    
    // Process expectations
    for (Expectation e : cloneList(expectations)) {
      //print("Checking expected class " + e.ifClass);
      if (classes.contains(e.ifClass)) {
        moveElementFromCollectionToCollection(e, expectations, fulfilledExpectations);
        change();
        callF(e.action);
      }
    }
    
    if (l(classes) > classesConvertedToTraits) {
      for (fS c : dropFirst(classesConvertedToTraits, classes))
        addTraitsForClass(c);
      classesConvertedToTraits = l(classes);
    }
    
    for (Trait t : iterateListConcurrently(traits))
      t.update();
  }
  
  bool isGroup() { ret constituents != null; }
  
  bool addClass(S c) {
    if (!classes.add(c)) false;
    change();
    long n;
    do {
      n = changes;
      // optimizable
      for (S d : iterateListConcurrently(asList(classes)))
        for (S e : subClasses.get(d))
          if (classes.add(e)) change();
    } while (changes != n);
    true;
  }
  
  void addExpectation(Expectation e) {
    //print("addExpectation " + e);
    expectations.add(e);
    change();
  }
  
  void addTraitsForClass(S c) {
    for (PairS p : groupingsByA.get(c))
      addTrait(LinkWithTo(p.a, p.b));
  }
  
  void addTrait(Trait t) {
    set(t, w := this);
    traits.add(t);
  }
}

static Word makeGroup(Word a, Word b, S newClass) {
  //print("makeGroup " + a.text + " / " + b.text);
  L<Word> list = ll(a, b);
  
  // look for existing group
  for (Word g : a.groups)
    if (eq(g.constituents, list)) {
      if (g.addClass(newClass))
        print("Added class " + newClass + " to existing group: " + a.text + " + " + b.text);
      ret g;
    }
      
  // new group
  print("Making group " + newClass + " " + a.text + " + " + b.text);
  print("  prev=" + sfu(collect(a.prev, 'text)));
  print("  next=" + sfu(collect(b.next, 'text)));
  new Word g;
  allObjects.add(g);
  g.addClass(newClass);
  g.constituents = list;
  for (Word w : list)
    w.groups.add(g);
  g.prev.addAll(a.prev);
  g.next.addAll(b.next);
  for (Word prev : a.prev) prev.next.add(g);
  for (Word next : b.next) next.prev.add(g);
  ret g;
}

sclass Trait extends Updatable {
  Word w;
}

sclass LinkWithTo extends Trait {
  S linkWith, linkTo; // classes
  int expectationsSentToNext;
  
  *() {}
  *(S *linkWith, S *linkTo) {}
  
  void update {
    if (l(w.next) > expectationsSentToNext) {
      for (final Word next : dropFirst(expectationsSentToNext, w.next))
        next.addExpectation(Expectation(linkWith, r {
          makeGroup(w, next, linkTo)
        }));
      expectationsSentToNext = l(w.next);
    }
  }
}

p-exp {
  fS sentence = "In the movies Dracula always wears a cape";
  L<S> rawWords = printStruct(words(sentence));
  
  theSet = ai_englishWordCategoriesWithElements();
  parseGroupings();
  
  new L<Word> words;
  for (S w : rawWords)
    words.add(nu(Word, text := w));
  for (int i = 0; i < l(words)-1; i++)
    linkWords(words.get(i), words.get(i+1));
  //printStruct(first(words));
  
  addAll(allObjects, words);
  long lastChanges;
  do {
    lastChanges = changes;
    print(n2(changes, "change"));
    for (Updatable w : cloneList(allObjects))
      w.update();
  } while (lastChanges != changes);
  
  //for (Word w : words) printStruct(cloneForPrinting(w));
  for (Word w : words) print("  " + textAndClasses(w));
  print();
    
  L<Word> groups = [Word w : instancesOf(Word, allObjects) | w.constituents != null];
  print();
  print(n2(groups, "group"));
  for (Word g : groups) {
    print("Group: " + textAndClasses(g));
    print("  " + grouped(g));
  }
    
  assertNempty([Word g : groups | eq(g.text, sentence) && g.classes.contains("<sentence>")]);
  print("OK");
}

sS textAndClasses(Word w) {
  ret w.text + " (" + joinWithComma(w.classes) + ")";
}

svoid linkWords(Word a, Word b) {
  a.next.add(b);
  b.prev.add(a);
}

static O cloneForPrinting(Word w) {
  ret cloneWithoutFields(w, 'prev, 'next, 'constituents);
}

svoid change() { ++changes; }

svoid parseGroupings() {
  for (S s : tlft(groupings)) {
    L<S> tok = javaTokWithAngleBracketsC(s);
    if (l(tok) == 5)
      groupingsByA.put(tok.get(0), pair(tok.get(2), tok.get(4)));
    else if (l(tok) == 3)
      subClasses.put(tok.get(0), tok.get(2));
  }
}

sS grouped(Word g) {
  if (g.constituents == null) ret g.text;
  new L<S> l;
  for (Word w : g.constituents)
    l.add(curlyBraceIfMultipleTokens(grouped(w)));
  ret joinWithSpace(l);
}