#!/usr/bin/env ruby
=begin

# lig.rb

Lingr IRC Gateway - IRC Gateway to Lingr ( http://www.lingr.com/ )

## Launch

  $ ruby lig.rb # daemonized

If you want to help:

  $ ruby lig.rb --help
  Usage: examples/lig.rb [opts]


  Options:
      -p, --port [PORT=16669]          port number to listen
      -h, --host [HOST=localhost]      host name or IP address to listen
      -l, --log LOG                    log file
      -a, --api_key API_KEY            Your api key on Lingr
          --debug                      Enable debug mode

## Configuration

Configuration example for Tiarra ( http://coderepos.org/share/wiki/Tiarra ).

  lingr {
    host: localhost
    port: 16669
    name: username@example.com (Email on Lingr)
    password: password on Lingr
    in-encoding: utf8
    out-encoding: utf8
  }

Set your email as IRC 'real name' field, and password as server password.
This does not allow anonymous connection to Lingr.
You must create a account on Lingr and get API key (ask it first time).

## Client

This gateway sends multibyte nicknames at Lingr rooms as-is.
So you should use a client which treats it correctly.

Recommended:

 * LimeChat for OSX ( http://limechat.sourceforge.net/ )
 * Irssi ( http://irssi.org/ )
 * (gateway) Tiarra ( http://coderepos.org/share/wiki/Tiarra )

## Nickname/Mask

nick -> nickname in a room.
o_id -> occupant_id (unique id in a room)
u_id -> user_id (unique user id in Lingr)

 * Anonymous User: <nick>|<o_id>!anon@lingr.com
 * Logged-in User: <nick>|<o_id>!<u_id>@lingr.com
 * Your:           <nick>|<u_id>!<u_id>@lingr.com

So you can see some nicknames in same user, but it is needed for
nickname management on client.

(Lingr allows different nicknames between rooms in a same user, but IRC not)

## Licence

Ruby's by cho45

## 備考

このクライアントで 1000speakers への応募はできません。lingr.com から行ってください。

=end

$LOAD_PATH << File.dirname(__FILE__)
$LOAD_PATH << "lib"
$LOAD_PATH << "../lib"

require "rubygems"
require "lingr"
require "net/irc"
require "pit"
require "mutex_m"


class LingrIrcGateway < Net::IRC::Server::Session
  def server_name
    "lingrgw"
  end

  def server_version
    "0.0.0"
  end

  def initialize(*args)
    super
    @channels = {}
    @channels.extend(Mutex_m)
  end

  def on_user(m)
    super
    @real, *@copts = @real.split(/\s+/)
    @copts ||= []

    # Tiarra sends prev nick when reconnects.
    @nick.sub!(/\|.+$/, "")

    log "Hello #{@nick}, this is Lingr IRC Gateway."
    log "Client Option: #{@copts.join(", ")}"
    @log.info "Client Option: #{@copts.join(", ")}"
    @log.info "Client initialization is completed."

    @lingr = Lingr::Client.new(@opts.api_key)
    @lingr.create_session('human')
    @lingr.login(@real, @pass)
    @session_observer = Thread.start do
      loop do
        begin
          @log.info "Verifying session..."
          @log.info "Verifed session => #{@lingr.verify_session.inspect}"
        rescue Lingr::Client::APIError => e
          @log.info "Verify session raised APIError<#{e.code}:#{e.message}>. Try to re-create session."
          @lingr.create_session('human')
          @lingr.login(@real, @pass)
        rescue Exception => e
          @log.info "Error on verify_session: #{e.inspect}"
        end
        sleep 9 * 60
      end
    end
    @user_info = @lingr.get_user_info

    prefix = make_ids(@user_info)
    @user_info["prefix"] = prefix
    post @prefix, NICK, prefix.nick

  rescue Lingr::Client::APIError => e
    case e.code
    when 105
      post nil, ERR_PASSWDMISMATCH, @nick, "Password incorrect"
    else
      log "Error: #{e.code}: #{e.message}"
    end
    finish
  end

  def on_privmsg(m)
    target, message = *m.params
    if @channels.key?(target.downcase)
      @lingr.say(@channels[target.downcase][:ticket], message)
    else
      post nil, ERR_NOSUCHNICK, @user_info["prefix"].nick, target, "No such nick/channel"
    end
  rescue Lingr::Client::APIError => e
    log "Error: #{e.code}: #{e.message}"
    log "Coundn't say to #{target}."
    on_join(Message.new(nil, "JOIN", [target])) if e.code == 102 # invalid session
  end

  def on_notice(m)
    on_privmsg(m)
  end

  def on_whois(m)
    nick = m.params[0]
    chan = nil
    info = nil

    @channels.each do |k, v|
      if v[:users].key?(nick)
        chan = k
        info = v[:users][nick]
        break
      end
    end

    if chan
      prefix      = info["prefix"]
      real_name   = info["description"].to_s
      server_info = "Lingr: type:#{info["client_type"]} source:#{info["source"]}"
      channels    = [info["client_type"] == "human" ? "@#{chan}" : chan]
      me          = @user_info["prefix"]

      post nil, RPL_WHOISUSER,     me.nick, prefix.nick, prefix.user, prefix.host, "*", real_name
      post nil, RPL_WHOISSERVER,   me.nick, prefix.nick, prefix.host, server_info
      # post nil, RPL_WHOISOPERATOR, me.nick, prefix.nick, "is an IRC operator"
      # post nil, RPL_WHOISIDLE,     me.nick, prefix.nick, idle, "seconds idle"
      post nil, RPL_WHOISCHANNELS, me.nick, prefix.nick, channels.join(" ")
      post nil, RPL_ENDOFWHOIS,    me.nick, prefix.nick, "End of WHOIS list"
    else
      post nil, ERR_NOSUCHNICK, me.nick, nick, "No such nick/channel"
    end
  rescue Exception => e
    @log.error e.inspect
    e.backtrace.each do |l|
      @log.error "\t#{l}"
    end
  end

  def on_who(m)
    channel = m.params[0]
    return unless channel

    info = @channels.synchronize { @channels[channel.downcase] }
    me   = @user_info["prefix"]
    res  = @lingr.get_room_info(info[:chan_id], nil, info[:password])
    res["occupants"].each do |o|
      next unless o["nickname"]
      u_id, o_id, prefix = *make_ids(o, true)
      op = (o["client_type"] == "human") ? "@" : ""
      post nil, RPL_WHOREPLY, me.nick, channel, o_id, "lingr.com", "lingr.com", prefix.nick, "H*#{op}", "0 #{o["description"].to_s.gsub(/\s+/, " ")}"
    end
    post nil, RPL_ENDOFWHO, me.nick, channel
  rescue Lingr::Client::APIError => e
    log "Maybe gateway don't know password for channel #{channel}. Please part and join."
  end

  def on_join(m)
    channels = m.params[0].split(/\s*,\s*/)
    password = m.params[1]
    channels.each do |channel|
      next if @channels.key? channel.downcase
      begin
        @log.debug "Enter room -> #{channel}"
        res = @lingr.enter_room(channel.sub(/^#/, ""), @nick, password)
        res["password"] = password

        @channels.synchronize do
          create_observer(channel, res)
        end
      rescue Lingr::Client::APIError => e
        log "Error: #{e.code}: #{e.message}"
        log "Coundn't join to #{channel}."
        if e.code == 102
          log "Invalid session... prompt the client to reconnect"
          finish
        end
      rescue Exception => e
        @log.error e.inspect
        e.backtrace.each do |l|
          @log.error "\t#{l}"
        end
      end
    end
  end

  def on_part(m)
    channel = m.params[0]
    info    = @channels[channel.downcase]
    prefix  = @user_info["prefix"]

    if info
      info[:observer].kill
      @lingr.exit_room(info[:ticket])
      @channels.delete(channel.downcase)

      post prefix, PART, channel, "Parted"
    else
      post nil, ERR_NOSUCHCHANNEL, prefix.nick, channel, "No such channel"
    end
  rescue Lingr::Client::APIError => e
    unless e.code == 102
      log "Error: #{e.code}: #{e.message}"
      log "Coundn't say to #{target}."

      @channels.delete(channel.downcase)
      post prefix, PART, channel, "Parted"
    end
  end

  def on_disconnected
    @channels.each do |k, info|
      info[:observer].kill
    end
    @session_observer.kill rescue nil
    begin
      @lingr.destroy_session
    rescue
    end
  end

  private

  def create_observer(channel, response)
    Thread.start(channel, response) do |chan, res|
      myprefix = @user_info["prefix"]
      if @channels[chan.downcase]
        @channels[chan.downcase][:observer].kill rescue nil
      end
      @channels[chan.downcase] = {
        :ticket   => res["ticket"],
        :counter  => res["room"]["counter"],
        :o_id     => res["occupant_id"],
        :chan_id  => res["room"]["id"],
        :password => res["password"],
        :users    => res["occupants"].reject {|i| i["nickname"].nil? }.inject({}) {|r,i|
          i["prefix"] = make_ids(i)
          r.update(i["prefix"].nick => i)
        },
        :hcounter => 0,
        :observer => Thread.current,
      }

      post server_name, TOPIC, chan, "#{res["room"]["url"]} #{res["room"]["description"]}"
      post myprefix, JOIN, channel
      post server_name, MODE, channel, "+o", myprefix.nick
      post nil, RPL_NAMREPLY,   myprefix.nick, "=", chan, @channels[chan.downcase][:users].map{|k,v|
        v["client_type"] == "human" ? "@#{k}" : k
      }.join(" ")
      post nil, RPL_ENDOFNAMES, myprefix.nick, chan, "End of NAMES list"

      info = @channels[chan.downcase]
      while true
        begin
          @log.debug "observe_room<#{info[:counter]}><#{chan}> start <- #{myprefix}"
          res = @lingr.observe_room info[:ticket], info[:counter]

          info[:counter] = res["counter"] if res["counter"]

          (res["messages"] || []).each do |m|
            next if m["id"].to_i <= info[:hcounter]

            u_id, o_id, prefix = *make_ids(m, true)

            case m["type"]
            when "user"
              # Don't send my messages.
              unless info[:o_id] == o_id
                post prefix, PRIVMSG, chan, m["text"]
              end
            when "private"
              # TODO not sent from lingr?
              post prefix, PRIVMSG, chan, ctcp_encoding("ACTION Sent private: #{m["text"]}")

            # system:{enter,leave,nickname_changed} should not be used for nick management.
#            when "system:enter"
#              post prefix, PRIVMSG, chan, ctcp_encoding("ACTION #{m["text"]}")
#            when "system:leave"
#              post prefix, PRIVMSG, chan, ctcp_encoding("ACTION #{m["text"]}")
#            when "system:nickname_change"
#              post prefix, PRIVMSG, chan, ctcp_encoding("ACTION #{m["text"]}")
            when "system:broadcast"
              post "system.broadcast",  NOTICE, chan, m["text"]
            end

            info[:hcounter] = m["id"].to_i if m["id"]
          end

          if res["occupants"]
            enter = [], leave = []
            newusers = res["occupants"].reject {|i| i["nickname"].nil? }.inject({}) {|r,i|
              i["prefix"] = make_ids(i)
              r.update(i["prefix"].nick => i)
            }


            nickchange = newusers.inject({:new => [], :old => []}) {|r,(k,new)|
              old = info[:users].find {|l,old|
                # same occupant_id and different nickname
                # when nickname was changed and when un-authed user promoted to authed user.
                new["prefix"] != old["prefix"] && new["id"] == old["id"]
              }
              if old
                old = old[1]
                post old["prefix"], NICK, new["prefix"].nick
                r[:old] << old["prefix"].nick
                r[:new] << new["prefix"].nick
              end
              r
            }

            entered = newusers.keys - info[:users].keys - nickchange[:new]
            leaved  = info[:users].keys - newusers.keys - entered - nickchange[:old]

            leaved.each do |leave|
              leave = info[:users][leave]
              post leave["prefix"], PART, chan, ""
            end

            entered.each do |enter|
              enter  = newusers[enter]
              prefix = enter["prefix"]
              post prefix, JOIN, chan
              if enter["client_type"] == "human"
                post server_name, MODE, chan, "+o", prefix.nick
              end
            end

            info[:users] = newusers
          end


        rescue Lingr::Client::APIError => e
          case e.code
          when 100
            @log.fatal "BUG: API returns invalid HTTP method"
            exit 1
          when 102
            @log.error "BUG: API returns invalid session. Prompt the client to reconnect."
            finish
          when 104
            @log.fatal "BUG: API returns invalid response format. JSON is unsupported?"
            exit 1
          when 109
            @log.error "Error: API returns invalid ticket. Rejoin this channel..."
            on_part(Message.new(nil, PART, [chan, res["error"]["message"]]))
            on_join(Message.new(nil, JOIN, [chan, info["password"]]))
          when 114
            @log.fatal "BUG: API returns no counter parameter."
            exit 1
          when 120
            @log.error "Error: API returns invalid encoding. But continues."
          when 122
            @log.error "Error: API returns repeated counter. But continues."
            info[:counter] += 10
            log "Error: repeated counter. Some message may be ignored..."
          else
            # may be socket error?
            @log.debug "observe failed : #{res.inspect}"
            log "Error: #{e.code}: #{e.message}"
          end
        rescue Timeout::Error
          # pass
        rescue JSON::ParserError => e
          @log.error e
          info[:counter] += 10
          log "Error: JSON::ParserError Some message may be ignored..."
        rescue Exception => e
          @log.error e.inspect
          e.backtrace.each do |l|
            @log.error "\t#{l}"
          end
        end
        sleep 1
      end
    end
  end

  def log(str)
    str.gsub!(/\s/, " ")
    begin
      post nil, NOTICE, @user_info["prefix"].nick, str
    rescue
      post nil, NOTICE, @nick, str
    end
  end

  def make_ids(o, ext=false)
    u_id  = o["user_id"] || "anon"
    o_id  = o["occupant_id"] || o["id"]
    nick  = (o["default_nickname"] || o["nickname"]).gsub(/\s+/, "")
    if o["user_id"] == @user_info["user_id"]
      nick << "|#{o["user_id"]}"
    else
      nick << "|#{o["user_id"] ? o_id : "_"+o_id}"
    end
    pref = Prefix.new("#{nick}!#{u_id}@lingr.com")
    ext ? [u_id, o_id, pref] : pref
  end
end


if __FILE__ == $0
  require "rubygems"
  require "optparse"
  require "pit"

  opts = {
    :port  => 16669,
    :host  => "localhost",
    :log   => nil,
    :debug => false,
    :foreground => false,
  }

  OptionParser.new do |parser|
    parser.instance_eval do
      self.banner  = <<-EOB.gsub(/^\t+/, "")
        Usage: #{$0} [opts]

      EOB

      separator ""

      separator "Options:"
      on("-p", "--port [PORT=#{opts[:port]}]", "port number to listen") do |port|
        opts[:port] = port
      end

      on("-h", "--host [HOST=#{opts[:host]}]", "host name or IP address to listen") do |host|
        opts[:host] = host
      end

      on("-l", "--log LOG", "log file") do |log|
        opts[:log] = log
      end

      on("-a", "--api_key API_KEY", "Your api key on Lingr") do |key|
        opts[:api_key] = key
      end

      on("--debug", "Enable debug mode") do |debug|
        opts[:log]   = $stdout
        opts[:debug] = true
      end

      on("-f", "--foreground", "run foreground") do |foreground|
        opts[:log]        = $stdout
        opts[:foreground] = true
      end

      parse!(ARGV)
    end
  end

  opts[:logger] = Logger.new(opts[:log], "daily")
  opts[:logger].level = opts[:debug] ? Logger::DEBUG : Logger::INFO

  def daemonize(foreground=false)
    [:INT, :TERM, :HUP].each do |sig|
      Signal.trap sig, "EXIT"
    end
    return yield if $DEBUG || foreground
    Process.fork do
      Process.setsid
      Dir.chdir "/"
      File.open("/dev/null") {|f|
        STDIN.reopen  f
        STDOUT.reopen f, "w"
        STDERR.reopen f, "w"
      }
      yield
    end
    exit! 0
  end

  opts[:api_key] = Pit.get("lig.rb", :require => {
    "api_key" => "API key of Lingr"
  })["api_key"] unless opts[:api_key]

  daemonize(opts[:debug] || opts[:foreground]) do
    Net::IRC::Server.new(opts[:host], opts[:port], LingrIrcGateway, opts).start
  end

end