// used e.g. to solve the "Pizza with..." example

sclass Gazelle_MiniEngine1 {

  int minScore = 50; // minimal percentage score for rule matching

  bool printMappings, printGroupedData, printRejectedVars; // what to debug-print

  // some parsing and formatting macros

  F1<S> formatForUser = func(S s) -> S { ai_superSimpleVerbCorrector(tok_dropCurlyBrackets(s)) };

  F1<S, LS> parse = func(S s) -> LS { codeTokens_lazy_uncurly(javaTokWithBrackets_cached(s)) };

  // syntactic sugar for the macros

  S formatForUser(S s) { ret callF(formatForUser, s); }

  LS parse(S s) { ret callF(parse, s); }

  // rules are in => out + variables

  LPair<S> rules;

  Map<PairS, Set<S>> ruleVariables = new Map;

  // returns solutions

  // data = section "rules" and section "input" (input statements)

  MultiMap<S> run(S _data) {

    // parse rules from _data

    S data = mapEachLine ai_groupSimplestNounPhrases(_data);

    if (printGroupedData) print(data);

    SS sections = asCIMap(minusSignsSections(data));

    rules = ai_findDoubleArrowRulesAsPairs(sections.get("Rules"));

    for (PairS rule : rules)

      ruleVariables.put(rule, ai_wordsInBothSidesOfPair_uncurly(rule));

    // process input statements from _data and record rewrites that don't end in "fail"

    printAsciiHeading("REASONING");

    new MultiMap<S> solutions;

    for (S input : tlft(sections.get("Input"))) {

      print("\nInput: " + tok_dropCurlyBrackets(input));

      temp tempIndent();

      for (Pair<S, Int> in : interpretations(input)) {

        print("\nInterpretation: " + formatForUser(in.a));

        Set<S> out = litciset();

        interpretRecursively(in.a, 5, out);

        if (!matchAny("fail", out))

          solutions.put(input, in.a);

      }

    }

    // print solutions

    printAsciiHeading("RESULTS");

    print(formatDoubleArrowPairs_horizontallyAligned(mapPairBoth(formatForUser, multiMapToPairs(solutions))));

    ret solutions;

  }

  void interpretRecursively(S input, int level, Set<S> out) {

    if (level <= 0) ret;

    LS interpretations = pairsA(interpretations(ai_groupSimplestNounPhrases(input)));

    temp tempIndent();

    for (S in : addAllAndReturnNew(out, interpretations)) {

      print(" => " + formatForUser(in));

      for (S s : lithashset(in, ai_superSimpleVerbCorrector(in)))

        interpretRecursively(s, level-1, out);

    }

  }

  LPair<S, Int> interpretations(S input) {

    LS tokI = parse(input);

    new LPair<S, Int> interpretations;

    for (PairS rule : rules) {

      LS tokR = parse(rule.a);

      final SS map = ciMapWithoutKeysEqualToValues(zipTwoListsToCIMap_strict(tokR, tokI));

      if (map == null) continue;

      // Found matching rule

      int score = l(tokR)-l(map);

      L<S> nonVars = withoutDollarVars(listMinusSet(keys(map), ruleVariables.get(rule)));

      if (printRejectedVars && nempty(nonVars)) print("Rejected vars: " + nonVars);

      if (nempty(nonVars)) score = 0;

      if (printMappings) print("  " + reverseMapCI_joinDuplicatesWithPlus(map) + " | " + rule.a);

      // Make consequence

      S c = rule.b;

      c = join(mapCodeTokens(javaTok(c), func(S s) -> S { getOrKeep_tryUncurlied(map, s) }));

      c = join(mapCodeTokens(javaTokWithBrackets(c), func(S s) -> S { getOrKeep_tryUncurlied(map, s) }));

      //c = javaTokWithBrackets_recursiveTransform(func(S s) -> S { getOrKeep(map, s) }, c);

      addPairIfBAtLeast(interpretations, c, ratioToIntPercent(score, l(tokR)), minScore);

    }

    ret interpretations;

  }

}