!7

set flag DynModule.

sclass GazelleTree {
  L<GazelleTree> children;
  GazelleTree parent;
  double weight = 1, totalWeight;
  S line, lineType;
  S prediction, judgement;
  RuleEngine2_MatchedRule mr;
  
  transient EvalContext ctx;

  *() {}
  *(S *line) {}
  
  toString {
    new LS l;
    if (mr != null)
      for (S s : unnull(mr.remainingConditions))
        l.add("if: " + s);
    addIfNempty(l, prediction);
    if (mr != null)
      l.add(mr.qualitySum() + " / " + formatDouble(mr.relativeQuality(), 2));
    ret line + appendSquareBracketed(joinWithComma(l));
  }
}

sclass EvalContext {
  RuleEngine2 engine;
  Map<S, ai_gazelle_analyzeStatementsForRule_Data> dataByRule;
}

cmodule TestRuleEngine2 > DynSCP {
  S input, processedInput;
  transient ReliableSingleThread rstCalc = dm_rstWithPostDelay(this, r calc, 500);
  transient int maxResults = 500;
  transient bool skipBadPredictions = true;
  transient JTree jTree;
  transient GazelleTree root;
  transient double qualityCutOff = -0.75;
  
  S switchableFields() { ret "skipBadPredictions maxResults"; }
  
  start {
    dm_vmBus_onMessage('gazelleRuleCreated, rstCalc);
  }
  
  visualize {
    jTree = jDynamicTree(null, func(GazelleTree tree) -> L<GazelleTree> { gt_getChildren(tree) }, makeChildrenIsFast := true);
    
    componentPopupMenu(jTree, voidfunc(JPopupMenu menu) {
      MouseEvent evt = componentPopupMenu_getEvent();
      TreePath path = jTree.getPathForLocation(evt.getX(), evt.getY());
      if (path == null) ret;
      DefaultMutableTreeNode node = cast path.getLastPathComponent();
      final GazelleTree e = cast node.getUserObject();
      jTree.setSelectionPath(path);
      
      print("Selected: " + e);
      addMenuItem(menu, "Copy line", rThread { copyTextToClipboard(e.line) });
      addMenuItem(menu, "Make rule...", rThread {
        S s = e.line;
        GazelleTree ee = e;
        while ((ee = ee.parent) != null)
          s = ee.line + "\n+ " + s;
        dm_gazelle_newRuleDialog_2(s);
      });
    });
    
    JComponent tf = dm_textField('input);
    onChangeAndNow(tf, rstCalc);
    ret northCenterAndSouthWithMargins(
      centerAndEastWithMargin(
        tf,
        jbutton("Make rule...", rThread { dm_gazelle_newRuleDialog_2(input) })),
      super.visualize(),
      rightAlignedButtons(
        treeDependentButton(jTree, "Mark good", rMark('good)),
        treeDependentButton(jTree, "Mark bad", rMark('bad)),
        treeDependentButton(jTree, "Mark funny", rMark('funny))
      ));
  }
  
  visualize2 {
    ret jscroll(jTree);
  }
  
  Runnable rMark(fS judgement) {
    ret rThread {
      GazelleTree e = selected();
      e.judgement = judgement;
      jTree_fireUserObjectChanged(jTree, e);
      saveEntry(e);
    };
  }
  
  GazelleTree selected() {
    ret (GazelleTree) jtree_selectedUserObject(jTree);
  }
  
  void calc {
    S input = this.input;
    root = new GazelleTree(input);
    jTree_setRootObject(jTree, root);
    print("Replaced root on " + isShowing(jTree) + " " + jTree);
    jtree_collapseAndOpenRootNode(jTree);
    processedInput = input;
  }
  
  L<GazelleTree> gt_getChildren(GazelleTree tree) {
    if (tree == null) null;
    if (tree.children != null) ret tree.children;
    
    // make rule engine etc.
    if (tree.ctx == null) {
      new EvalContext ctx;
      tree.ctx = ctx;
      ctx.engine = new RuleEngine2;
      ctx.engine.addRules2(dm_allRulesFromRulesModuleWithCommentsAndIDs());
      
      // gather data for predictor
      MultiMap<S> statementsByRule = ai_gazelle_indexStatementsByRule(dm_gazelle_statementsFromAppliedRules());
      ctx.dataByRule = mapValues ai_gazelle_analyzeStatementsForRule(multiMapToMap(statementsByRule));
    }
    EvalContext ctx = tree.ctx;
    
    new L<GazelleTree> children;
    L<RuleEngine2_MatchedRule> l = sortByMethodDesc qualitySum(ai_ruleEngine2_rulesForInput_3(tree.ctx.engine, tree.line));
    for (RuleEngine2_MatchedRule r : l) {
      if (r.relativeQuality() < qualityCutOff) continue;
      S line = r.applyMappingTo(r.rule.out);
      
      GazelleTree child = new(line);
      child.parent = tree;
      child.ctx = tree.ctx;
      child.mr = r;
      
      ai_gazelle_analyzeStatementsForRule_Data data = ctx.dataByRule.get(r.rule.globalID);
      child.prediction = data == null ? null : ai_gazelle_predictor1_onData(r, data);
      children.add(child);
    }
    sortByCalculatedFieldDesc(children, func(GazelleTree c) -> int { ai_goodBadToInt(c.prediction) });
    ret tree.children = children;
  }
  
  void saveEntry(GazelleTree e) {
    S modifiedRule = e.ctx.engine.formatForUser(e.mr.applyMapping().asText());
    dm_gazelle_saveAppliedRule(
      +modifiedRule,
      judgement := e.judgement,
      matchedRuleStruct := struct(e.mr));
  }
}