!7

set flag DynModule.

sclass TelegramFactsBot > AbstractTelegramThinkBot {
  bool debug;
  bool imagineMode;
  bool collectCheckingLog = true;
  new LinkedHashSet<S> imaginedFacts;
  LS checkingLog;
  long processingTime;
  
  visualize {
    ret withCenteredButtons(super.visualize(),
      "Checking Log", r { showText("Checking Log", lines(checkingLog)) });
  }

  S evalExp(Exp e, NLLogicChecker_v2.Matching m) {
    S code = nlLogic_text(e);
    print("Eval'ing: " + code);
    temp tempAdd(hotwire_copyOver_after, voidfunc(Class c) {
      copyFields(mc(), c, 'telegram_msg_tl, 'telegram_recentHistory_tl)
    });
    S result = str(evalWithDollarVars(code, m.matches));
    print("Result: " + shorten(result, 100));
    ret result;
  }

  void thinkAbout(S s) {
    time "Processing Time For Message"{
      thinkAbout_impl(s);
    }
    processingTime = lastTiming();
  }
  
  void thinkAbout_impl(fS s) {
    new Map<S, Int> ruleScores;
    ai_tg_collectRuleFeedback(ruleScores, null);
    
    final Map msg = telegram_msg();
    
    NLLogicChecker_v3 c = new NLLogicChecker_v3 {
      L<S> entities;
      
      bool checkExpression_impl(Exp e, Matching m) {
        if (e instanceof Literal) {
          // TEXT CONDITIONS
          
          S text = nlLogic_text(e);
          if (eq(text, "authorized"))
            ret telegram_amIAuthorized();
          else if(eq(text, "imagineMode"))
            ret imagineMode;
        }
        
        ret super.checkExpression_impl(e, m);
      }
    };
    c.input = s;
    c.recentHistory = recentHistory;
    c.evaluator = func(Exp e, NLLogicChecker_v2.Matching m) -> S { evalExp(e, m) };
    
    if (collectCheckingLog) {
      checkingLog = new L;
      nlLogic_collectCheckingLog(c, checkingLog);
    }
    
    Pair<L<IfThen>, LS> rulesAndFacts = getRulesAndFacts();
    c.facts = rulesAndFacts.b;
    L<IfThen> rules = rulesAndFacts.a;
    
    final new L<RuleWithParams> battleSpace;

    applyNLLogicFacts_v4_verbose.set(debug);
    applyNLLogicFacts_v4(c, voidfunc(IfThen rule, NLLogicChecker_v2.Matching m) {
      // Rule fired!
      
      battleSpace.add(new RuleWithParams(rule, m.matches));
    }, rules);
    
    print("Have " + n2(battleSpace, "possible rule"));
    
    nlLogic_battleItOut(battleSpace);
    
    L<RuleWithParams> winners = nlLogic_highestScore(battleSpace, ruleScores);

    fS msgGlobalID = getString(msg, 'globalID);
    print("msgGlobalID=" + msgGlobalID);
    for (RuleWithParams r : winners) {
      print("Firing rule " + r.rule.globalID);
      
      // Save rule fire
      if (nempty(msgGlobalID) && nempty(r.rule.globalID)) {
        S fact = format("Rule * fired on message * at *", r.rule.globalID, msgGlobalID, localDateWithMilliseconds());
         if (nempty(r.matches))
           fact += " with vars " + dropPrefix("lhm", struct(r.matches));
        print("Saving rule fire. Mech mode: " + mechMode());
        print(addToMechList("Telegram Rule Fires", print(fact)));
      }
      
      // Execute rule
      for (Exp e : nlLogic_unrollAnd(r.rule.out)) {
        e = c.apply(e, r.matches);
        if (e cast Func) {
          S name = e.name;
          if (eqOneOf(name, 'output, 'say))
            postMessage(nlLogic_text(e.arg));
          else if (eq(name, 'fact)) {
            S fact = nlLogic_text(e.arg);
            if (imagineMode) {
              if (!containsNL(imaginedFacts, fact)) {
                imaginedFacts.add(fact);
                postMessage("Storing imaginary fact: " + fact);
              }
            } else if (ai_storeActualFact(fact))
              postMessage("Storing fact: " + fact);
          } else if (eq(name, 'storeRule)) {
            S rule = nlLogic_text(e.arg);
            rule = nlLogic_addGlobalID(rule);
            if (mech_changed(appendToMechList_noUniq("NL Logic Examples", "\n" + rule)))
              postMessage("Rule stored");
          } else if (eq(name, 'imagineMode)) {
            imagineMode = match("true", nlLogic_text(e.arg));
            if (!imagineMode) imaginedFacts.clear();
          }
        }
      }
    }
    
    if (collectCheckingLog)
      print("Checking log length: " + l(checkingLog));
  }
 
  Pair<L<IfThen>, LS> getRulesAndFacts() { 
    LS facts = imagineMode ? concatLists(imaginedFacts, mL_facts()) : mL_facts();
    
    LS unparsedRules = ai_unparsedTalkRules();
    
    for (S listName : mL("Rule & Fact Lists"))
      for (S x : splitAtEmptyLines(mL_raw(listName)))
        if (anyJavaTokens(x))
          if (nlLogic_parseRule(x) != null)
            unparsedRules.add(x);
          else
            facts.add(x);

    unparsedRules = sortedByCalculatedField(unparsedRules, func(S s) { jcontains(s, "entity(") });
    L<IfThen> rules = map_pcall nlLogic_parseRule(unparsedRules);
    
    for (S listName : mL("Default active scripts"))
      addAll(rules, nlLogic_loadMechScript(listName));
    
    nlLogic_expandMacros(rules);
    ret pair(rules, facts);
  }
}