// for notes see #1028089

sclass PatternMaker1 {
  S comment, examplesText, counterexamplesText;
  transient Concepts cc;
  transient Set<S> examples, counterexamples;
  transient new Lowest<Theory> simplestFullSolutionCollector;
  TreeMap<Int, Scored<S>> bestPatternsByClass;
  S simplestFullSolution; // simplest pattern solving all examples
  Runnable strategy;
  
  // collectors
  transient new TreeMap<Int, Theory> bestByComplexity;
  transient Map<Int, TreeSetWithDuplicates<Theory>> allByComplexity
    = autoTreeMap(() -> treeSetWithDuplicatesOverCalculatedField theoryScore());

  sconcept Example {
    S text;
    bool pos;
    
    toString { ret text + "/" + pos; }
  }

  sconcept Theory {
    S pattern;
  
    transient simplyCached Cl<Example> solvedExamples() {
      ret filter(list(_concepts, Example.class), e -> e.pos == mmo2_match(pattern, e.text));
    }
    
    transient simplyCached Cl<Example> unsolvedExamples() {
      ret setMinusSet(list(_concepts, Example.class), solvedExamples());
    }
    
    bool isFullSolution() { ret empty(unsolvedExamples()); }
    
    int score() { ret l(solvedExamples()); }
    
    transient simplyCached int complexityClass() { ret numberOfWords2(pattern); }
  } // end of Theory
  
  *() {}
  *(S *examplesText, S *counterexamplesText) {}
  *(LS examples, LS counterexamples) {
    examplesText = lines(examples);
    counterexamplesText = lines(counterexamples);
  }
  
  void prepare {
    cc = new Concepts;
    clearCollectors();
    indexConceptFieldCI(cc, Example.class, 'text);
    indexConceptFieldCI(cc, Theory.class, 'pattern);
    setField(simplestFullSolution := null);
    simplestFullSolutionCollector.clear();
    
    examples = asLinkedHashSet(tlftj(examplesText));
    counterexamples = asLinkedHashSet(tlftj(counterexamplesText));
    Set<S> intersection = setIntersection(examples, counterexamples);
    if (nempty(intersection))
      ret with infoBox("Error: Examples appear in both lists, e.g. " + first(intersection));

    for (S s : examples) uniqCI(cc, Example.class, text := s, pos := true);
    for (S s : counterexamples) uniqCI(cc, Example.class, text := s, pos := false);
    int nExamples = countConcepts(cc, Example.class);
    print("Have " + nExamples(nExamples));
  }

  void think {
    prepare();

    strategy = makeStrategy();
    pcallF(strategy);

    afterThink();
  }
  
  void afterThink {
    print("Have " + nTheories(countConcepts(cc, Theory.class)));
    
    setField(bestPatternsByClass := mapValues(t -> scoredNonPercent(t.score(), t.pattern), bestByComplexity));

    doneThinking();
  }
  
  swappable Runnable makeStrategy() { ret new Strategy1; }
  
  runnable class Strategy1 {
    // positive examples to pattern
    for (S s : examples)
      addPatterns(ai_inputExampleToPossibleMMOPatterns1(s));
    
    // combine some pattern pairs from complexity classes 1-2
    twice {
      for (Theory a : allByComplexity.get(1))
        for (int n = 1; n <= 2; n++)
          for (Theory b : allByComplexity.get(n))
            addPattern(mmo2_combineWithOr(a.pattern, b.pattern));
    }
  }

  Map theoryToMap(Theory t) {  
    ret t == null ? null :
      litorderedmap(
        "Pattern" := t.pattern,
        "Complexity class" := t.complexityClass(),
        "Solved examples" := l(t.solvedExamples()) + " of " + countConcepts(cc, Example.class),
        "Unsolved" := joinWithComma(quoteAll(collect text(t.unsolvedExamples()))));
  }
  
  void addPatterns(Iterable<S> l) { fOr (S s : l) addPattern(s); }
  void addPattern(S pattern) {
    addToCollectors(uniqCI_returnIfNew(cc, Theory.class, +pattern));
  }
  void tryPattern(S pattern) { addPattern(pattern); }
  
  int theoryScore(Theory t) { ret t == null ? 0 : t.score(); }
  
  void clearCollectors {
    bestByComplexity.clear();
    allByComplexity.clear();
  }
  
  void addToCollectors(Theory t) {
    if (t == null) ret;
    putIfHigherByCalculatedField theoryScore(bestByComplexity, t.complexityClass(), t);
    allByComplexity.get(t.complexityClass()).add(t);
    if (t.isFullSolution() && simplestFullSolutionCollector.put(t, t.complexityClass()))
      setField(simplestFullSolution := t.pattern);
  }
  
  void printBestByClass() {
    for (int complexity, Theory t : bestByComplexity) {
      print("Best theory for complexity " + complexity + ": " + shorten(100, str(theoryToMap(t))));
    }
  }
  
  !include #1028121 // setField + change
  
  event doneThinking;
}

Began life as a copy of #1028089