!include #1004681 // Concepts

// Anyone's line in a chat (should be called ChatLine I guess)
sclass UserLine extends Concept {
  ELPost post;
  
  *() {}
  *(ELPost *post) { _doneLoading(); }
  
  void _doneLoading() {
    userLines.put(postToID(post), this);
  }
  
  S text() { ret trim(post.text); }
  S s() { ret text(); }
}

// A question posed by this program
sclass Question extends Concept {
  new Ref<UserLine> inResponseTo;
  new Ref<UserLine> userLine;
  
  *() {}
  *(UserLine inResponseTo) {
    this.inResponseTo.set(inResponseTo);
  }
}

// User's answer to one of our questions
sclass UserAnswer extends Concept {
  new Ref<Question> inResponseTo;
  new Ref<UserLine> userLine;
}

// An answer given by this program
sclass Answer extends Concept {
  new Ref<UserLine> userLine;
}

static new Map<S, UserLine> userLines;

static File eventLogFile;
static L<ELPost> posts;

static File lastFile;
static long lastLength;
static int chatIdx;

static void scanChatIfNecessary {
  eventLogFile = latestEventLogFile();
  long l = eventLogFile.length();
  bool sameFile;
  if (!((sameFile = sameFile(eventLogFile, lastFile)) && l == lastLength)) {
    lastFile = eventLogFile;
    lastLength = l;
    posts = scanEventLogForPosts(eventLogFile);
    psl(posts);
    if (!sameFile) chatIdx = 0;
    scanChat();
    chatIdx = l(posts);
  }
}

static void scanChat {
  // scan over all new posts in chat
  
  for (int i = chatIdx; i < l(posts); i++) {
    ELPost p = posts.get(i);
    parsePossibleAnswer(i);
    processNewUserLine(getUserLine(p));
  }
}
    
static void parsePossibleAnswer(int chatIdx) {
  ELPost p = posts.get(chatIdx);
  S s = trim(p.text);
  if (startsWith(s, "@")) {
    s = substring(s, 1);
    int i = min(xIndexOf(s, ' '), xIndexOf(s, ':'));
    S n = substring(s, 0, i);
    if (!isInteger(n)) ret;
    S answer = trimDropPrefixTrim(":", substring(s, i));
    int questionIdx = chatIdx-parseInt(n);
    registerUserAnswer(chatIdx, questionIdx, answer);
  } else if (findBackRef(getUserLine(p), Question.class) == null) {
    registerUserAnswer(chatIdx, chatIdx-1, s);
  }
}

static void registerUserAnswer(int chatIdx, int questionIdx, S answer) {
  ELPost p = posts.get(chatIdx);
  ELPost q = get(posts, questionIdx);
  if (q == null)
    print("Didn't find question to answer " + quote(answer));
  else {
    print("Possible answer: " + q.text + " => " + quote(answer));
    UserLine ulQ = getUserLine(q);
    Question qu = findBackRefOfType(ulQ, Question.class);
    if (qu == null)
      print("  Wasn't our question");
    else {
      UserLine ul = getUserLine(p);
      UserAnswer ua = findBackRefOfType(ul, UserAnswer.class);
      if (ua != null)
        print("User answer already registered.");
      else {
        ua = new UserAnswer();
        ua.userLine.set(ul);
        ua.inResponseTo.set(qu);
        print("  Registered user answer as " + ua.id);
      }
    }
  }
}

static S postToID(ELPost p) {
  ret p.chatTime + ": " + p.text;
}

static UserLine getUserLine(ELPost p) {
  UserLine ul = userLines.get(postToID(p));
  if (ul == null)
    ul = new UserLine(p); // automatically adds to userLines index
  ret ul;
}

static UserLine postToChat(S text) {
  S chatTime = matchOK(sendToLocalBot("Chat.", "please post * to chat file *",
    text, f2s(eventLogFile)));
  if (chatTime == null) null;
  new ELPost post;
  post.chatTime = chatTime;
  post.text = text;
  ret getUserLine(post);
}

static void action {
  while licensed {
    pcall {
      scanChatIfNecessary();
    }
    
    pcall {
      dbActions();
    }
    
    sleepSeconds(1);
  }
}