!7

!include once #1014750 // CSnippet

sS inspiration = [[
  snippet titles
  "[OK]"
]];

static new LL<S> facts; // stores code token parses
static Map<S, O> phrasesWordTree = wordTree();
static Clusters<S> clusters = ciClusters();
static Prolog prolog;

sS reasoning = [[
  // check inspiration :o)
  assert(inspired "snippet titles")
  assert(inspired "\"[OK]\"")

  // phrases
  phrase "snippet titles"
  phrase "a list of strings"
  phrase "a quoted string"
  
  // synonyms
  "the snippet titles" = "snippet titles"
  
  // grammar
  singular_plural("snippet title", "snippet titles")
  
  // test parsing
  assert_parse("snippet titles are a list of strings", "snippet titles", "are", "a list of strings")
  
  // facts
  snippet titles are a list of strings
  "[OK]" is a quoted string
  
  // rule to answer a question
  fact_question_answer_upperCaseVars("X are Y", "what are X?", "Y")
  
  // check the rule
  assert_answer("what are snippet titles?", "a list of strings")
]];

p-experiment-tt { go(); }

svoid go {
  prolog = new Prolog;
  
  L<S> program = tlftj(reasoning);
  pnl(program);
  print();
  
  //set translateUsingWordTree_debug;
  //set translateUsingWordTreeC_printReplacements;
  
  for (S s : tlftj(inspiration))
    addFact("inspired " + quote(s));
    
  for (S s : program) {
    Pair<S, L<S>> p = parseFunctionCall(s);
    if (p != null) {
      //print("Function call: " + sfu(p));
      S f = p.a;
      L<S> args = p.b;
      if (eqic(f, "assert"))
        assertFact(getSingleton(p.b));
      else if (swic(f, "assert_")) {
        if (eqic(f, "assert_answer"))
          assertAnswer(unquote(first(args)), unquote(second(args)));
        else if (eqic(f, "assert_parse"))
          assertParse(args);
        else
          fail("Unknown assertion function: " + f);
      } else if (eqic(f, "fact_question_answer_upperCaseVars"))
        prolog.code(
          print("if [" + toProlog(unquote(first(args))) + "] and ["
          + toProlog(unquote(second(args))) + "] then [answer is ["
          + toProlog(unquote(third(args))) + "]]"));
      continue;
    }
    
    L<S> tok = javaTokC(s);
    if (l(tok) == 2 && isIdentifier(first(tok)) && isQuoted(second(tok)))
      if (eq(first(tok), "phrase")) {
        addPhrase(unquote(second(tok)));
        continue;
      }
      
    if (l(tok) == 3 && eq(second(tok), "=")) {
      ciClusters_add(clusters,
        addPhrase(unquote(first(tok))),
        addPhrase(unquote(third(tok))));
      continue;
    }

    addFact(s);
  }
  
  printAsciiHeading("Facts");
  pnlStruct(facts);
  print();
  
  print("Clusters: " + sfu(clusters));
  print("Phrases: " + sfu(phrasesWordTree));
  //loadSnippets();
}

svoid loadSnippets {
  loadMainConceptsFrom_readOnly(#1009918); // get snippets
  print("Have " + countConcepts(CSnippet) + " snippets");
  pnl(takeFirst10(collect(list(CSnippet), 'title));
}

static L<S> parseFact(S s) {
  L<S> tok = map toLowerIfIdentifier(javaTokWithAngleBracketsC(/*dropPunctuation*/(s)));
  ret nempties(translateUsingWordTreeC(tok, phrasesWordTree));
}

svoid assertFact(S fact) {
  if (contains(facts, parseFact(fact)))
    print("OK fact: " + fact);
  else
    print("FAILED fact assert: " + fact);
}

svoid assertAnswer(S q, S a) {
  Prolog p = new(prolog);
  //p.showStuff = true;
  p.code(dontPrint("to prolog: ", squareBracket(toProlog(q))));
  L<Lisp> out = p.rewrite();
  //print("Got " + l(out) + " statement(s)");
  L<S> lines = map nlUnparse(out);
  L<S> answers = startingWithEndingWith_drop(lines, "answer is [", "]");
  if (l(answers) == 1 && eqic(first(answers), a))
    print("OK answer: " + q + " -> " + a);
  else {
    pnl(map nlUnparse(out));
    print("FAIL answer: " + q + " -> " + first(answers) + " - expected: " + a);
  }
}

sS addPhrase(S s) {
  wordTreeAdd(phrasesWordTree, javaTokC(s), s);
  ret s;
}

svoid addFact(S s) {
  L<S> tok = parseFact(s);
  facts.add(tok);
  prolog.code(dontPrint("to prolog: ", squareBracket(factToProlog(tok))));
}

svoid assertParse(L<S> args) {
  args = unquoteAll(args);
  S s = first(args);
  L<S> parsed = parseFact(s);
  L<S> expected = dropFirst(args);
  if (eq(parsed, expected))
    print("OK parse: " + s + " -> " + sfu(parsed));
  else
    print("FAILED parse: " + s + " -> " + sfu(parsed) + " - expected: " + sfu(expected));
}

sS toProlog(S s) {
  L<S> tok = parseFact(upperCaseVarsToDollarVars(s));
  ret factToProlog(tok);
}

sS factToProlog(L<S> tok) {
  ret joinWithSpace(map tokenToProlog(tok));
}

sS tokenToProlog(S t) {
  if (!isQuoted(t) && containsSpace(t)) ret squareBracket(t);
  ret t;
}