class Qeweney::Request

def buffer_body_chunk(chunk)
  @buffered_body_chunks ||= []
  @buffered_body_chunks << chunk
end

def complete!(keep_alive = nil)
  @message_complete = true
  @keep_alive = keep_alive
end

def complete?
  @message_complete
end

def consume
  @adapter.consume_request(self)
end

def each_chunk
  if @buffered_body_chunks
    while (chunk = @buffered_body_chunks.shift)
      yield chunk
    end
    @buffered_body_chunks = nil
  end
  while !@message_complete && (chunk = @adapter.get_body_chunk(self))
    yield chunk
  end
end

def finish
  send_headers({}) unless @headers_sent
  
  @adapter.finish(self)
end

def headers_sent?
  @headers_sent
end

def initialize(headers, adapter)
  @headers  = headers
  @adapter  = adapter
end

def keep_alive?
  @keep_alive
end

def next_chunk
  if @buffered_body_chunks
    chunk = @buffered_body_chunks.shift
    @buffered_body_chunks = nil if @buffered_body_chunks.empty?
    return chunk
  end
  @message_complete ? nil : @adapter.get_body_chunk(self)
end

def read
  buf = @buffered_body_chunks ? @buffered_body_chunks.join : nil
  while (chunk = @adapter.get_body_chunk(self))
    (buf ||= +'') << chunk
  end
  @buffered_body_chunks = nil
  buf
end

def respond(body, headers = {})
  @adapter.respond(self, body, headers)
  @headers_sent = true
end

def rx_incr(count)
  headers[':rx'] ? headers[':rx'] += count : headers[':rx'] = count
end

def send_chunk(body, done: false)
  send_headers({}) unless @headers_sent
  
  @adapter.send_chunk(self, body, done: done)
end

def send_headers(headers = {}, empty_response = false)
  return if @headers_sent
  
  @headers_sent = true
  @adapter.send_headers(self, headers, empty_response: empty_response)
end

def total_transfer
  (headers[':rx'] || 0) + (headers[':tx'] || 0)
end

def transfer_counts
  [headers[':rx'], headers[':tx']]
end

def tx_incr(count)
  headers[':tx'] ? headers[':tx'] += count : headers[':tx'] = count
end