// A naive suffix tree implementation
sclass SuffixTree {
  Node root;
  S fullText;
  int nodeCount;
  
  Comparator<IFirstChar> childComparator = (a, b) -> a.firstCharOrMinus1()-b.firstCharOrMinus1();
  new DummyNode dummyNode;
  
  sinterface IFirstChar {
    int firstCharOrMinus1();
  }
  
  sclass DummyNode implements IFirstChar {
    int firstChar;
    
    public int firstCharOrMinus1() { ret firstChar; }
  }

  sclass Node implements IFirstChar {
    Substring text;
    CompactTreeSet<IFirstChar> children; // actually, <Node>
    IntBuffer positions;

    *() {}
    *(Substring *text) {}
    
    void addPosition(int i) {
      if (positions == null) positions = new IntBuffer;
      positions.add(i);
    }
    
    void addChild(SuffixTree tree, Node n) {
      if (children == null) children = makeEmptyChildrenSet(tree);
      children.add(n);
    }
    
    CompactTreeSet<IFirstChar> makeEmptyChildrenSet(SuffixTree tree) { ret new CompactTreeSet<>(tree.childComparator); }
    
    public int firstCharOrMinus1() {
      ret charToIntOrMinus1(text);
    }
    
    Node getChild(SuffixTree tree, int c) {
      if (children == null) null;
      tree.dummyNode.firstChar = c;
      ret (Node) children.find(tree.dummyNode);
    }
  }

  *() {}
  *(S *fullText) {
    root = new Node(Substring(fullText, 0, 0));
    ++nodeCount;
    for i over fullText: {
      addSuffix(Substring(fullText, i), i);
      if (((i+1) % 1000000) == 0)
        print((i+1) + " suffixes added (" + nNodes(nodeCount) + ")");
    }
  }

  void addSuffix(Substring s, int position) {
    Node node = root;
    
    while (!empty(s)) {
      int _n = lCommonPrefix_CharSequence(node.text, s);
      s = s.substring(_n);
      if (_n >= l(node.text)) { // node text exhausted
        if (empty(s)) { // pattern also exhausted - done
          node.addPosition(position);
          ret;
        } else {
          Node n = node.getChild(SuffixTree.this, charToIntOrMinus1(s));
          if (n == null) {
            n = new Node(s);
            ++nodeCount;
            n.addPosition(position);
            node.addChild(SuffixTree.this, n);
            ret;
          } else
            node = n;
        }
      } else { // node text not exhausted
        // split node. first, move all the node's vitals to a new node nOld
        Node nOld = new Node(node.text.substring(_n));
        ++nodeCount;
        nOld.positions = node.positions;
        node.positions = null;
        nOld.children = node.children;
        node.children = null;
        node.text = node.text.substring(0, _n);
        node.addChild(SuffixTree.this, nOld);

        // now add a new node
        Node nNew = new Node(s);
        ++nodeCount;
        nNew.addPosition(position);
        node.addChild(SuffixTree.this, nNew);
        ret;
      }
    }
  }

  public L<Int> indicesOf(S pattern) {
    new IntBuffer out;
    getIndicesOf(out, root, pattern, 0);
    ret out.asVirtualList();
  }
  
  void getIndicesOf(IntBuffer out, Node node, S pattern, int iPattern) {
    int lPattern = l(pattern);
    while true {
      int n = lCommonPrefix_CharSequence(node.text, Substring(pattern, iPattern));
      iPattern += n;
      if (iPattern >= lPattern) break; // pattern exhausted - done
      if (n < l(node.text)) ret; // mismatch, exit
      Node child = node.getChild(SuffixTree.this, charAtAsIntOrMinus1(pattern, iPattern));
      if (child != null) continue with node = child;
      ret;
    }
    
    collectPositions(out, node);
  }
  
  L<Int> getPositions(Node node) {
    new IntBuffer out;
    collectPositions(out, node);
    ret out.asVirtualList();
  }
  
  void collectPositions(IntBuffer out, Node node) {
    if (node == null) ret;
    out.addAll(node.positions);
    fOr (IFirstChar n : node.children)
      collectPositions(out, (Node) n);
  }
  
  void printMe() {
    printNode("", "", root);
  }
  
  void printNode(S indent, S pre, Node node) {
    print(indent + pre + quote(shorten(20, node.text)) + (empty(node.positions) ? "" : " " + node.positions));
    fOr (IFirstChar _n : node.children) {
      Node n = cast _n;
      printNode(indent + "  ", "[" + (empty(n.text) ? "end" : quote(n.text.charAt(0))) + "] ", n);
    }
  }
  
  ItIt<Node> allNodes() {
    new L<Iterator<Node>> stack;
    stack.add(iteratorLL(root));
    ret iteratorFromFunction_if0(() -> {
      while (nempty(stack)) {
        if (!last(stack).hasNext())
          popLast(stack);
        else {
          Node n = last(stack).next();
          stack.add((Iterator) iterator(n.children));
          ret n;
        }
      }
      null;
    });
  }
}