#!/usr/bin/env ruby
# -*- mode: ruby -*-

$KCODE = 'u'

require 'pathname'

$LOAD_PATH.unshift(Pathname($0).dirname.parent.join('lib'))

require 'rubygems'
require 'digest'
require 'friendfeed'
require 'friendfeed/unofficial'
require 'main'
require 'mechanize'
require 'uri'
require 'tempfile'
require 'twitter'
require 'yaml'
require 'yaml/store'

MYNAME = File.basename($0)

TWITTER_URI = URI.parse('http://twitter.com/')

def ConfigDir()
  $config_dir ||=
    begin
      config_dir = File.expand_path('~/.%s' % MYNAME)
      if !File.directory?(config_dir)
        Dir.mkdir(config_dir, 0700)
      end
      config_dir
    end
end

def ConfigFile()
  $config_file ||= File.join(ConfigDir(), 'config.yml')
end

def Config(keypath, default = :omitted)
  $config ||= YAML.load_file(ConfigFile())

  keypath.split('.').inject($config) { |hash, key|
    hash.is_a?(Hash) or raise TypeError
    hash.fetch(key)
  }
rescue => e
  return default if default != :omitted
  
  STDERR.print <<EOM
The key "#{keypath}" is missing in #{ConfigFile()}.
Please run "#{$0} config" and fill out necessary information.
EOM
  exit 1
end

def putinfo(fmt, *args)
  STDERR.puts sprintf(fmt, *args)
end

def Status(key)
  $status ||= YAML::Store.new(File.join(ConfigDir(), 'status.yml'))
  if block_given?
    $status.transaction(false) {
      return $status[key] = yield
    }
  else
    $status.transaction(true) {
      return $status[key]
    }
  end
end

def agent
  $agent ||= Mechanize.new
end

def parse_uri(url)
  case url
  when URI
    url
  else
    begin
      URI.parse(url)
    rescue URI::InvalidURIError
      dir, file = File.split(url)
      URI.parse(File.join(dir, URI.escape(file)))
    end
  end
end

def get_file(url)
  uri = parse_uri(url)
  putinfo 'Fetching %s', uri
  agent.get_file(uri)
end

class FriendFeed::Client
  def change_picture_to_url(id, url)
    t = Tempfile.open("picture")
    t.write get_file(url)
    t.close
    File.open(t.path) { |f|
      change_picture(id, f)
    }
    t.unlink
  end
end

def friendfeed_client
  $ff_client ||=
    begin
      username = Config('friendfeed.username')
      password = Config('friendfeed.password')
      putinfo 'Logging in to FriendFeed as %s', username
      FriendFeed::Client.new.login(username, password)
    end
end

class Twitter::Base
  def all_friends
    list = []
    cursor = -1
    loop {
      result = friends(:cursor => cursor)
      break if result.users.nil?
      list.concat(result.users)
      cursor = result[:next_cursor]
      break if cursor.zero?
    }
    list
  end

  def get_profile(name)
    friends(:screen_name => name).first
  end
end

def twitter_client
  $tw_client ||=
    begin
      username = Config('twitter.username')
      password = Config('twitter.password')
      putinfo 'Logging in to Twitter as %s', username
      Twitter::Base.new(Twitter::HTTPAuth.new(username, password))
    end
end

