!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));

  }

}