class AWS::Core::Http::Handler

def handle(request, http_response, &read_block)
  @base.handle(request, http_response, &read_block)
end

def handle_async(request, http_response, handle)
  Thread.new do
    begin
      self.handle(request, http_response)
    rescue => e
      handle.signal_failure
    else
      handle.signal_success
    end
  end
end

def initialize(base, &block)
  @base = base
  if base.respond_to?(:handle)
    unless [2,3].include?(block.arity)
      raise ArgumentError, 'passed block must accept 2 or 3 arguments'
    end
    MetaUtils.extend_method(self, :handle, &block)
    if block.arity == 3
      m = Module.new do
        eval(<<-DEF)
          def handle req, resp, &read_block
            super(req, resp, read_block)
          end
        DEF
      end
      self.extend(m)
    end
  elsif base.respond_to?(:handle_async)
    unless block.arity == 3
      raise ArgumentError, 'passed block must accept 3 arguments'
    end
    MetaUtils.extend_method(self, :handle_async) do |req, resp, handle|
      @base.handle_async(req, resp, handle)
    end
    MetaUtils.extend(self) do
      define_method(:handle) do |req, resp|
        raise "attempted to call #handle on an async handler"
      end
      define_method(:handle_async, &block)
    end
  else
    raise ArgumentError, 'base must respond to #handle or #handle_async'
  end
end

def sleep_with_callback seconds, &block
  Kernel.sleep(seconds)
  yield
end