!759

static S theme =

  //"Color Showing Bot";

  "Yo robot";

//include #1003412 // LooseBot v4

!include #1003413 // LooseBot v5

!include #1003407 // OccTree2

static OccTree2 tree, botTree;

static O makeBot;

sbool walkTree_debug;

sbool useAdapter = true;

p {

  L<Dialog> dialogs = loadDialogs(theme);

  tree = goodDialogs2occTree2(dialogs);

  botTree = goodDialogs2occTree2(dialogs);

  printOccTree2(botTree);

  print("Tree size: " + tree.size() + ", bot tree size: " + botTree.size());

  makeBot = func { new LooseBot(botTree, func { new WordAdapter }) };

  //walkTree_debug = true;

  try {

    walkTree();

  } catch e {

    print("Engine not working, abort.");

    printStackTrace(e);

    ret;

  }

  print("Tree walked! " + inputFed + " -> " + outputGot);

  int origSize = botTree.size()-1;

  print("Engine works! Trying to shrink the tree.");

  while (canShrinkTree()) {

    print("Tree shrunk, trying it again.");

  }

  int newSize = botTree.size()-1;

  printOccTree2(botTree);

  if (newSize < origSize) {

    long percent = newSize == 0 ? 9999 : round(origSize*100.0/newSize);

    print("Done shrinking tree (" + origSize + " -> " + newSize + " entries - " + percent + "% shrinkage!)");

  } else

    print("Tree unshrinkable.");

}

static int inputFed, outputGot;

sbool canShrinkTree() {

  L<OccTree2> leaves = botTree.allLeaves();

  print("Leaves found: " + l(leaves));

  bool anyChange = false;

  for (OccTree2 leaf : leaves) {

    print("Trying to remove leaf: " + leaf.e + " (level " + leaf.level() + ")");

    Reattach reattach = removeLeaf(leaf);

    //printOccTree2(botTree);

    if (canWalkTree()) {

      print("Leaf removed successfully!");

      anyChange = true;

    } else

      reattach.reattach();

  }

  ret anyChange;

}

sclass Reattach {

  OccTree2 node, leaf;

  int idx;

  void reattach() {

    leaf.parent = node;

    node.next.add(idx, leaf);

  }

}

static Reattach removeLeaf(OccTree2 leaf) {

  new Reattach r;

  r.leaf = leaf;

  r.node = leaf.parent;

  r.idx = leaf.parent.next.indexOf(leaf);

  leaf.parent.next.remove(r.idx);

  leaf.parent = null;

  ret r;

}

sbool canWalkTree() {

  ret canWalkTree(tree, call(makeBot));

}

sbool canWalkTree(OccTree2 tree, O bot) {

  try { walkTree(tree, bot); true; } catch e {

    if (walkTree_debug)

      printStackTrace(e);

    ret false;

  }

}

svoid walkTree() {

  walkTree(tree, call(makeBot));

}

svoid walkTree(OccTree2 tree, O bot) {

  if (tree.isLeaf())

    assertNull(getOutput(bot));

  else

    for (E e : tree.followUpKeys()) {

      if (!contains(ll("good", "bad"), e.state)) {

        bool input = isInput(e);

        if (walkTree_debug)

          print((input ? "FEED " : "CHECK ") + structure(e));

        if (input) {

          assertNull(getOutput(bot));

          feed(bot, e);

        } else

          checkOutput(e, getOutput(bot));

        walkTree(tree.followUp(e), bot);

        if (walkTree_debug)

          print("Rewind " + structure(e));

        rewind(bot);

      }

    }

}

svoid rewind(O bot) {

  call(bot, "rewind"); // rewind one step

}

svoid feed(O bot, E e) {

  call(bot, "take", e);

  ++inputFed;

}

static E getOutput(O bot) {

  E e = cast call(bot, "getSingleOutput");

  if (e != null) ++outputGot;

  ret e;

}

svoid checkOutput(E e, E output) {

  assertEquals(e, output);

}

static bool isInput(E e) {

  ret e.q()

    //|| (e.state() && !matchStart("bot", e.state));

    ;

}