!7

!include once #1027167 // Compact Module Include 2 v2

set flag AllPublic.

module WinogradSolver1 > DynSingleFunctionWithPrintLog {

  transient PhilosophyBot1 engine;

  transient O multiStage; // unused

  S prelude = "import bool";

  S input = "Bob paid for Charlie's college education. He is very [generous/grateful]. Who is [generous/grateful]?";

  Map<S, SS> answers = syncMap();

  delegate LogicRule to PhilosophyBot1.

  replace GroupingAndPatterns with Pair<S, Set<S>>.

  void doIt() {

    // Stage 3a: Select the right rules for the task

    Cl<S> rulesToUse = dm_getUnclearList("Rules"); // take all for now

    LS patternsToUse = dm_getUnclearList("Patterns");

    doIt(rulesToUse, patternsToUse);

  }

  void doIt(Cl<S> rulesToUse, LS patternsToUse) {

    clear(answers); change();

    if (empty(input)) ret;

    print("Using patterns: " + sfu(patternsToUse));

    print("Using rules: " + sfu(rulesToUse));

    // Stage 1: take one option out of square brackets

    for (S variant : winograd_variants(input)) {

      print(variant);

      SS _answers = ciMap();

      dm_call(multiStage, 'addStage, "Variant", variant);

      // Stage 1b: Split off 's

      S input2b = ai_splitOffApostropheS(variant);

      dm_call(multiStage, 'addStage, "Split off 's", input2b);

      // Stage 1c: Split into sentences

      LS sentences = map dropQuestionMark(sentences(input2b));

      dm_call(multiStage, 'addStage, "Split into sentences", sentences);

      // Stage 2: Parser

      S parser = dm_makeModule("#1027108/TopDownParsing");

      //L<virtual TryPatterns> parsed = map(sentences, s -> dm_call(parser, 'parse, s));

      L<Cl<GroupingAndPatterns>> groupingsWithPatterns = map(sentences,

        s -> (Cl<GroupingAndPatterns>) dm_callWithImport(parser, 'parseToGroupingsWithUsedPatterns, s,

          patterns := patternsToUse));

      L<GroupingAndPatterns> groupingsWithPatterns2 = concatLists(groupingsWithPatterns);

      Map<S, Set<S>> groupingToUsedPatterns = pairsToMap(groupingsWithPatterns2);

      //L<Cl<S>> parsed = map(sentences, s -> (Cl<S>) dm_call(parser, 'parseToGroupings, s));

      //pnl(parsed);

      Set<S> allGroupings = toCISet(pairsA(groupingsWithPatterns2));

      print("Have " + n2(allGroupings, "grouping"));

      //dm_call(multiStage, 'addStage, "Parser", parsed);

      // Stage 3b: Run logic engine

      S program = joinWithEmptyLines(concatLists(ll(prelude), allGroupings, rulesToUse));

      engine = PhilosophyBot1(program);

      engine.standardImports();

      engine.enableTrails();

      engine.parseProgram();

      for (S s : allGroupings) {

        //print("Setting trail for " + quote(s));

        engine.setTrail(s, "grouped original input");

      }

      engine.printFactsAfterThinking = false;

      L<LogicRule> initialRules = engine.logicRules();

      engine.think();

      engine.printDeducedFactsWithTrails();

      Set<S> allOriginalGroupings = cloneSet(allGroupings);

      // gather simplified versions of questions so we find their answers too

      LPairS simplifications = philosophyBot1_allSimplifications_gen(engine);

      for (PairS p : simplifications)

        if (allGroupings.contains(p.a)) allGroupings.add(p.b);

      for (Pair<S, SS> p : engine.matchFacts2("the answer to $x is $y"))
 {

        S fact = p.a;

        SS map = p.b;

        if (allGroupings.contains($x(map))) {

          printAfterNewLine("ANSWER>> " + $x(map) + ": " + $y(map));

          //print("Trail: " + engine.getTrail(fact));

          //print("Question trail: " + engine.getTrail($x(map)));

          Set set = engine.thingsUsedForMaking(fact);

          Set<S> strings = asCISet(stringsOnly(set));

          Set<LogicRule> sourceRules = setIntersection(set, initialRules);

          Set<S> usedRules = setIntersection(strings, rulesToUse);

          strings = setMinusSet(strings, usedRules);

          Set<S> usedGroupings = setIntersection(strings, allOriginalGroupings);

          Set<S> remainingStrings = setMinusSet(strings, allGroupings);

          Set<S> usedPatterns = joinCISets(map(usedGroupings, s -> groupingToUsedPatterns.get(s)));

          LS usedRules_prettier = map(usedRules, s -> replacePrefixIC("add simplifier ", "simplifier ", s));

          /*for (O o : sourceRules) {

            print(" RULE >> " + o);

            print("    Trail: " + engine.getTrail(o));

          }

          for (O o : usedRules) {

            print(" FACT >> " + o);

            print("    Trail: " + engine.getTrail(o));

          }*/

          pnl("  PATTERN >> ", usedPatterns);

          pnl("  GROUPED INPUT >> ", usedGroupings);

          pnl("  TOOL >> ", usedRules_prettier);

          _answers.put($x(map), $y(map));

        }

      }

      answers.put(variant, _answers); change();

      print();

    }

  }

  visual northCenterAndSouthWithMargins(

    jCenteredSection("Input", dm_centeredTextField input()),

    super,

    jCenteredSection("Answers",

      //dm_calculatedTextArea(() -> pnlToString(answers)))

      dm_calculatedCenteredLabel(() -> joinWithSlash(

        map(values(answers), map -> joinWithComma(values(map)))))

    ));

  start {

    dm_registerAs winogradSolver();

  }

  // API

  O getTrailForFact(S fact) {

    ret engine == null ? null : engine.getTrail(fact);

  }

}