class KyotoTycoon

# File lib/kyototycoon.rb, line 25
def self.configure(name, host=DEFAULT_HOST, port=DEFAULT_PORT, &block)
  @configure ||= {}
  if @configure[name]
    raise "'#{name}' is registered"
  end
  @configure[name] = lambda{
    kt = KyotoTycoon.new(host, port)
    block.call(kt)
    kt
  }
end

# File lib/kyototycoon.rb, line 41
def self.configure_reset!
  @configure = {}
end

# File lib/kyototycoon.rb, line 37
def self.configures
  @configure
end

# File lib/kyototycoon.rb, line 45
def self.create(name)
  if @configure[name].nil?
    raise "undefined configure: '#{name}'"
  end
  @configure[name].call
end

# File lib/kyototycoon.rb, line 52
def initialize(host=DEFAULT_HOST, port=DEFAULT_PORT)
  @servers = [[host, port]]
  @checked_servers = nil
  @serializer = KyotoTycoon::Serializer::Default
  @logger = Logger.new(nil)
  @colenc = :B
  @connect_timeout = 0.5
  @cursor = 1
end

# File lib/kyototycoon.rb, line 95
def add(key, value, xt=nil)
  res = request('/rpc/add', {:key => key, :value => @serializer.encode(value), :xt => xt})
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 105
def append(key, value, xt=nil)
  request('/rpc/append', {:key => key, :value => @serializer.encode(value), :xt => xt})
end

# File lib/kyototycoon.rb, line 109
def cas(key, oldval, newval, xt=nil)
  res = request('/rpc/cas', {:key => key, :oval=> @serializer.encode(oldval), :nval => @serializer.encode(newval), :xt => xt})
  case res[:status].to_i
    when 200
      true
    when 450
      false
  end
end

# File lib/kyototycoon.rb, line 171
def clear
  request('/rpc/clear')
end

# File lib/kyototycoon.rb, line 243
def client
  host, port = *choice_server
  @client ||= begin
    Tsvrpc::Skinny.new(host, port)
  end
end

# File lib/kyototycoon.rb, line 167
def cursor(cur_id=nil)
  Cursor.new(self, cur_id || @cursor += 1)
end

# File lib/kyototycoon.rb, line 67
def db= (db)
  @db = db
end

# File lib/kyototycoon.rb, line 125
def decrement(key, num=1, xt=nil)
  increment(key, num * -1, xt)
end

# File lib/kyototycoon.rb, line 184
def echo(value)
  res = request('/rpc/echo', value)
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 254
def finish
  client.finish
end

# File lib/kyototycoon.rb, line 78
def get(key)
  res = request('/rpc/get', {:key => key})
  @serializer.decode(Tsvrpc.parse(res[:body], res[:colenc])['value'])
end

# File lib/kyototycoon.rb, line 145
def get_bulk(keys)
  params = keys.inject({}){|params, k|
    params[k.to_s.match(/^_/) ? k.to_s : "_#{k}"] = ''
    params
  }
  res = request('/rpc/get_bulk', params)
  bulk = Tsvrpc.parse(res[:body], res[:colenc])
  bulk.delete_if{|k,v| k.match(/^[^_]/)}.inject({}){|r, (k,v)|
    r[k[1..-1]] = @serializer.decode(v)
    r
  }
end

# File lib/kyototycoon.rb, line 119
def increment(key, num=1, xt=nil)
  res = request('/rpc/increment', {:key => key, :num => num, :xt => xt})
  Tsvrpc.parse(res[:body], res[:colenc])['num'].to_i
end

# File lib/kyototycoon.rb, line 130
def increment_double(key, num, xt=nil)
  res = request('/rpc/increment_double', {:key => key, :num => num, :xt => xt})
  Tsvrpc.parse(res[:body], res[:colenc])['num'].to_f
end

# File lib/kyototycoon.rb, line 224
def keys
  match_prefix("")
end

# File lib/kyototycoon.rb, line 71
def logger= (logger)
  if logger.class != Logger
    logger = Logger.new(logger)
  end
  @logger = logger
