// adapters are immutable! (plus returns a modified clone)

abstract sclass Adapter {

  abstract bool canMatch(S in, S out);

  Adapter plus(S in, S out) { ret this; }

  S get(S in) { ret in; }

  double size() { ret 0; }

}

abstract sclass GenericAdapter {

  void modify(OccTree2 node) {}

}

// node in flight (+ optional adapter)

sclass InFlight {

  OccTree2 node;

  Adapter adapter;

  *(OccTree2 *node) {}

  *(OccTree2 *node, Adapter *adapter) {}

  E adapted() {

    // TODO: security when rewriting states

    ret adapter == null ? node.e : new E(adapter.get(node.e.text()), node.e.type());

  }

}

sclass LooseBot {

  sbool debug, repeat = true;

  OccTree2 tree;

  new L<InFlight> nodes;

  new L<L> rewindStack;

  O newAdapter;

  O grabber; // func(S -> E)

  GenericAdapter genericAdapter;

  // WordAdapter now default

  *(OccTree2 tree) { this(tree, func { new WordAdapter }); }

  // main constructor

  *(OccTree2 *tree, O *newAdapter) {

    expandEllipsis(tree);

  }

  *(S theme) { this(makeOccTree(theme)); }

  *(S theme, O newAdapter) { this(makeOccTree(theme), newAdapter); }

  Adapter makeAdapter() {

    ret newAdapter == null ? null : (Adapter) call(newAdapter);

  }

  void take(E in) {

    remember();

    // try starting over from beginning of tree too

    if (repeat) setAdd(nodes, new InFlight(tree, makeAdapter()));

    new L<InFlight> l;

    // try grabber

    if (grabber != null && in.q()) try {

      E grabbed = cast callFunction(grabber, in.text());

      if (grabbed != null) {

        if (debug)

          print("Grabber worked! " + in.text() + " => " + grabbed);

        // make a mini tree with Q + A so it is matched in

        // next call to getSingleOutput()

        OccTree2 node = new OccTree2(in);

        node.next.add(new OccTree2(grabbed));

        l.add(new InFlight(node));

      } else

        if (debug)

          print("Grabber didnt't return anything. " + in.text());

    } catch e {

      if (debug) printStackTrace(e);

    }

    for (InFlight flight : nodes)

      for (OccTree2 n : flight.node.next) {

        if (genericAdapter != null)

          genericAdapter.modify(n);

        if (eq(n.e.type(), in.type()) && (flight.adapter != null

          ? flight.adapter.canMatch(n.e.text(), in.text())

          : matchE(n.e, in))) {

          l.add(new InFlight(n, flight.adapter == null ? null

            : flight.adapter.plus(n.e.text(), in.text())));

        }

      }

    nodes = l;

  }

  L<E> possibleNextInput() {

    new HashSet<E> l;

    if (repeat) l.add(tree.e);

    L<InFlight> ns = cloneList(nodes);

    if (repeat) setAdd(ns, new InFlight(tree, makeAdapter()));

    for (InFlight flight : ns)

      for (OccTree2 n : flight.node.next)

        l.add(new InFlight(n, flight.adapter).adapted());

    ret asList(l);

  }

  void remember() {

    if (rewindStack != null)

      rewindStack.add(cloneList(nodes));

  }

  E getSingleOutput() {

    remember();

    new L<InFlight> l;

    for (InFlight flight : nodes)

      for (OccTree2 n : flight.node.next)

        if (n.e.a() || isCommand(n.e))

          l.add(new InFlight(n, flight.adapter));

    if (empty(l)) { rewind(); null; }

    nodes = l;

    ret first(nodes).adapted();

  }

  void rewind() {

    nodes = popLast(rewindStack);

  }

  bool isCommand(E e) {

    ret e.state() && matchStart("bot", e.state);

  }

  void noRewind() {

    rewindStack = null;

  }

  bool matchE(E a, E b) {

    // standard NL matching

    ret eq(a.type(), b.type()) && match(a.text(), b.text());

  }

  S nodesToString(L<InFlight> nodes) {

    new L<S> l;

    l.add(n(l(nodes), "node"));

    for (InFlight flight : nodes) {

      l.add(str(flight.node.e));

      if (flight.adapter != null)

        l.add("  " + flight.adapter);

    }

    ret rtrim(fromLines(l));

  }

  S thoughts() {

    new L<S> l;

    l.add("Expecting input:\n");

    for (E e : possibleNextInput())

      if (e != null)

        l.add("  " + e);

    l.add("");

    l.add(nodesToString(nodes));

    if (rewindStack != null) {

      l.add("\nHistory\n");

      for (L<InFlight> nodes : reversedList(rewindStack))

        l.add(indent(nodesToString(nodes)));

    }

    ret fromLines(l);

  }

  LooseBot debugOn() {

    debug = true;

    ret this;

  }

}

sclass WordAdapter extends Adapter {

  new Map<S, S> wordMap;

  L<S> tok(S s) {

    ret nlTok2(dropPunctuation2(s));

  }

  bool canMatch(S in, S out) {

    L<S> t1 = tok(in), t2 = tok(out);

    ret l(t1) == l(t2);

  }

  Adapter plus(S in, S out) {

    L<S> t1 = tok(in), t2 = tok(out);

    if (l(t1) != l(t2)) ret this;

    WordAdapter a = cast nuObject(getClass());

    a.wordMap = cloneMap(wordMap);

    for (int i = 1; i < l(t1); i += 2) {

      S w1 = t1.get(i), w2 = t2.get(i);

      if (!eqic(w1, w2))

        // just overwrite - be flexible!

        a.wordMap.put(w1.toLowerCase(), w2.toLowerCase());

    }

    ret a;

  }

  S get(S s) {

    L<S> tok = nlTok2(s);

    for (int i = 1; i < l(tok); i += 2) {

      S w = lookupToken(tok.get(i));

      if (nempty(w))

        tok.set(i, w);

    }

    ret join(tok);

  }

  S lookupToken(S s) {

    ret wordMap.get(s.toLowerCase());

  }

  double size() {

    ret l(wordMap);

  }

  public S toString() {

    ret structure(wordMap);

  }

}

sclass WordAdapter2 extends WordAdapter {

  new Map<S, S> wordMap;

  L<S> tok(S s) {

    ret nlTok2(s);

  }

}