!7

set flag DynModule.

sclass Entry {
  //S originalRule, replacements, modifiedRule;
  S line;
  S conditions;
  S rule;
  S prediction;
  S judgement = "";
  S struct;
  transient RuleEngine2_MatchedRule mr;

  sS _fieldOrder = "line conditions prediction judgement struct";
}

cmodule TestRuleEngine2 > DynObjectTable<Entry> {
  S input, processedInput;
  transient ReliableSingleThread rstCalc = dm_rstWithPostDelay(this, r calc, 500);
  transient int maxResults = 500;
  transient bool skipBadPredictions = true;
  
  S switchableFields() { ret "skipBadPredictions maxResults"; }
  
  start {
    set withSearcher;
    set fieldsInOrder;
    hideFields = litset('rule, 'mr);
  }
  
  visualize {
    JComponent tf = dm_textField('input);
    onChangeAndNow(tf, rstCalc);
    ret northCenterAndSouthWithMargins(
      centerAndEastWithMargin(
        tf,
        jbutton("Make rule...", rThread { dm_gazelle_newRuleDialog(input, input) })),
      super.visualize(),
      rightAlignedButtons(
        tableDependentButton(table(), "Mark good", rMark('good)),
        tableDependentButton(table(), "Mark bad", rMark('bad)),
        tableDependentButton(table(), "Mark funny", rMark('funny))
      ));
  }
  
  Runnable rMark(fS judgement) {
    ret rThread {
      Entry e = selected();
      print("Selected: " + e);
      e.judgement = judgement;
      fireDataChanged();
      saveEntry(e);
    };
  }
  
  void calc {
    S input = this.input;
    final new RuleEngine2 engine;
    engine.addRules2(dm_allRulesFromRulesModuleWithCommentsAndIDs());
    
    // gather data for predictor
    MultiMap<S> statementsByRule = ai_gazelle_indexStatementsByRule(dm_gazelle_statementsFromAppliedRules());
    final Map<S, ai_gazelle_analyzeStatementsForRule_Data> dataByRule =
      mapValues ai_gazelle_analyzeStatementsForRule(multiMapToMap(statementsByRule));

    final new LinkedHashSet<S> queue;
    queue.add(input);
    final new Set<S> done;
    final new Set<S> lines;
    new L<Entry> list;

    bool changes = true;
    while (l(list) < maxResults && nempty(queue)) {
      S input2 = popFirst(queue);
      done.add(input2);
      
      L<RuleEngine2_MatchedRule> l = ai_ruleEngine2_rulesForInput_3(engine, input2);
      l = sortByMethodDesc qualitySum(l);
    
      new L<Entry> newList;
      for (RuleEngine2_MatchedRule r : l) {
        S modifiedRule = engine.formatForUser(r.applyMapping().asText());
        S line = r.applyMappingTo(r.rule.out);
        addIfNotInOtherSet(queue, done, line);
        
        ai_gazelle_analyzeStatementsForRule_Data data = dataByRule.get(r.rule.globalID);
        S prediction = data == null ? null : ai_gazelle_predictor1_onData(r, data);
        
        if (skipBadPredictions && eq(prediction, 'bad)) continue;
        
        newList.add(nu(Entry,
          +line,
          conditions := join(" | " , r.remainingConditions),
          +prediction,
          rule := modifiedRule,
          struct := struct(r),
          mr := r));
      }
      list.addAll(newList);
      
      for (Entry e : newList) {
        continue if e.mr == null;
        for (S line : ai_gazelle_makeIWantToKnows(e.mr)) {
          if (!lines.add(line)) continue;
          list.add(nu(Entry,
            +line,
            struct := "iwtk " + e.mr.rule.globalID)); // abusing the struct field
          addIfNotInOtherSet(queue, done, line);
        }
      }
    }

    setList(list);
    processedInput = input;
  }
  
  void saveEntry(Entry e) {
    dm_gazelle_saveAppliedRule(
      modifiedRule := e.rule,
      judgement := e.judgement,
      matchedRuleStruct := e.struct);
  }
}