end

# File lib/kyototycoon.rb, line 199
def match_prefix(prefix)
  res = request('/rpc/match_prefix', {:prefix => prefix})
  keys = []
  Tsvrpc.parse(res[:body], res[:colenc]).each{|k,v|
    if k != 'num'
      keys << k[1, k.length]
    end
  }
  keys
end

# File lib/kyototycoon.rb, line 210
def match_regex(re)
  if re.class == Regexp
    re = re.source
  end
  res = request('/rpc/match_regex', {:regex => re})
  keys = []
  Tsvrpc.parse(res[:body], res[:colenc]).each{|k,v|
    if k != 'num'
      keys << k[1, k.length]
    end
  }
  keys
end

# File lib/kyototycoon.rb, line 84
def remove(*keys)
  remove_bulk(keys.flatten)
end

# File lib/kyototycoon.rb, line 158
def remove_bulk(keys)
  params = keys.inject({}){|params, k|
    params[k.to_s.match(/^_/) ? k.to_s : "_#{k}"] = ''
    params
  }
  res = request('/rpc/remove_bulk', params)
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 100
def replace(key, value, xt=nil)
  res = request('/rpc/replace', {:key => key, :value => @serializer.encode(value), :xt => xt})
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 189
def report
  res = request('/rpc/report')
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 228
def request(path, params=nil)
  if @db
    params ||= {}
    params[:DB] = @db
  end

  status,body,colenc = client.request(path, params, @colenc)
  if ![200, 450].include?(status.to_i)
    raise body
  end
  res = {:status => status, :body => body, :colenc => colenc}
  @logger.info("#{path}: #{res[:status]} with query parameters #{params.inspect}")
  res
end

# File lib/kyototycoon.rb, line 62
def serializer= (adaptor=:default)
  klass = KyotoTycoon::Serializer.get(adaptor)
  @serializer = klass
end

# File lib/kyototycoon.rb, line 89
def set(key, value, xt=nil)
  res = request('/rpc/set', {:key => key, :value => @serializer.encode(value), :xt => xt})
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 135
def set_bulk(records)
  # records={'a' => 'aa', 'b' => 'bb'}
  values = {}
  records.each{|k,v|
    values[k.to_s.match(/^_/) ? k.to_s : "_#{k}"] = @serializer.encode(v)
  }
  res = request('/rpc/set_bulk', values)
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 250
def start
  client.start
end

# File lib/kyototycoon.rb, line 194
def status
  res = request('/rpc/status')
  Tsvrpc.parse(res[:body], res[:colenc])
end

# File lib/kyototycoon.rb, line 179
def sync(params={})
  request('/rpc/synchronize', params)
end

# File lib/kyototycoon.rb, line 175
def vacuum
  request('/rpc/vacuum')
end

# File lib/kyototycoon.rb, line 285
def choice_server
  if @checked_servers
    return @checked_servers
  end

  @servers.each{|s|
    host,port = *s
    if ping(host, port)
      @checked_servers = [host, port]
      break
    end
  }
  if @checked_servers.nil?
    msg = "alived server not exists"
    @logger.fatal(msg)
    raise msg
  end
  @checked_servers
end

# File lib/kyototycoon.rb, line 260
def ping(host, port)
  begin
    rpc = Tsvrpc::Skinny.new(host, port)
    Timeout.timeout(@connect_timeout){
      @logger.debug("connect check #{host}:#{port}")
      res = rpc.request('/rpc/echo', {'0' => '0'}, :U)
      @logger.debug(res)
    }
    true
  rescue Timeout::Error => ex
    # Ruby 1.8.7 compatible
    @logger.warn("connect failed at #{host}:#{port}")
    false
  rescue SystemCallError
    @logger.warn("connect failed at #{host}:#{port}")
    false
  rescue => ex
    @logger.warn("connect failed at #{host}:#{port}")
    false
  ensure
    # for 1.8.7
    rpc.finish
  end
end