/*
Input:
  123 is a number
  blubb is not a number
  5$"%! is not a number
  45 is a number

task 1: tokenize well (in this case, ignore quotes)
task 2: discover patterns "* is a number" and "* is not a number"
task 3: call pattern 1 positive, pattern 2 negative
task 4: make set of positive/negative example strings for argument
task 5a: learn description for positive examples, output new examples
task 5b: learn description for negative examples, output new examples

Generates new examples for numbers, e.g.:
  351 is a number
  73 is a number
*/

cprint {
  S input = autoUnindent_mls([[
    123 is a number
    blubb is not a number
    5$"%! is not a number
    45 is a number
  ]]);
  S output;

  transient L<F1> someFunctions = ll(
    f<Char, Bool> isDigit,
    f<Char, Bool> isLetter,
    f<Char, Bool> isLetterOrDigit,
    f<Char, Bool> isSpace);

  visual jvsplit(jhsplit(dm_textAreaAsSection input(), dm_textAreaAsSection output()), super);
  
  start { dm_onFieldChangeAndNow input(r calc); }

  void calc {
    // task 1: tokenize well (in this case, ignore quotes)
    
    ITokenizer tokenizer = lambda1 splitAtSpaceTokenizer;
    LLS tokenizedInput = map(s -> simpleSpacesAndTrim(tokenizer.tokenize(s)), tlft(input));
    pnlStruct(+tokenizedInput);
    
    // task 2: discover patterns "* is a number" and "* is not a number"

    Set<S> patterns = asSet(findOneArgumentPatterns(tokenizedInput));
    assertEquals(2, l(patterns));
    print(+patterns);
    
    // task 3: make set of positive/negative example strings for argument
    
    Map<S, LS> examples = mapToValues_linkedHashMap(patterns, pat ->
      mapNotNulls(tok -> firstMatch(getFlexMatchIC(pat, tok)), tokenizedInput));
    print(+examples);
    
    // task 4: make theories

    replace Xmp with L<Char>.
    
    Map<S, L<Xmp>> examplesAsLists = mapValues(l -> lambdaMap characters(l), examples);
    print(examplesAsLists);
    //examplesAsLists = reverseKeys(examplesAsLists); // test reversing to see if theory gets reversed
    L<Xmp> posExamples = firstValue(examplesAsLists), negExamples = secondValue(examplesAsLists);

    // for functions that are applicable to the elements of the examples:
    new LinkedHashSet<ITheoryOn<Xmp>> theories;
    for (O function : concatAsOrderedSet(lambdaMap plusNegation(someFunctions))) {
      //if (!functionCallableOnAll_nonSynthetic(function, concatLists(values(examplesAsLists)))) continue;
      print("Testing function " + function);
      theories.add(new AllElementsSatisfy(function));
      theories.add(new AnyElementSatisfies(function));
    }

    theories.addAll(concatLists(lambdaMap theoryPlusInverse(theories)));
    pnl(theories);

    // test theories
    Map<ITheoryOn<Xmp>, PosNeg<Xmp>> theoryResults = mapToValues(theories, theory -> 
      PosNeg(mapToValues(trueFalseMap(posExamples, negExamples), (example, x) ->
        theory.check(example) == x)));
    pnl(theoryResults);

    // make new examples

    replace Theory with ITheoryOn<Xmp>.

    new LS newStatements;

    L<Theory> perfectTheories = sortByMetaTransformerStructureComplexity(keysWhereValue(theoryResults, pn -> pn.perfect()));
    print(+perfectTheories);
    newStatements.addAll(makeExamplesFor(perfectTheories, posExamples, firstKey(examplesAsLists)));

    // perfect theories for negative examples
    L<Theory> antiPerfectTheories = sortByMetaTransformerStructureComplexity(keysWhereValue(theoryResults, pn -> pn.antiPerfect()));
    print(+antiPerfectTheories);
    newStatements.addAll(makeExamplesFor(antiPerfectTheories, negExamples, secondKey(examplesAsLists)));

    setField(output := lines(newStatements));
  }

  LS makeExamplesFor(L<ITheoryOn<L<Char>>> theories, Cl<L<Char>> examples, S pattern) {
    new LS out;
    
    IntRange sizeRange = sizeRangeOfCollections(examples);
    print(+sizeRange);

    for (ITheoryOn<L<Char>> t : theories)
      if (t cast AllElementsSatisfy) {
        IF0<Char> generator = predicateToGenerator(t.pred);
        if (generator == null) continue with print("No generator for " + t.pred);
        repeat 3 {
          S example = charactersToString(repF(random(sizeRange), generator));
          print("> ", addAndReturn(out, format_noQuote(pattern, example)));
        }
        break;
      }

    ret out;
  }

  IF0<Char> predicateToGenerator(O f) {
    ret () -> (Char) random(filter(f, printableASCIICharsList()));
  }
}