class Protobuf::Rpc::Middleware::ResponseEncoder

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

def call(env)
  dup._call(env)
end

def encoded_response
  logger.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, exception.message
end

def initialize(app)
  @app = app
end

def log_signature
  env.log_signature || super
end

def response
  return @response unless @response.nil?
  candidate = env.response
  return @response = validate!(candidate) if candidate.is_a?(Message)
  return @response = validate!(candidate.to_proto) if candidate.respond_to?(:to_proto)
  return @response = env.response_type.new(candidate.to_hash) if candidate.respond_to?(:to_hash)
  return @response = candidate if candidate.is_a?(PbError)
  @response = validate!(candidate)
end

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

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