class Aws::S3::MultipartUpload

def abort(options = {})
  options = options.merge(
    bucket: @bucket_name,
    key: @object_key,
    upload_id: @id
  )
  resp = @client.abort_multipart_upload(options)
  resp.data
end

def bucket_name
  @bucket_name
end

def checksum_algorithm
  data[:checksum_algorithm]
end

def client
  @client
end

def complete(options = {})
  if options.delete(:compute_parts)
    options[:multipart_upload] = { parts: compute_parts }
  end
  basic_complete(options)
end

def complete(options = {})
  options = options.merge(
    bucket: @bucket_name,
    key: @object_key,
    upload_id: @id
  )
  @client.complete_multipart_upload(options)
  Object.new(
    bucket_name: @bucket_name,
    key: @object_key,
    client: @client
  )
end

def compute_parts
  parts.sort_by(&:part_number).each.with_object([]) do |part, part_list|
    part_list << { part_number: part.part_number, etag: part.etag }
  end
end

def data
  load unless @data
  @data
end

def data_loaded?
  !!@data
end

def extract_bucket_name(args, options)
  value = args[0] || options.delete(:bucket_name)
  case value
  when String then value
  when nil then raise ArgumentError, "missing required option :bucket_name"
  else
    msg = "expected :bucket_name to be a String, got #{value.class}"
    raise ArgumentError, msg
  end
end

def extract_id(args, options)
  value = args[2] || options.delete(:id)
  case value
  when String then value
  when nil then raise ArgumentError, "missing required option :id"
  else
    msg = "expected :id to be a String, got #{value.class}"
    raise ArgumentError, msg
  end
end

def extract_object_key(args, options)
  value = args[1] || options.delete(:object_key)
  case value
  when String then value
  when nil then raise ArgumentError, "missing required option :object_key"
  else
    msg = "expected :object_key to be a String, got #{value.class}"
    raise ArgumentError, msg
  end
end

def id
  @id
end

def identifiers
  {
    bucket_name: @bucket_name,
    object_key: @object_key,
    id: @id
  }
end

def initialize(*args)
  options = Hash === args.last ? args.pop.dup : {}
  @bucket_name = extract_bucket_name(args, options)
  @object_key = extract_object_key(args, options)
  @id = extract_id(args, options)
  @data = options.delete(:data)
  @client = options.delete(:client) || Client.new(options)
  @waiter_block_warned = false
end

def initiated
  data[:initiated]
end

def initiator
  data[:initiator]
end

def key
  data[:key]
end

def load
  msg = "#load is not implemented, data only available via enumeration"
  raise NotImplementedError, msg
end

def object
  Object.new(
    bucket_name: @bucket_name,
    key: @object_key,
    client: @client
  )
end

def object_key
  @object_key
end

def owner
  data[:owner]
end

def part(part_number)
  MultipartUploadPart.new(
    bucket_name: @bucket_name,
    object_key: @object_key,
    multipart_upload_id: @id,
    part_number: part_number,
    client: @client
  )
end

def parts(options = {})
  batches = Enumerator.new do |y|
    options = options.merge(
      bucket: @bucket_name,
      key: @object_key,
      upload_id: @id
    )
    resp = @client.list_parts(options)
    resp.each_page do |page|
      batch = []
      page.data.parts.each do |p|
        batch << MultipartUploadPart.new(
          bucket_name: options[:bucket],
          object_key: options[:key],
          multipart_upload_id: options[:upload_id],
          part_number: p.part_number,
          data: p,
          client: @client
        )
      end
      y.yield(batch)
    end
  end
  MultipartUploadPart::Collection.new(batches)
end

def storage_class
  data[:storage_class]
end

def upload_id
  data[:upload_id]
end

def wait_until(options = {}, &block)
  self_copy = self.dup
  attempts = 0
  options[:max_attempts] = 10 unless options.key?(:max_attempts)
  options[:delay] ||= 10
  options[:poller] = Proc.new do
    attempts += 1
    if block.call(self_copy)
      [:success, self_copy]
    else
      self_copy.reload unless attempts == options[:max_attempts]
      :retry
    end
  end
  Aws::Waiters::Waiter.new(options).wait({})
end