class EventMachine::WebMockHttpClient

def build_request_signature
  headers, body = headers_and_body_processed_by_middleware
  method = @req.method
  uri = @req.uri.clone
  query = @req.query
  uri.query = encode_query(@req.uri, query).slice(/\?(.*)/, 1)
  body = form_encode_body(body) if body.is_a?(Hash)
  if headers['authorization'] && headers['authorization'].is_a?(Array)
    headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(headers.delete('authorization'))
  end
  WebMock::RequestSignature.new(
    method.downcase.to_sym,
    uri.to_s,
    body: body || (@req.file && File.read(@req.file)),
    headers: headers
  )
end

def build_webmock_response
  webmock_response = WebMock::Response.new
  webmock_response.status = [response_header.status, response_header.http_reason]
  webmock_response.headers = response_header
  webmock_response.body = response
  webmock_response
end

def connection_completed
  @state = :response_header
  send_request(*headers_and_body_processed_by_middleware)
end

def get_response_cookie(name)
  name = name.to_s
  raw_cookie = response_header.cookie
  raw_cookie = [raw_cookie] if raw_cookie.is_a? String
  cookie = raw_cookie.detect { |c| c.start_with? name }
  cookie and cookie.split('=', 2)[1]
end

def headers_and_body_processed_by_middleware
  @headers_and_body_processed_by_middleware ||= begin
    head, body = build_request, @req.body
    @conn.middleware.each do |m|
      head, body = m.request(self, head, body) if m.respond_to?(:request)
    end
    [head, body]
  end
end

def make_raw_response(response)
  response.raise_error_if_any
  status, headers, body = response.status, response.headers, response.body
  headers ||= {}
  response_string = []
  response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
  headers["Content-Length"] = body.bytesize unless headers["Content-Length"]
  headers.each do |header, value|
    if header =~ /set-cookie/i
      [value].flatten.each do |cookie|
        response_string << "#{header}: #{cookie}"
      end
    else
      value = value.join(", ") if value.is_a?(Array)
      # WebMock's internal processing will not handle the body
      # correctly if the header indicates that it is chunked, unless
      # we also create all the chunks.
      # It's far easier just to remove the header.
      next if header =~ /transfer-encoding/i && value =~/chunked/i
      response_string << "#{header}: #{value}"
    end
  end if headers
  response_string << "" << body
  response_string.join("\n")
end

def request_signature
  @request_signature ||= build_request_signature
end

def send_request(head, body)
  WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
  if stubbed_webmock_response
    WebMock::CallbackRegistry.invoke_callbacks({lib: :em_http_request}, request_signature, stubbed_webmock_response)
    @uri ||= nil
    EM.next_tick {
      setup(make_raw_response(stubbed_webmock_response), @uri,
            stubbed_webmock_response.should_timeout ? Errno::ETIMEDOUT : nil)
    }
    self
  elsif WebMock.net_connect_allowed?(request_signature.uri)
    super
  else
    raise WebMock::NetConnectNotAllowedError.new(request_signature)
  end
end

def setup(response, uri, error = nil)
  @last_effective_url = @uri = uri
  if error
    on_error(error)
    @conn.drop_client
    fail(self)
  else
    @conn.receive_data(response)
    succeed(self)
  end
end

def stubbed_webmock_response
  unless defined?(@stubbed_webmock_response)
    @stubbed_webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
  end
  @stubbed_webmock_response
end

def unbind(reason = nil)
  if !stubbed_webmock_response && WebMock::CallbackRegistry.any_callbacks?
    webmock_response = build_webmock_response
    WebMock::CallbackRegistry.invoke_callbacks(
      {lib: :em_http_request, real_request: true},
      request_signature,
      webmock_response)
  end
  @request_signature = nil
  remove_instance_variable(:@stubbed_webmock_response)
  super
end

def uri
  @req.uri
end