sclass RuleEngine {

  new LL<S> facts; // stores code token parses

  Map<S, O> phrasesWordTree = wordTree();

  Clusters<S> clusters = ciClusters();

  new Prolog prolog;

  *(S program) {

    this("", program);

  }

  *(S program, bool showStuff) {

    if (showStuff) showStuff();

    runProgram(program);

  }

  *(S inspiration, S program) {

    runProgram(inspiration, program);

  }

  void runProgram(S program) {

    runProgram("", program);

  }

  void runProgram(S inspiration, S program) {

    for (S s : tlftj(inspiration))

      addFact("inspired " + quote(s));

    L<S> programLines = tlftj(program);

    //pnl(program);

    //print();

    for (S s : programLines) {

      Pair<S, L<S>> p = parseFunctionCall(s);

      if (p != null) {

        //print("Function call: " + sfu(p));

        S f = p.a;

        L<S> args = p.b;

        if (eqic(f, "assert"))

          assertFact(getSingleton(p.b));

        else if (swic(f, "assert_")) {

          if (eqic(f, "assert_answer"))

            assertAnswer(unquote(first(args)), unquote(second(args)));

          else if (eqic(f, "assert_parse"))

            assertParse(args);

          else

            fail("Unknown assertion function: " + f);

        } else if (eqic(f, "fact_question_answer_upperCaseVars"))

          prolog.code(

            dontPrint("if [" + toProlog(unquote(first(args))) + "] and ["

            + toProlog(unquote(second(args))) + "] then [answer is ["

            + toProlog(unquote(third(args))) + "]]"));

        continue;

      }

      L<S> tok = javaTok(s);

      if (eqic(second(tok), "assert")) {

        assertFact(join(dropFirst(3, tok)));

        continue;

      }

      int i = indexOfSubListLL(tok, "-", "", ">");

      if (i >= 0) {

        L<S> left = subList(tok, 1, i-1);

        int j = indexOf(left, "+");

        if (j >= 0) {

          prolog.code(

            print("if [" + toProlog(joinSubList(left, 0, j-1))

            + "] and [" + toProlog(joinSubList(left, j+2)) + "] then ["

            + toProlog(joinSubList(tok, i+4)) + "]"));

          continue;

        }

      }

      tok = codeTokens(tok);

      if (eqic(getSingletonOpt(tok), "rewrite"))

        continue with addFactsFromProlog(prolog.rewriteAndSave());

      if (l(tok) == 2 && isIdentifier(first(tok)) && isQuoted(second(tok)))

        if (eq(first(tok), "phrase")) {

          addPhrase(unquote(second(tok)));

          continue;

        }

      if (l(tok) == 3 && eq(second(tok), "=")) {

        ciClusters_add(clusters,

          addPhrase(unquote(first(tok))),

          addPhrase(unquote(third(tok))));

        continue;

      }

      addFact(s);

    }

  }

  void printStuff {

    printAsciiHeading("Facts");

    pnlStruct(facts);

    print();

    print("Clusters: " + sfu(clusters));

    print("Phrases: " + sfu(phrasesWordTree));

  }

  L<S> parseFact(S s) {

    L<S> tok = map toLowerIfIdentifier(javaTokWithAngleBracketsC(/*dropPunctuation*/(s)));

    ret nempties(translateUsingWordTreeC(tok, phrasesWordTree));

  }

  void assertFact(S fact) {

    if (contains(facts, parseFact(fact)))

      print("OK fact: " + fact);

    else

      print("FAILED fact assert: " + fact);

  }

  void assertAnswer(S q, S a) {

    Prolog p = new(prolog);

    //p.showStuff = true;

    p.code(dontPrint("to prolog: ", squareBracket(toProlog(q))));

    L<Lisp> out = p.rewrite();

    //print("Got " + l(out) + " statement(s)");

    L<S> lines = map nlUnparse(out);

    L<S> answers = startingWithEndingWith_drop(lines, "answer is [", "]");

    if (l(answers) == 1 && eqic(first(answers), a))

      print("OK answer: " + q + " -> " + a);

    else {

      pnl(map nlUnparse(out));

      print("FAIL answer: " + q + " -> " + first(answers) + " - expected: " + a);

    }

  }

  S addPhrase(S s) {

    wordTreeAdd(phrasesWordTree, javaTokC(s), s);

    ret s;

  }

  void addFact(S s) {

    L<S> tok = parseFact(s);

    facts.add(tok);

    prolog.code(dontPrint("to prolog: ", squareBracket(factToProlog(tok))));

  }

  void assertParse(L<S> args) {

    args = unquoteAll(args);

    S s = first(args);

    L<S> parsed = parseFact(s);

    L<S> expected = dropFirst(args);

    if (eq(parsed, expected))

      print("OK parse: " + s + " -> " + sfu(parsed));

    else

      print("FAILED parse: " + s + " -> " + sfu(parsed) + " - expected: " + sfu(expected));

  }

  S toProlog(S s) {

    L<S> tok = parseFact(upperCaseVarsToDollarVars(s));

    ret factToProlog(tok);

  }

  S factToProlog(L<S> tok) {

    ret joinWithSpace(map ruleEngine_tokenToProlog(tok));

  }

  void addFactsFromProlog(L<Lisp> l) {

    addFacts(printAll(map nlUnparse(l)));

  }

  void addFacts(L<S> l) {

    for (S s : unnull(l)) addFact(s);

  }

  RuleEngine showStuff() {

    prolog.showStuff = true;

    this;

  }

}