// should now be persistable
sclass RuleEngine2 {
  sclass SimplifyWithRule extends Rule {
    transient O _function; // function name or F1. can return S or LS
    bool isSplitRule; // splitter rather than simplifier
    bool callOnTree; // function takes GazelleTree rather than S
    
    O function() {
      if (_function == null) {
        gazelle_parseInstruction(this);
        assertNotNull(_function);
      }
      ret _function;
    }
  }
  
  abstract sclass QuickCheck {
    abstract bool check(S input);
  }
  
  sclass CicQuickCheck extends QuickCheck {
    S string;
    
    bool check(S input) { ret cic(input, string); }
  }
  
  sclass Rule {
    S globalID;
    LS in;
    S out;
    LS comments;
    Set<S> vars;
    L<GRuleLine> insWithType;
    LS outTypes;
    transient L inputMassagers; // func(S input) -> S for every in
    transient L checkerFunctions; // func(S input) -> SS for every in
    transient L matchers; // func(LS tokC, LS tokI, RuleEngine2_MatchedRule) -> SS for every in
    S text; // original text
    QuickCheck applicabilityQuickCheck;
    S purpose = "";
    Double qualityCutOff;
    bool avoidRecentlyUsedMappings;
    
    // (optional) massage the variable map after matching
    // L<func(SS varMap, LS tokCondition, LS tokInput, RuleEngine2_MatchedRule matched) -> SS newVarMap>
    L mapMassagers;

    S asText() {
      if (l(in) > 1 && eq(last(in), out))
        ret join(" \n+ ", dropLast(in)) + " \n+=> " + out;
      ret join(" \n+ ", in) + " \n=> " + out;
    }
    
    void addMapMassager(O massager) {
      if (massager != null) mapMassagers = addToOrCreateList(mapMassagers, massager);
    }
    
    void setInputMassager(int i, O massager) {
      inputMassagers = listSetWithCreate(inputMassagers, i, massager);
    }
    
    void setMatcher(int i, O matcher) {
      matchers = listSetWithCreate(matchers, i, matcher);
    }
    
    void setOutType(int i, S type) {
      outTypes = listSetWithCreate(outTypes, i, type);
    }
    
    S outType() { ret first(outTypes); }
    
    void parseGeneralComments() {
      purpose = gazelle_purposeFromComments(comments);
      pcall {
        S s = matchAny_firstGroup("quality cutoff = *", comments);
        if (s != null) qualityCutOff = parseDouble(s);
      }
      avoidRecentlyUsedMappings = cic(comments, "avoid recently used mapping");
    }
    
    toString {
      ret globalID + ": " + text;
    }
  } // end of class Rule
  
  int minScore = 50; // minimal percentage score for rule matching
  int maxLevel = 100, maxOutLines = 10000;
  new L<Rule> rules;
  bool printMappings, printGroupedData, printRejectedVars;
  Set<S> facts = ciSet();
  transient F2<S, S, O> callFunctionOnString = func(S function, S s) -> O { callAndMake(function, s) };
  bool hasHelpers;

  *() {}
  
  // probably not used anymore
  *(LPair<S> rulesWithComments) {
    for (PairS p : unnull(rulesWithComments))
      addRule(p.a, splitAtDoubleArrow_pair(p.a), p.b, null);
  }
  
  void copyRulesFrom(RuleEngine2 engine) {
    if (engine == null) ret;
    rules.addAll(engine.rules);
    hasHelpers = engine.hasHelpers;
  }
  
  void addRules2(L<T3S> rulesWithCommentsAndID) {
    new Matches m;
    for (T3<S> p : unnull(rulesWithCommentsAndID)) try {
      PairS p2 = splitAtDoubleArrow_pair(p.a);
      if (p2 != null)
        continue with addRule(p.a, p2, p.b, p.c);
      
      new SimplifyWithRule r;
      r.globalID = p.c;
      r.text = p.a;
      r.comments = lines(p.b);
      r.parseGeneralComments();
      S s = p.a;
      gazelle_parseInstruction(r);
      if (r._function == null) continue;
      rules.add(r);
    } catch e {
      printStackTrace("Exception parsing rule " + p.c, e);
    }
  }

  void addRule(S text, PairS rule, S comments, S globalID) {
    if (rule == null) ret;
    rule = ai_rule_pair_expandPlusArrow(rule);
    LS conditions = tok_splitAtPlusAtBeginningOfLine(rule.a);
    new Rule r;
    r.globalID = globalID;
    r.text = text;
    r.comments = lines(comments);
    r.parseGeneralComments();
    r.in = conditions;
    r.insWithType = map(conditions, func(S s) -> GRuleLine { GRuleLine(s, "standard") });
    
    // input massagers for "<anything>"
    
    for (int i = 0; i < l(r.in); i++) {
      S s = r.in.get(i);
      continue unless endsWith(s, "<anything>");
      if (eq(s, "<anything>"))
        r.checkerFunctions = listSetWithCreate(r.checkerFunctions, i, func(S s) -> SS { nempty(s) ? litmap() : null });
      else if (jmatch("* says: <anything>", javaTokWithBrackets(s))) {
        //print("Made input massager");
        r.setInputMassager(i, func(S s) -> S { new Matches m; ret jMatchStart("* says:", javaTokWithBrackets(s), m) ? m.get(0) + " says: <anything>" : s; });
      }
    }
    
    for (Matches m : getJMatches_all("expand *", r.comments))
      if (isQuoted(m.get(0))) {
        fS var = m.unq(0);
        for (int i = 0; i < l(r.in); i++)
          r.setMatcher(i, new O { SS get(LS tokC, LS tokI, RuleEngine2_MatchedRule matched) {
            if (eqic(nextToLast(tokC), var))
              tokI = tok_groupLastTokensToMatchPattern(tokI, tokC);
            ret zipCodeTokensToCIMap_strict_withoutEquals(tokC, tokI);
          }});
      }
    
    // "in = dialog" (probably not used anymore)
        
    if (jmatchAny(ll("in = dialog", "fact + event => replacement fact"), r.comments))
      for (int i = 0; i < l(r.insWithType); i++)
        r.insWithType.get(i).type = "dialog-" + (l(r.insWithType)-i);
        
    new Matches m;
    for (S s : r.comments) {
      if (jMatchStart("in * =", s, m) && isInteger($1)
        && (startsWith($2, 'statement) || eq($2, 'condition)))
        set(get(r.insWithType, parseInt($1)-1), type := $2);
      else if (jMatchStart("out * =", s, m) && isInteger($1))
        r.setOutType(parseInt($1)-1, $2);
      else if (jMatchStart("out = ", s, m))
        r.setOutType(0, m.rest());
      else if (jMatchStart("in * :", s, m) && isInteger($1)) {
        int i = parseInt($1)-1;
        S comment = m.rest();
        GRuleLine line = get(r.insWithType, i);
        if (line != null) {
          line.comments = addToOrCreateList(line.comments, comment);
          if (match("tokenize with *", comment, m))
            line.tokenizer = $1;
        }
      }
    }
    
    r.out = rule.b;
    r.vars = ai_wordsInBothSidesOfPair_uncurly(rule);
    rules.add(r);
  }
  
  /*
  LS addFacts(Collection<S> facts) {
    ret addAllAndReturnNew(this.facts, facts);
  }
  
  void addFact(S fact) { facts.add(fact); }
  
  void addAndInterpretFacts(Collection<S> facts) {
    addFacts(recursiveInterpretations(addFacts(facts)));
  }
  
  void processInput(S input) {
    print("\nInput: " + tok_dropCurlyBrackets(input));
    temp tempIndent();
    for (S in : interpretations(input)) {
      print("\nInterpretation: " + formatForUser(in));
      Set<S> out = litciset();
      interpretRecursively(in, 5, out);
    }
  }
  
  Set<S> recursiveInterpretations(S in) {
    ret recursiveInterpretations(ll(in));
  }
  
  Set<S> recursiveInterpretations(Iterable<S> in) {
    Set<S> inSet = asCISet(in);
    Set<S> out = litciset();
    new LinkedHashSet<S> queue;
    addAll(queue, inSet);
    while (l(out) < maxOutLines && nempty(queue)) {
      LS intp = interpretations(popFirst(queue));
      for (S i : intp)
        if (!inSet.contains(i) && !out.contains(i)) {
          out.add(i);
          queue.add(i);
          if (l(out) >= maxOutLines) break;
        }
    }
    ret out;
  }

  void interpretRecursively(S input, int level, Set<S> out) {
    if (level <= 0) ret;
    LS interpretations = interpretations(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);
    }
  }

  LS defaultParse(S s) {
    ret codeTokens_lazy_uncurly(javaTokNPunctuationWithBrackets_cached(s));
  }

  LS interpretations(S input) {
    LS tokI = defaultParse(input);
    //print("Raw parse: " + tokI);
    new LS interpretations;
      
    for (Rule rule : rules) {
      continue unless l(rule.in) == 1;
      LS tokR = defaultParse(first(rule.in));
      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), rule.vars));
      if (printRejectedVars && nempty(nonVars)) print("Rejected vars: " + nonVars);
      if (nempty(nonVars)) score = 0;
      int percentScore = ratioToIntPercent(score, l(tokR));
      if (printMappings) print("  " + percentScore + "% " + reverseMapCI_joinDuplicatesWithPlus(map) + " | " + rule.in);
      if (percentScore < minScore) continue;
      
      // Make consequence
      
      S c = rule.out;
      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);
      
      interpretations.add(c);
    }
      
    ret interpretations;
  }

  S formatForUser(S s) {
    ret tok_dropCurlyBrackets(s);
  }*/
  
  LPair<LS, S> rulesAsPairs() {
    ret map(rules, func(Rule r) -> Pair<LS, S> { pair(r.in, r.out) });
  }
  
  L<SimplifyWithRule> splitterRules() {
    ret (L) [Rule r : rules | r instanceof SimplifyWithRule && ((SimplifyWithRule) r).isSplitRule];
  }
  
  void dropRulesWhere(IF1<Rule, Bool> pred) {
    rules = antiFilter(pred, rules);
  }
  
  void deleteRule(S ruleID) {
    dropRulesWhere(r -> eq(r.globalID, ruleID));
  }
  
  Rule getRule(S ruleID) {
    ret firstWhere(rules, globalID := ruleID);
  }
}