class Protobuf::Rpc::Service

def self.client(options = {})
  ::Protobuf::Rpc::Client.new({ :service => self,
                                :host => host,
                                :port => port }.merge(options))
end

def self.configure(config = {})
  self.host = config[:host] if config.key?(:host)
  self.port = config[:port] if config.key?(:port)
end

def self.host
  @_host ||= DEFAULT_HOST
end

def self.host=(new_host)
  @_host = new_host
end

def self.implemented_services
  classes = (self.subclasses || []).select do |subclass|
    subclass.rpcs.any? do |(name, _)|
      subclass.method_defined? name
    end
  end
  classes.map(&:name)
end

def self.located_at(location)
  return if location.nil? || location.downcase.strip !~ /.+:\d+/
  host, port = location.downcase.strip.split ':'
  configure(:host => host, :port => port.to_i)
end

def self.port
  @_port ||= DEFAULT_PORT
end

def self.port=(new_port)
  @_port = new_port
end

def self.rpc(method, request_type, response_type)
  rpcs[method] = RpcMethod.new(method, request_type, response_type)
end

def self.rpc_method?(name)
  rpcs.key?(name)
end

def self.rpcs
  @_rpcs ||= {}
end

def callable_rpc_method(method_name)
  lambda { run_filters(method_name) }
end

def initialize(env)
  @env = env.dup # Dup the env so it doesn't change out from under us
  @request = env.request
end

def request_type
  @_request_type ||= env.request_type
end

def respond_with(candidate)
  @_response = candidate
end

def response
  @_response ||= response_type.new
end

def response_type
  @_response_type ||= env.response_type
end

def rpc_failed(message)
  message = message.message if message.respond_to?(:message)
  raise RpcFailed.new(message)
end

def rpc_method?(name)
  self.class.rpc_method?(name)
end

def rpcs
  self.class.rpcs
end