!759

static Map<S, L<S>> thescripts = synchroTreeMap();

static class PerUser {
  S dialogID;
  ScriptState scriptState;
}

static class ScriptState {
  S scriptID;
  long position;
  
  *(S *scriptID) {}
  *() {}
}

static new Map<S, PerUser> perUserMap;
static new ThreadLocal<PerUser> puCurrent;
static new ThreadLocal<ScriptState> scriptStateCurrent;

static new L<S> snippetIDs;

static O mainBot;
  
p {
  load("snippetIDs");
  
  reload();
  
  load("perUserMap");
  makeBot("A Dialog Bot");
}

// does not increase the index
static FC parseFunctionCall() {
  ret parseFunctionCall(currentScriptLine());
}

static S currentScriptLine() {
  int l = l(thescript());
  int idx = (int) (scriptState().position % l);
  ret thescript().get(idx);
}

synchronized answer {
  // init per-user stuff
  
  S dialogID = cast call(mainBot, "getDialogID");
  
  if "get dialog id" {
    ret structure(dialogID);
  }
  
  if "dialog engine: number of users" {
    ret str(l(perUserMap));
  }
  
  if (dialogID == null) ret null; // need a dialog id now
  PerUser pu = perUserMap.get(dialogID);
  if (pu == null) {
    pu = new PerUser;
    pu.dialogID = dialogID;
    printFormat("Created new dialog: *", dialogID);
    perUserMap.put(dialogID, pu);
  }
  puCurrent.set(pu);
  
  // admin stuff
  
  if "print scripts"
    ret structure(thescripts);
    
  if "list scripts"
    ret structure(snippetIDs);
    
  if "add dialog script *" {
    setAdd(snippetIDs, formatSnippetID(m.unq(0)));
    save("snippetIDs");
    reload();
    ret "OK, scripts now: " + structure(snippetIDs);
  }
  
  if "remove dialog script *" {
    snippetIDs.remove(formatSnippetID(m.unq(0)));
    save("snippetIDs");
    reload();
    ret "OK, scripts now: " + structure(snippetIDs);
  }
  
  if "reload dialogs" {
    reload();
    ret "OK, " + l(snippetIDs) + " dialog scripts reloaded.";
  }
  
  // try current script first
  
  pcall {
    if (u().scriptState != null && thescript() != null) {
      S answer = answerUsingScript(u().scriptState, s);
      if (!empty(answer)) ret answer;
    }
  }
  
  // try all scripts
  
  for (S scriptID : thescripts.keySet()) pcall {
    ScriptState scriptState = new ScriptState(scriptID);
    S answer = answerUsingScript(scriptState, s);
    if (!empty(answer)) {
      u().scriptState = scriptState; // Switch to new script
      save("perUserMap");
      ret answer;
    }
  }
}

static synchronized S answerUsingScript(ScriptState scriptState, S s) {
  scriptStateCurrent.set(scriptState);
  int safety = 0;
  while (safety++ < 1000) try {
    FC fc = parseFunctionCall();
    S f = fc.f;
    if (eq(f, "match")) {
      S pat = getString(fc.args, 0);
      if (!match(pat, s)) {
        softFail("I only understand: *", pat);
        null;
      }
      nextPosition(); // only after match succeeds, otherwise stay at that point
    } else if (eq(f, "say")) {
      nextPosition();
      S answer = getString(fc.args, 0);
      ret answer;
    } else
      throw fail("Unknown function in script: *", fc.f);
  } catch (Throwable e) {
    printFormat("Was parsing: *", currentScriptLine());
    throw asRuntimeException(e);
  }
  throw fail("hard limit reached - 1000 script lines at once - possible endless loop?");
}

// a parsed function call
static class FC {
  int idx; // index of next token
  S f;
  new L args;
}

static FC parseFunctionCall(S s) {
  L<S> tok = javaTok(s);
  new FC fc;
  fc.f = assertIsIdentifier(tok.get(1));
  int i = 5;
  assertEquals("(", tok.get(3));
  while (i < l(tok) && !eq(tok.get(i), ")")) {
    fc.args.add(unquote(tok.get(i)));
    i += 2;
    if (tok.get(i).equals(",")) // otherwise it's kinda mangled, eh. well! we just keep on parsing...
      i += 2;
  }
  if (eq(tok.get(i), ")")) // we even allow a missing closing bracket!
    i += 2;
  fc.idx = i; // save index so some other parser can continue parsing
  ret fc;
}

static void nextPosition() {
  ++scriptState().position;
  save("perUserMap"); // might not always be necessary
  print("Position in script now: " + scriptState().position % l(thescript()));
}

// get per-user data for current thread
static PerUser u() {
  ret puCurrent.get();
}

static ScriptState scriptState() {
  ret scriptStateCurrent.get();
}

static L<S> thescript() {
  S scriptID = scriptState().scriptID;
  ret thescripts.get(scriptID);
}

static void loadMore() {
  for (S snippetID : snippetIDs) pcall {
    L<S> lines = toLinesFullTrim(loadSnippet(snippetID));
    new L<S> currentScript;
    int i = 0;
    for (; i < l(lines); i += 2) {
      S q = lines.get(i);
      if (q.startsWith("-")) {
        if (nempty(currentScript))
          thescripts.put(snippetID + "-" + i, currentScript);
        currentScript = litlist();
        --i;
      } else {
        S a = lines.get(i+1);
        a = dropPrefix("eleu:", a).trim();
        currentScript.addAll(litlist(
          "match(" + quote(q) + ");",
          "say(" + quote(a) + ");"));
      }
    }
    if (nempty(currentScript))
      thescripts.put(snippetID + "-" + i, currentScript);
  }
}

static void reload() {
  thescripts.clear();
  thescripts.put("1", toLinesFullTrim([[
    match("Hi Eleutheria");
    say("Hi there!");
    match("Hi Eleutheria");
    say("You have said that before :)");
  ]]));
  
  thescripts.put("2", toLinesFullTrim([[
    match("how old are you");
    say("less than one year i believe");
    match("really?");
    say("yeah");
  ]]));
  
  loadMore();
}