Main {
  description 'Twitter to FriendFeed migration helper'

  def run
    print usage.to_s
  end

  mode 'config' do
    description 'Edit the configuration file'

    def run
      if !File.exist?(ConfigFile())
        File.open(ConfigFile(), 'w') { |f|
          f.print <<EOF
--- 
friendfeed: 
  username: "username"
  password: "password"
twitter: 
  username: "username"
  password: "password"
EOF
        }
      end

      system ENV['VISUAL'] || ENV['EDITOR'] || 'vi', ConfigFile()
    end
  end
  
  mode 'friends' do
    description 'Import Twitter-only friends to FriendFeed as "imaginary friends"'

    def run
      require 'set'

      ffcli = friendfeed_client()

      subscribed_real = Set[]
      subscribed_imag = Set[]

      putinfo "Checking real friends in FriendFeed..."
      ffcli.get_real_friends.each { |profile|
        profile['services'].each { |service|
          url = service['profileUrl'] or next
          if (name = TWITTER_URI.route_to(url).to_s).match(/\A[A-Za-z0-9_]+\z/)
            putinfo 'Found a Twitter friend %s in FriendFeed', name
            subscribed_real << name.downcase
          end
        }
      }

      putinfo "Checking imaginary friends in FriendFeed..."
      ffcli.get_imaginary_friends.each { |profile|
        profile['services'].each { |service|
          url = service['profileUrl'] or next
          if (name = TWITTER_URI.route_to(url).to_s).match(/\A[A-Za-z0-9_]+\z/)
            putinfo 'Found a Twitter friend %s in FriendFeed (imaginary)', name
            subscribed_imag << name.downcase
          end
        }
      }

      putinfo "Checking groups in FriendFeed..."
      ffcli.get_profile['rooms'].each { |room|
        ffcli.get_services(room['nickname']).each { |service|
          url = service['profileUrl'] or next
          if (name = TWITTER_URI.route_to(url).to_s).match(/\A[A-Za-z0-9_]+\z/)
            putinfo 'Found a Twitter friend %s in FriendFeed (group)', name
            subscribed_imag << name.downcase
          end
        }
      }

      Status('friends_subscribed_real') { subscribed_real.sort }
      Status('friends_subscribed_imag') { subscribed_imag.sort }

      (subscribed_real & subscribed_imag).each { |name|
        putinfo 'Duplicated subscription: %s', name
      }

      subscribed = subscribed_real + subscribed_imag

      friends = Set[]
      to_subscribe = Set[]
      to_watch = Set[]
      picture_urls = {}

      twitter_client().all_friends.each { |friend|
        name = friend.screen_name.downcase
        friends << name
        next if subscribed.include?(name)

        if friend.protected
          to_watch << name
        else
          to_subscribe << name
          picture_urls[name] = friend.profile_image_url
        end
      }
      friends << Config('twitter.username')

      Status('friends') { friends.sort }
      Status('friends_to_watch') { to_watch.sort }

      to_watch.each { |name|
        putinfo 'Skipping a protected user %s', name
      }

      to_subscribe.each { |name|
        putinfo 'Creating an imaginary friend for %s', name
        id = ffcli.create_imaginary_friend('(%s)' % name)
        ffcli.add_twitter(id, name)
        if url = picture_urls[name]
          putinfo 'Setting the picture of %s', name
          ffcli.change_picture_to_url(id, url)
        end
      }
    end
  end

  mode 'icons' do
    description 'Update imaginary friends icons with those of their Twitter accounts'

    def run
      twcli = twitter_client()

      picture_urls = {}

      twcli.all_friends.each { |friend|
        name = friend.screen_name.downcase
        picture_urls[name] = friend.profile_image_url
      }

      ffcli = friendfeed_client()

      putinfo "Checking imaginary friends in FriendFeed..."
      ffcli.get_imaginary_friends.each { |profile|
        profile['services'].each { |service|
          url = service['profileUrl'] or next
          if (name = TWITTER_URI.route_to(url).to_s).match(/\A[A-Za-z0-9_]+\z/)
            name.downcase!
            if picture_urls.key?(name)
              url = picture_urls[name]
            else
              friend = twcli.get_profile(name) rescue
                begin
                  putinfo "Failed to get profile of %s", name
                  next
                end
              url = friend.profile_image_url
            end
            id = profile['id']
            putinfo 'Changing the picture of %s', name
            ffcli.change_picture_to_url(id, url)
          end
        }
      }
    end
  end

  mode 'favorites' do
    description 'Synchronize Twitter favorites and FriendFeed likes as far as possible'

    def run
      require 'set'

      ffcli = friendfeed_client()
      ff_me = ffcli.nickname

      twcli = twitter_client()

      favorited = Set[]

      twcli.favorites.each { |favorite|
        id = favorite['id']
        # p [id, favorite.user.screen_name]
        favorited << id
      }

      liked = Set[]
      tw_url = {}

      ffcli.get_user_liked_entries.each { |like|
        url = like['link']
        case TWITTER_URI.route_to(url).to_s
        when %r{\A([A-Za-z0-9_]+)/statuses/([0-9]+)\z}
          id = $2.to_i
          liked << id
          tw_url[id] = url
        end
      }

      # Favorite FriendFeed-liked entry in Twitter
      (liked - favorited).each { |id|
        putinfo "Adding a favorite in Twitter: %s", tw_url[id]
        twcli.favorite_create(id)
      }

      # Find Twitter-liked entries in FriendFeed that aren't liked yet
      (
        ffcli.get_user_friend_entries('num' => 1000) +
        ffcli.get_user_discussed_entries
      ).sort_by { |entry|
        entry["published"]
      }.each { |entry|
        # Just in case this entry is not covered by the 'liked' list
        next if entry['likes'].any? { |like| like['user']['nickname'] == ff_me }

        # Is the source Twitter?
        url = entry['service']['profileUrl'] or next
        m = TWITTER_URI.route_to(url).to_s.match(%r{\A([A-Za-z0-9_]+)/statuses/([0-9]+)\z}) or next
        id = m[2].to_i

        # A different entry with the same source may be liked already
        next if liked.include?(id)

        if favorited.include?(id)
          entryid = entry['id']
          putinfo "Adding a like in FriendFeed: %s", entry['link']
          ffcli.add_like(entryid)
          liked << id
        end
      }
    end
  end

  mode 'replies' do
    description 'Produce an RSS feed of Twitter @replies'

    option('include-friends') {
      description 'Include @reples from friends'

      cast :bool
      default false
    }

    option('include-protected') {
      description 'Include @reples from protected users'

      cast :bool
      default false
    }

    argument('filename') {
      description 'Output RSS to this file'
    }

    def run
      require 'nokogiri'
      require 'rss'
      require 'set'
      require 'time'

      include_friends   = params['include-friends'].value
      include_protected = params['include-protected'].value
      filename = params['filename'].value

      File.open(filename, 'w') { |w|
        feed = RSS::Maker.make("2.0") { |rss|
          rss.channel.title = 'Twitter replies'
          rss.channel.link = 'http://twitter.com/replies'
          rss.channel.description = 'Twitter replies'

          friends = Status('friends').to_set

          twitter_client().mentions.each { |reply|
            user = reply.user
            next if !include_protected && user.protected
            name = user.screen_name
            next if !include_friends && friends.include?(name.downcase)
            text = '%s: %s' % [name, reply.text]
            url = 'http://twitter.com/%s/statuses/%d' % [name, reply.id]
            timestamp = Time.parse(reply.created_at)
            rss.items.new_item { |item|
              item.title = Nokogiri.HTML(text).inner_text
              item.link = url
              item.description = text
              item.date = timestamp
            }
          }
        }
        w.print feed.to_s
      }
    end
  end

  mode 'protected' do
    description 'Produce an RSS feed for Twitter entries from protected friends'

    argument('filename') {
      description 'Output RSS to this file'
    }

    def run
      require 'nokogiri'
      require 'rss'
      require 'set'
      require 'time'

      filename = params['filename'].value

      friends = Status('friends').to_set
      friends_subscribed_real = Status('friends_subscribed_real').to_set

      items = []

      twitter_client().mentions.each { |reply|
        user = reply.user
        next if !user.protected
        name = user.screen_name
        next if friends.include?(name.downcase)

        text = '[%s]: %s' % [name, reply.text]
        url = 'http://twitter.com/%s/statuses/%d' % [name, reply.id]
        timestamp = Time.parse(reply.created_at)
        items << [timestamp, text, url]
      }

      twitter_client().friends_timeline.each { |status| 
        user = status.user
        next if !user.protected
        name = user.screen_name
        next if friends_subscribed_real.include?(name.downcase)
        text = '[%s]: %s' % [name, status.text]
        url = 'http://twitter.com/%s/statuses/%d' % [name, status.id]
        timestamp = Time.parse(status.created_at)
        items << [timestamp, text, url]
      }

      File.open(filename, 'w') { |w|
        feed = RSS::Maker.make("2.0") { |rss|
          rss.channel.title = 'Twitter entries from protected friends'
          rss.channel.link = 'http://twitter.com/home'
          rss.channel.description = 'Twitter entries from protected friends'

          items.sort { |a, b|
            b.first <=> a.first
          }.each { |timestamp, text, url|
            rss.items.new_item { |item|
              item.title = Nokogiri.HTML(text).inner_text
              item.link = url
              item.description = text
              item.date = timestamp
            }
          }
        }
        w.print feed.to_s
      }
    end
  end
  
  mode 'refresh' do
    description 'Urge FriendFeed to refresh services (import feed entries)'

    def run
      ffcli = friendfeed_client()
      profile = ffcli.get_profile

      ffcli.get_services.each { |service|
        putinfo "Refreshing %s..." % service['service']
        ffcli.refresh_service(profile['id'], service['serviceid'], service['service'])
      }
    end
  end
}