!7

// include #1007762 // new lispCalculateDeep

sS theFacts = [[

  Fibonacci number n is Fibonacci number n-1 plus Fibonacci number n-2 if n > 2.

  There is no Fibonacci number with a negative index.

  There is no Fibonacci number 0.

  Fibonacci number 1 is 1.

  Fibonacci number 2 is 1.

  // Some technical stuff

  gmtzfidalveipfyx feyhbrhdeovmbvaw amcmxkgwhivbouqs

  pqnfhkzxoqkaoyqk sppxbuuqeetjmzuo

]];

sS theRiddle = [[

  What is Fibonacci number 0?

  What is Fibonacci number 1?

  What is Fibonacci number 2?

  What is Fibonacci number 3?

  What is Fibonacci number 4?

]];

static S concepts = [[

  ["feyhbrhdeovmbvaw", "There is no X."],

  ["mtsrzasaoxrmicch", "X is Y if Z."],

  ["fgvvrzypbkqomktd", "X is Y."],

  ["sppxbuuqeetjmzuo", "X plus Y"],

  ["devwldetfsfylnod", "X with a negative index"],

  ["rgsamtbrhpcqowko", "Fibonacci number X"],

  ["jxcubqjtqykhfvyo", "X - Y", "as in minus"],

  ["wdbphzfoxwlrhdyl", "X > Y"],

  ["urfkhwfasdaqqqse", "What is X?"],

  ["pqnfhkzxoqkaoyqk", "Operation X should be expanded."],

  ["amcmxkgwhivbouqs", "Something that doesn't exist"],

  ["yissyloatogavyuu", "Fibonacci number"],

  ["gmtzfidalveipfyx", "Marker X implies label Y."]

]];

!include #1007689 // Web v2

static int saveInterval = 60000;

static volatile new Web web;

static L<Lisp> facts;

static long lastSave, sizeSaved;

extend Web {

  volatile transient bool cancelled, calculating;

}

p-tt {

  setConsoleTitle(programTitle());

  load("web"); lastSave = sysNow();

  setFrameHeight(consoleFrame(), 400);

  centerConsole();

  //magellan();

  //graphite();

  //mistAqua();

  //moderateTheme();

  sahara();

  swing {

    setConsoleInput("What is Fibonacci number 500?");

    consoleAddAskButton();

    focusConsole();

    final JLabel lblBrainSize = jRightAlignedLabel();

    addToConsole2(withMargin(centerAndEast(lblBrainSize,

      withLeftMargin(jbutton("Reset", "reset")))));

    awtEvery(lblBrainSize, 1000, r {

      lblBrainSize.setText("Brain Size: " + toM(fileSize(programFile("web.structure")), 1) + " MB");

    });

    awtCalcEvery(lblBrainSize, 1000, 1000, r {

      if (web.calculating) ret;

      int webSize = web.count();

      if (shouldSave(webSize, false)) saveWeb(webSize);

    });

  }

  aiEnhancements();

  aiConcepts_noAutoClear();

  useConceptsDump(concepts);

  set englishToConceptLanguage_useBrackets;

  facts = clParse(linesToCL(theFacts));

  print(theFacts);

  useFacts(theFacts);

  //printNumberedLines(facts);

  firstRiddle();

  makeBot();

  notDone();

}

svoid firstRiddle {

  print();

  for (S rid : toLinesFullTrim(theRiddle)) {

    print("? " + rid);

    print("  " + answer(rid));

  }

  print();

}

static int webSize() { ret web.count(); }

sbool shouldSave(int webSize, bool checkInterval) {

  ret webSize != sizeSaved &&

    (!checkInterval || sysNow() >= lastSave+saveInterval);

}

svoid saveWeb(int webSize) {

  save("web");

  sizeSaved = webSize;

  lastSave = sysNow();

}

static S answer(S rid) {

  web.calculating = true;

  try {

    ret answerImpl(rid);

  } finally {

    web.calculating = false;

  }

}

static S answerImpl(S rid) {

  if (eq(rid, "web")) { print(web); ret "OK"; }

  Web web = main.web;

  Lisp riddle = clParse(englishToConceptLanguage(rid));

  //print("# " + riddle);

  if (!riddle.is("urfkhwfasdaqqqse", "mrhggsmuykeceghd")) ret "huh?"; // What is X? // What is the decimal representation of X?

  Lisp mainConcept = riddle.get(0);

  // Make web

  web.node(mainConcept);

  web.relations(facts);

  int webSize = web.count();

  int cursor = 0;

  while licensed {

    if (web.cancelled) ret "cancelled";

    //print("Web size: " + webSize);

    if (shouldSave(webSize, true)) {

      printWithoutNL("S");

      saveWeb(webSize);

    } else

      printWithoutNL(".");

    if ((++cursor % 60) == 0) print();

    CriticalAction action = beginCriticalAction("Web Update");

    try {

      web_expandMarkers2(web);

      web_expandOperations2(web);

      for (LispStatement ls : lispStatementsByHead("mtsrzasaoxrmicch")) {

        if (web.cancelled) ret "cancelled";

        Lisp rule = ls.term, x = rule.get(0);

        //print("Pot size: " + l(web.getPot(ls.globalID)));

        for (WebNode node : web.clearPot(ls.globalID)) {

          for (Lisp lbl : cloneList(node.labels)) {

            //print("Matching " + x + " and " + lbl);

            Map<S, Lisp> matches = lispMatch(x, lbl, ll("n"));

            if (matches != null) {

              //print("Rule match: " + struct(matches));

              Lisp bla = lispReplaceVars(rule.get(2), matches);

              if (checkACondition(bla)) {

                bla = lispReplaceVars(rule.get(1), matches);

                bla = lispCalculateDeep(bla);

                bla = web_insertNumbers(web, bla);

                //print("bla: " + bla);

                bla = lispCalculateDeep(bla);

                if (lispIsInt(bla)) {

                  node.addLabel(bla); // Found!

                  //pot.remove(node);

                } else {

                  //print("Condition OK! Evaluating: " + bla);

                  web.node(bla);

                  // Place into pot again

                  web.getPot(ls.globalID).add(node);

                }

              }

            }

          }

        }

        //print("Node: " + node + ", condition: " + condition);

      }

    } finally {

      action.done();

    }

    int n = web.count();

    if (n == webSize) break;

    webSize = n;

  }

  print();

  // print question again

  if (cursor / 60 >= 10)

    print("? " + rid);

  // Answer question

  L<Lisp> l = listWithout(web.findNode(mainConcept).labels, mainConcept);

  //print("Labels: " + l);

  S s = chooseALabelToReturn(l);

  s = or2(conceptLanguageToEnglish(unquote(s)), "I don't know");

  ret s;

}

sS chooseALabelToReturn(L<Lisp> ll) {

  L<S> l = map(f clUnparse, ll);

  //print("  Labels: " + l);

  S s = findInteger(l);

  if (s == null) s = firstGlobalID(l);

  //if (s == null) s = random(l);

  if (s == null) ret s = first(l);

  ret s;

}

sbool checkACondition(Lisp l) false on exception {

  ret lispCalculateDeep(l).is("true");

}

svoid cleanMeUp {

  while (criticalActionsInFlight()) sleep(5);

  if (sizeSaved != web.count())

    save("web");

}

svoid reset {

  if (!confirmOKCancel("Really clear the Fibonacci brain?")) ret;

  web.cancelled = true;

  CriticalAction action = beginCriticalAction("Resetting Brain");

  try {

    web = new Web;

    sizeSaved = 0;

    save("web");

  } finally {

    action.done();

  }

  clearConsole();

  firstRiddle();

}