!7

cmodule PhilosophyBot extends DynPrintLog {
  transient S program = [[
    "memory"
    
    memory can mean RAM
    RAM has a size
    I have RAM
    
    input is x & x can mean y => pretend (input is y)
    
    input is x => activate facts containing x
    
    I have x => Ask something about (my x)
    
    I have x => (my x) exists

    x has a y & (my x) exists => (my x) has a y

    assume x => x
    
    // General patterns in flight now:
    //   my *
    //   Ask something about *
    //   pretend *
    //   input is *
    // (and more)
    
    Procedures
    ----------
    
    Ask something about x => proc {
      if (x exists):
        ask (what is x?)
      else:
        ask (does x exist?)
      for (y | x has a y):
        assume ((the y of x) exists)
        ask something about (the y of x)
    }
    
    the answer to x is y => the answer to x is known
    
    ask x & the answer to x is known => don't (ask x)
    
    Ask x => proc {
      print x
      on input:
        if (input is a valid answer to x):
          store (the answer to x is input)
    }
    
    (x exists) is a valid answer to (does x exist)
    (x doesn't exist) is a valid answer to (does x exist)
    (x is y) is a valid answer to (what is x)
  ]];

  srecord LogicRule(lhs, rhs) {}
  srecord And(a, b) {}
  srecord If(condition, thenBlock, elseBlock) {}
  srecord For(var, condition, body) {}

  transient Set<S> facts = linkedCISet();
  transient Set<S> originalFacts;
  transient new LinkedHashSet<LogicRule> logicRules;
  transient new AllOnAll<LogicRule, S> rulesOnFacts;
  transient new LS proceduresToRun;

  transient Set<S> vars = litciset("x", "y");

  void addLogicRule(LogicRule rule) {
    if (logicRules.add(rule)) {
      print("Got logic rule", rule);
      rulesOnFacts.newA(rule); // to combine it with the facts
    }
  }

  void addFact(S fact) {
    fact = trim(fact);
    if (empty(fact)) ret;
    fact = tok_deRoundBracket(fact);
    // Check if it's a procedure
    LS tok = javaTokWithBrackets(fact);
    if (countCodeTokens(tok) == 2 && eqic(getCodeToken(tok, 0), "proc")
      && isCurlyBracketed(getCodeToken(tok, 1))) {
        // It's a procedure!
        S proc = uncurly_keepSpaces(getCodeToken(tok, 1));
        if (proceduresToRun.add(proc)) {
          print("Got procedure:");
          print(indentx("> ", proc));
        }
      }
    else // It's a fact, not a procedure
      if (facts.add(fact)) {
        print("Got fact: " + fact);
        rulesOnFacts.newB(fact); // to combine it with the rules
      }
  }

  void runProcedure(S proc) {
    print("Running procedure.");
    L commands = parseProcedure(proc);
    runParsedProcedure(commands);
  }

  void runParsedProcedure(L commands) {
    for (O cmd : commands) {
      if cmd is If(O condition, O thenBlock, O elseBlock) {
        O blockToRun = checkCondition(condition) ? thenBlock : elseBlock;
        runParsedProcedure(ll(blockToRun));
      } else if cmd is For(O var, O condition, O body) {
        // make a new logic rule and add it
        // assume the variable is globally declared as a variable
        addLogicRule(new LogicRule(condition, "proc {\n" + body + "\n}"));
      } else if (cmd cast S) {
        addFact(cmd);
      } else if (cmd != null)
        fail("Unimplemented command: " + cmd);
    }
  }

  bool checkCondition(O o) {
    ret o instanceof S && contains(facts, (S) o);
  }
  
  L parseProcedure(S proc) {
    //printStruct(proc);
    proc = withoutLinesEmptyAfterTrim(proc);
    //printStruct(proc);
    proc = autoUnindent(proc);
    //printStruct(proc);
    print(indentx("> ", proc));
    
    LS l = groupPythonStyleIndents(proc);
    pnl("unpythonized ", l);

    new L out;
    for i over l: {
      S s = l.get(i);
      LS tok = javaTokWithBrackets(s);
      if (eqic(firstCodeToken(tok), "if")) {
        assertEquals(s, ":", getCodeToken(tok, 2));
        out.add(new If(deRoundBracket(getCodeToken(tok, 1)),
          joinSubList(tok, 3*2), null));
      } else if (eqic(firstCodeToken(tok), "else")) {
        O last = last(out);
        if (!last instanceof If) fail("Else without if");
        assertEquals(s, ":", getCodeToken(tok, 1));
        ((If) last).elseBlock = joinSubList(tok, 2*2);
      } else if (eqic(firstCodeToken(tok), "for")) {
        assertEquals(s, ":", getCodeToken(tok, 2));
        S cond = getCodeToken(tok, 1);
        // cond looks like: "(y | x has a y)"
        cond = deRoundBracket(cond);
        LS tok2 = javaTok(cond);
        assertEquals(cond, "|", getCodeToken(tok2, 1));
        S var = assertIdentifier(cond, getCodeToken(tok2, 0));
        S actualCondition = trimJoinSubList(tok2, 2*2+1);
        out.add(new For(var, actualCondition, joinSubList(tok, 3*2)));
      } else
        out.add(s);
    }
    pnl("Parsed procedure ", out);
    ret out;
  }

  O splitAtAmpersand2(S s) {
    LS l = tok_splitAtAmpersand(s);
    if (l(l) == 1) ret s;
    ret new And(first(l), splitAtAmpersand2(join(" & ", dropFirst(l))));
  }

  void applyLogicRuleToFact(LogicRule rule, S fact) {
    O lhs = rule.lhs, rhs = rule.rhs;
    O cond, remaining = null;
    if lhs is And(O a, O b) {
      cond = a;
      remaining = b;
    } else
      cond = lhs;
    
    // now we match the condition with the fact
    SS map = gazelle_zip((S) cond, fact);
    if (map == null) ret; // no match
    print("gazelle zip => " + map);

    // are only variables changed?
    if (!allKeysAreInSet(map, vars))
      ret /*with print("Non-variable changes, exiting")*/;

    // Now we have a proper mapping with the keys being variables!
    print("Match.");

    // drop round brackets
    // XXX? map = mapValues tok_deRoundBracket(map);

    // Apply mapping to right hand side
    S rhs_replaced = join(replaceCodeTokensUsingMap(javaTok((S) rhs), map));
    print(+rhs_replaced);

    if (remaining == null) {
      // Add as fact
      addFact(rhs_replaced);
    } else {
      // Apply mapping to remaning condition
      S remaining_replaced = join(replaceCodeTokensUsingMap(javaTok((S) remaining), map));
      addLogicRule(new LogicRule(remaining_replaced, rhs_replaced));
    }
  }

  start-thread {
    // split into paragraphs and unindent

    LS paragraphs = map autoUnindent(map rtrim(splitAtEmptyLines(program)));
    print("Got " + n2(paragraphs, "parapraph"));

    // print the parapraphs
    print(joinWithEmptyLines(map(s -> indentx("> ", s), paragraphs)));

    // throw away comment-only and quoted paragraphs (assume it's a title)
    LS paragraphs2 = antiFilter(paragraphs, s -> 
      isSingleLine(trim(s)) && isQuoted(trim(s)) || countJavaTokens(s) == 0
      || endsWith(rtrim(s), "----"));
    print("Got " + n2(paragraphs2, "filtered paragraph"));
    print(joinWithEmptyLines(map(s -> indentx("> ", s), paragraphs2)));

    // find fact paragraphs
    
    print(map allLinesAreUnindented(paragraphs2));
    Pair<LS> p1 = filterAntiFilter(s ->
      !isSingleLine(trim(s)) && allLinesAreUnindented(s), paragraphs2);
    LS multiFactParagraphs = p1.a, paragraphs3 = p1.b;

    for (S para : multiFactParagraphs)
      for (S s : tlft(para))
        addFact(s);

    // find logic rules

    new LS paragraphs4;
    for (S para : paragraphs3) {
      PairS p = splitAtDoubleArrow_pair(para);
      if (p == null) continue with paragraphs4.add(para);
      addLogicRule(new LogicRule(splitAtAmpersand2(p.a), splitAtAmpersand2(p.b)));
    }

    pnlStruct("Unparsed", paragraphs4);
    originalFacts = cloneSet(facts);

    // Parsing done, now THINK

    think();
  }

  bool doSomeLogic() {
    bool anyAction;
    Pair<LogicRule, S> p;
    while not null (p = rulesOnFacts.next()) {
      set anyAction;
      //print("Combination: " + p);
      applyLogicRuleToFact(p.a, p.b);
    }
    ret anyAction;
  }

  void think {
    int round = 0;
    bool anyAction;

    while (round++ < 100) {
      anyAction = false;
      print("Logic round " + round);
      while (doSomeLogic() && round++ < 100) set anyAction;

      for (S proc : getAndClearList(proceduresToRun)) {
        set anyAction;
        runProcedure(proc);
      }
    }

    // We're done logicking, so print all the facts gathered

    LS factsToPrint = listMinusList(facts, originalFacts);
    pnlWithHeading("Facts I deduced", factsToPrint);

    // Print the actual output

    new LS output;
    for (S fact : factsToPrint) {
      LS tok = javaTokWithBrackets(fact);
      if (countCodeTokens(tok) == 2 && eqic(getCodeToken(tok, 0), "print"))
        // For the user, we print without all the round brackets
        output.add(tok_dropRoundBrackets(getCodeToken(tok, 1)));
    }
    
    pnlWithHeading("Bot Output", output);
  }
}