!752
!1002672 // pircbot library

import org.jibble.pircbot.*;

!include #1002680 // modified PircBot

static boolean useBouncer = true;

static S server = useBouncer ? "second.tinybrain.de" : "irc.freenode.net";
static S channel = /*"##linux"*/"#pircbot";
static S name = "Lookie";
static int reconnectTimeout1 = 60; // seconds after which to send a ping to server
static int reconnectTimeout2 = 80; // seconds after which we try to reconnect

static Map<S, PersistentLog<Map>> bulk = new TreeMap; // key = channel (with "#")

static MyBot bot;

p {
  thread "IRC Log-In" {
    bot = new MyBot;
    bot.setVerbose(true);
    print("PircBot connecting to " + server);
    bot.connect(server);
    print("PircBot connect issued");
    
    autoReconnect(bot);
  }
}

static class MyBot extends PircBot {
  long lastReceived;
  
  MyBot() {
    setName(name);
    //setRealName(name); // newer version of PircBot only
    setLogin(name);
    setVersion(name);
    setFinger("");
    setAutoNickChange(true);
  }
  
  public void handleLine(String line) {
    getLog(channel).add(litmap("time", smartNow(), "line", line));
    super.handleLine(line);
    lastReceived = now();
  }
  
  public void onConnect() {
    print("PircBot onConnect useBouncer=" + useBouncer);
    if (useBouncer) {
      S bouncerLogin = loadSecretTextFileMandatory("bouncer-login").trim();
      print("Logging in to bouncer");
      bot.sendMessage("root", bouncerLogin.trim());
      
      // session should already be there, so resume it
      print("Resuming bouncer session");
      bot.sendMessage("root", "connect freenode");
    }
    
    bot.joinChannel(channel);
  }
}

static void autoReconnect(final MyBot bot) {
  thread "PircBot Auto-Reconnect" {
    while (licensed()) {
      sleepSeconds(10);
      
      if (now() >= bot.lastReceived + reconnectTimeout2*1000)
        try {
          print("PircBot: Trying to reconnect...");
          hardClose(bot);
          
          sleepSeconds(1); // allow for input thread to halt
          
          bot.reconnect();
        } catch (Exception e) {
          print("Reconnect fail: " + e);
          // Couldn't reconnect!
        }
      else if (now() >= bot.lastReceived + reconnectTimeout1*1000)
        bot.sendRawLine("TIME"); // send something
    }
  }
}

static Socket getSocket(PircBot bot) {
  ret (Socket) get(get(bot, "_inputThread"), "_socket");
}

answer {
  if "irc log size *"
    exceptionToUser { ret lstr(getLog(m.unq(0))); }
}

static synchronized PersistentLog<Map> getLog(S channelName) {
  checkChannelName(channelName);
  PersistentLog log = bulk.get(channelName);
  if (log == null)
    bulk.put(channelName, log = new PersistentLog(channelName + ".log"));
  ret log;
}

static S checkChannelName(S s) {
  assertTrue(nempty(s));
  for (int i = 0; i < l(s); i++)
    if (!(
      "#!".indexOf(s.charAt(i)) >= 0 || Character.isLetterOrDigit(s.charAt(i))))
      fail(s);
  ret s;
}

static void hardClose(PircBot bot) {
  if (bot == null) ret;
  
  try {
    //bot.disconnect();
    getSocket(bot).close();
  }
  catch (Exception e) { print(str(e)); }
}

static void cleanMeUp() {
  hardClose(bot);
}

static long smartNow_last;

static long smartNow() {
  ret smartNow_last = max(smartNow_last + 1, now());
}