class Protobuf::Rpc::Middleware::ResponseEncoder

def call(env)
  @env = app.call(env)
  env.response = response
  env.encoded_response = encoded_response
  env
end

def encoded_response
  log_debug { sign_message("Encoding response: #{response.inspect}") }
  env.encoded_response = wrapped_response.encode
rescue => exception
  log_exception(exception)
  # Rescue encoding exceptions, re-wrap them as generic protobuf errors,
  # and re-raise them
  raise PbError.new(exception.message)
end

def initialize(app)
  @app = app
end

def log_signature
  env.signature || super
end

def response
  @response ||= begin
                  candidate = env.response
                  case
                  when candidate.is_a?(Message) then
                    validate!(candidate)
                  when candidate.respond_to?(:to_proto) then
                    validate!(candidate.to_proto)
                  when candidate.respond_to?(:to_hash) then
                    env.response_type.new(candidate.to_hash)
                  when candidate.is_a?(PbError) then
                    candidate
                  else
                    validate!(candidate)
                  end
                end
end

def validate!(candidate)
  actual = candidate.class
  expected = env.response_type
  if expected != actual
    raise BadResponseProto.new("Expected response to be of type #{expected.name} but was #{actual.name}")
  end
  candidate
end

def wrapped_response
  if response.is_a?(Protobuf::Rpc::PbError)
    Socketrpc::Response.new(:error => response.message, :error_reason => response.error_type)
  else
    Socketrpc::Response.new(:response_proto => response.encode)
  end
end