class Protobuf::Rpc::Service

def call_rpc(method, pb_request)
  @current_method = method
  
  # Allows the service to set whether or not
  # it would like to asynchronously respond to the connected client(s)
  @async_responder = false
  
  # Setup the request
  @request = rpcs[method].request_type.new
  @request.parse_from_string(pb_request.request_proto)
rescue
  exc = BadRequestProto.new 'Unable to parse request: %s' % $!.message
  log_error exc.message
  log_error $!.backtrace.join("\n")
  raise exc
else   # when no Exception was thrown
  # Setup the response
  @response = rpcs[method].response_type.new
  log_debug "[#{log_signature}] calling service method %s#%s" % [self.class, method]
  # Call the aliased rpc method (e.g. :rpc_find for :find)
  __send__("rpc_#{method}".to_sym)
  log_debug "[#{log_signature}] completed service method %s#%s" % [self.class, method]
  
  # Pass the populated response back to the server
  # Note this will only get called if the rpc method didn't explode (by design)
  if @async_responder
    log_debug "[#{log_signature}] async request, not sending response (yet)"
  else
    log_debug "[#{log_signature}] trigger server send_response"
    send_response
  end
end

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

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

def host
  configure
  locations[self][:host] || DEFAULT_LOCATION[:host]
end

def located_at(location)
  return if location.nil? or location.downcase.strip !~ /[a-z0-9.]+:\d+/
  host, port = location.downcase.strip.split ':'
  configure :host => host, :port => port.to_i
end

def locations
  @locations ||= {}
end

def log_and_raise_error(error_message)
  log_error(error_message)
  raise error_message
end

def log_signature
  @log_signature ||= "service-#{self.class}"
end

def method_added(old)
  new_method = :"rpc_#{old}"
  return if private_instance_methods.include?(new_method) or old =~ /^rpc_/ or NON_RPC_METHODS.include?(old.to_s)
  
  alias_method new_method, old
  private new_method
  
  define_method(old) do |pb_request|
    call_rpc(old.to_sym, pb_request)
  end
rescue ArgumentError => e
  # Wrap a known issue where an instance method was defined in the class without
  # it being ignored with NON_RPC_METHODS. 
  raise ArgumentError, "#{e.message} (Note: This could mean that you need to add the method #{old} to the NON_RPC_METHODS list)"
end

def method_missing m, *params
  if rpcs.key?(m)
    exc = MethodNotFound.new "#{self}##{m} was defined as a valid rpc method, but was not implemented."
    log_error exc.message
    raise exc
  else
    log_error "-------------- [#{log_signature}] %s#%s not rpc method, passing to super" % [self.class.name, m.to_s]
    super m, params
  end
end

def on_rpc_failed(&rpc_failure_cb)
  @rpc_failure_cb = rpc_failure_cb
end

def on_send_response(&responder)
  @responder = responder
end

def port
  configure
  locations[self][:port] || DEFAULT_LOCATION[:port]
end

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

def rpc_failed(message="RPC Failed while executing service method #{@current_method}")
  error_message = 'Unable to invoke rpc_failed, no failure callback is setup.' 
  log_and_raise_error(error_message) if @rpc_failure_cb.nil?
  error = message.is_a?(String) ? RpcFailed.new(message) : message
  log_warn "[#{log_signature}] RPC Failed: %s" % error.message
  @rpc_failure_cb.call(error)
end

def rpcs
  @rpcs ||= {}
end

def rpcs
  self.class.rpcs[self.class]
end

def send_response
  error_message = "Unable to send response, responder is nil. It appears you aren't inside of an RPC request/response cycle."
  log_and_raise_error(error_message) if @responder.nil?
  @responder.call(@response)
end