!7

concept Rule > ConceptWithGlobalID {

  S input, output, variables /* comma-separated */, flags, comment;

  sS _fieldOrder = "globalID input output variables flags comment";

  Set<S> vars() { ret asCISet(tok_splitAtComma(variables)); }

  Set<S> flags() { ret asCISet(tok_splitAtComma(flags)); }

}

concept PossibleExample > ConceptWithGlobalID {

  Rule rule;

  S input, output;

  SS mapping;

  Bool good;

  sS _fieldOrder = "globalID rule good input output mapping";

}

concept Input > ConceptWithGlobalID {

  S input;

}

p {

  db();

  indexConceptFields(PossibleExample, 'rule);

  indexConceptFieldsCI(Input, 'input, Rule, 'input, PossibleExample, 'input);

  indexConceptFieldsOrdered(Rule, 'globalID);

}

static HCRUD rulesCRUD() {

  ret new HCRUD(rawLink("admin"), new HCRUD_Concepts<Rule>(Rule) {

    void massageItemMapForList(Rule r, MapSO map) {

      Cl<PossibleExample> examples = conceptsWhere(PossibleExample, rule := r);

      PossibleExample goodExample = random(objectsWhere(examples, good := true));

      map.put("Example Input" := goodExample != null ? goodExample.input : null);

      map.put("Example Output" := goodExample != null ? goodExample.output : null);

      map.put("Possible Examples" := l(examples));

      replaceKey(map, "input", "Pattern");

      replaceMap(map, putKeysFirst(map, "globalID", "Example Input", "Example Output", "Pattern"));

    }

    Cl<Rule> listConcepts() {

      ret conceptsSortedByFieldCI(Rule, 'input);

    }

  } .fieldHelp(variables := "comma-separated")

    .fieldHelp(flags := "comma-separated")

  ) {

    S renderValue(S field, O value) {

      S html = super.renderValue(field, value);

      if (eq(field, 'globalID))

        ret ahref(rawLink(str(value)), html);

      if (eqOneOf(field, 'input, "Pattern"))

        ret b(html);

      ret html;

    }

  };

}

static HCRUD inputsCRUD() {

  ret new HCRUD(new HCRUD_Concepts<Input>(Input.class) {

    void massageItemMapForList(Input i, MapSO map) {

      map.put("Possible Examples" := l(conceptsWhereCI PossibleExample(input := i.input)));

      map.put("Cmds", HTML(ahref(

        appendQueryToURL("admin", cmd := "processInput", inputID := i.id),

        "process")));

    }

  });

}

static HCRUD possibleExamplesCRUD(S uri) {

  ret new HCRUD(new HCRUD_Concepts<PossibleExample>(PossibleExample.class) {

    void massageItemMapForList(PossibleExample e, MapSO map) {

      if (e.rule != null)

        map.put(rule := HTML(ahref(rawLink(e.rule.globalIDStr()), e.rule.globalID())));

      map.put(Cmds := HTML(

        ahref(appendQueryToURL(rawLink(uri), cmd := "markGood", exampleID := e.id), "good") + " " +

        ahref(appendQueryToURL(rawLink(uri), cmd := "markBad", exampleID := e.id), "bad")));

    }

  });

}

set flag NoNanoHTTPD. html {

  long startTime = sysNow();

  bool authed = webAuthed(params);

  if (empty(uri = dropSlashPrefix(uri)))

    ret htitle_h1("Rules")

      + (webAuthed(params) ? p(ahref(rawLink("admin"), "Admin")) : "")

      + ul_noEncode(map(list(Rule), r -> ahref(rawLink(r.globalIDStr()), htmlEncode2(r.input + " => " + r.output))));

  if (eqic(uri, "wordClassExamples"))

    ret serveText(mapPairsToLines(multiSetMapToPairs(wordClassExamples()), (k, v) -> quote(v) + " is in word class " + quote(k)));

  // serve rule

  if (possibleGlobalID(uri)) {

    Rule r = conceptWhere(Rule, globalID := GlobalID(uri));

    if (r == null) ret subBot_serve404("Rule not found");

    S html = htitle_h1("Rule " + r.globalID)

      + htmlTable2(mapToTwoElementMaps("Field", "Value", litorderedmap("Input" := r.input, "Output" := r.output, "Variables" := r.variables, "Comment" := r.comment)));

    HCRUD peCRUD = possibleExamplesCRUD(uri);

    ((HCRUD_Concepts) peCRUD.data).addFilter(rule := r);

    html += h3("Possible Examples")

      + peCRUD.renderTable(false);

    //Cl<PossibleExample> examples = conceptsWhere PossibleExample(rule := r);

    //ret possibleExamplesCRUD().render(false, )

    ret html;  

  }

  new Matches m;

  if (swic_slash(uri, "admin", m))

 {

    S _uri = uri;

    HMultiCRUD multi = new(rawLink("admin"), Rule, Input, PossibleExample) {

      HCRUD makeCRUD(S className) {

        if (eq(className, "Rule")) ret rulesCRUD();

        if (eq(className, "Input")) ret inputsCRUD();

        if (eq(className, "PossibleExample")) ret possibleExamplesCRUD(_uri);

        null;

      }

      LS naviComponents() {

        LS l = super.naviComponents();

        if (mutationRights)

          l.add(ahref(appendQueryToURL(baseLink, cmd := "processInputs"), "process inputs"));

        l.add(ahref(rawLink("wordClassExamples"), "word class examples"));

        ret l;

      }

    } .mainTitle("Rules + Inputs")

      .mutationRights(authed);

    multi.downloadRights = authed;

    HAbstractRenderable.MakeFrame mf = multi.makeFrame;

    multi.makeFrame = (title, contents) -> mf.makeFrame(title, contents) + p(small(sysNow()-startTime + " ms"), align := "right");

    S cmd = params.get('cmd);

    if (nempty(cmd)) {

      try object checkWebAuthed(params);

      if (eqOneOf(cmd, "markGood", "markBad")) {

        PossibleExample e = getConcept(PossibleExample, parseLong(params.get('exampleID)));

        cset(e, good := eq(cmd, "markGood"));

      }

      if (eq(cmd, "processInput")) {

        Input i = getConcept(Input, toLong(params.get('inputID)));

        ret serveText(hijackPrint_tee_pcall(() -> processInput(i.input)));

      }

      if (eq(cmd, "processInputs")) {

        time {

          for (Input i)

            processInput(i.input);

        }

        ret multi.refreshWithMsgs("Processed " + nInputs(countConcepts(Input)) + " in " + lastTiming() + " ms");

      }

    }

    ret multi.renderPage(m.rest(), params);

  }

  ret subBot_serve404();

}

static void processInput(S input) {

  for (Rule r) {

    new Set<PossibleExample> found;

    print("Combining input " + quote(input) + " with rule " + quote(r.input));

    ITokenizer tokenizer = r.flags().contains("keep punctuation")

      ? lambda1 javaTokWithBrackets_cached

      : lambda1 javaTokNPunctuationWithBrackets_plusAsterisk_cached;

    //for (SS mapping : arbitraryVarsFlexMatchIC_iterator(r.vars(), r.input, input)) {

    for (SS mapping : arbitraryVarsFlexMatchIC_tok_iterator(r.vars(), Tok(tokenizer, r.input), Tok(tokenizer, input))) {

      print("  Have mapping: " + mapping);

      PossibleExample e = uniq PossibleExample(rule := r, +input, +mapping);

      found.add(e);

      S output = replaceVars_optRound2(r.output, mapping);

      output = applyTransformers(output);

      cset(found, +output);

    }

    deleteConcepts(listMinusSet(conceptsWhere(PossibleExample, rule := r, +input), found));

  }

}

func transformers = mapGet_if1(litmap(

  nominativ := (IF1<S>) lambda1 german_toNominativ,

  switcheroo := (IF1<S>) lambda1 switcheroo

));

sS applyTransformers(S s) {

  ret pcallOrKeep(s, () -> tok_applyCurlyTransformers(transformers(), s));

}

static MultiSetMap<S> wordClassExamples() {

  MultiSetMap<S> mm = ciMultiCISetMap();

  for (PossibleExample e : conceptsWhere PossibleExample(good := true))

    for (S key, value : unnull(e.mapping))

      mm.put(key, value);

  ret mm;

}