class Google::Cloud::Storage::Project

def acl_rule option_name
  Bucket::Acl.predefined_rule_for option_name
end

def add_custom_header header_name, header_value
  @service.add_custom_header header_name, header_value
  self
end

def add_custom_headers headers
  @service.add_custom_headers headers
  self
end

def bucket bucket_name,
           skip_lookup: false,
           generation: nil,
           soft_deleted: nil,
           if_metageneration_match: nil,
           if_metageneration_not_match: nil,
           user_project: nil
  if skip_lookup
    return Bucket.new_lazy bucket_name, service,
                           user_project: user_project
  end
  gapi = service.get_bucket bucket_name,
                            if_metageneration_match: if_metageneration_match,
                            if_metageneration_not_match: if_metageneration_not_match,
                            user_project: user_project,
                            soft_deleted: soft_deleted,
                            generation: generation
  Bucket.from_gapi gapi, service, user_project: user_project
rescue Google::Cloud::NotFoundError
  nil
end

def buckets prefix: nil, token: nil, max: nil, user_project: nil, soft_deleted: nil
  gapi = service.list_buckets \
    prefix: prefix, token: token, max: max, user_project: user_project, soft_deleted: soft_deleted
  Bucket::List.from_gapi \
    gapi, service, prefix, max, user_project: user_project, soft_deleted: soft_deleted
end

def create_bucket bucket_name,
                  acl: nil,
                  default_acl: nil,
                  location: nil,
                  custom_placement_config: nil,
                  storage_class: nil,
                  logging_bucket: nil,
                  logging_prefix: nil,
                  website_main: nil,
                  website_404: nil,
                  versioning: nil,
                  requester_pays: nil,
                  user_project: nil,
                  autoclass_enabled: false,
                  enable_object_retention: nil,
                  hierarchical_namespace: nil
  params = {
    name: bucket_name,
    location: location,
    custom_placement_config: custom_placement_config,
    hierarchical_namespace: hierarchical_namespace
  }.delete_if { |_, v| v.nil? }
  new_bucket = Google::Apis::StorageV1::Bucket.new(**params)
  storage_class = storage_class_for storage_class
  updater = Bucket::Updater.new(new_bucket).tap do |b|
    b.logging_bucket = logging_bucket unless logging_bucket.nil?
    b.logging_prefix = logging_prefix unless logging_prefix.nil?
    b.autoclass_enabled = autoclass_enabled
    b.storage_class = storage_class unless storage_class.nil?
    b.website_main = website_main unless website_main.nil?
    b.website_404 = website_404 unless website_404.nil?
    b.versioning = versioning unless versioning.nil?
    b.requester_pays = requester_pays unless requester_pays.nil?
    b.hierarchical_namespace = hierarchical_namespace unless hierarchical_namespace.nil?
  end
  yield updater if block_given?
  updater.check_for_changed_labels!
  updater.check_for_mutable_cors!
  updater.check_for_mutable_lifecycle!
  gapi = service.insert_bucket \
    new_bucket, acl: acl_rule(acl), default_acl: acl_rule(default_acl),
                user_project: user_project,
                enable_object_retention: enable_object_retention
  Bucket.from_gapi gapi, service, user_project: user_project
end

def create_hmac_key service_account_email, project_id: nil,
                    user_project: nil
  gapi = service.create_hmac_key service_account_email,
                                 project_id: project_id,
                                 user_project: user_project
  HmacKey.from_gapi gapi, service, user_project: user_project
end

def hmac_key access_id, project_id: nil, user_project: nil
  gapi = service.get_hmac_key \
    access_id, project_id: project_id, user_project: user_project
  HmacKey.from_gapi_metadata gapi, service, user_project: user_project
end

def hmac_keys service_account_email: nil, project_id: nil,
              show_deleted_keys: nil, token: nil, max: nil,
              user_project: nil
  gapi = service.list_hmac_keys \
    max: max, token: token,
    service_account_email: service_account_email,
    project_id: project_id, show_deleted_keys: show_deleted_keys,
    user_project: user_project
  HmacKey::List.from_gapi \
    gapi, service,
    service_account_email: nil, show_deleted_keys: nil,
    max: max, user_project: user_project
end

def initialize service
  @service = service
end

def project_id
  service.project
end

def restore_bucket bucket_name,
                   generation,
                   options: {}
  gapi = service.restore_bucket bucket_name, generation,
                                options: options
  Bucket.from_gapi gapi, service
end

def service_account_email
  @service_account_email ||= service.project_service_account.email_address
end

def signed_url bucket,
               path,
               method: "GET",
               expires: nil,
               content_type: nil,
               content_md5: nil,
               headers: nil,
               issuer: nil,
               client_email: nil,
               signing_key: nil,
               private_key: nil,
               signer: nil,
               query: nil,
               scheme: "HTTPS",
               virtual_hosted_style: nil,
               bucket_bound_hostname: nil,
               version: nil
  version ||= :v2
  case version.to_sym
  when :v2
    sign = File::SignerV2.new bucket, path, service
    sign.signed_url method: method,
                    expires: expires,
                    headers: headers,
                    content_type: content_type,
                    content_md5: content_md5,
                    issuer: issuer,
                    client_email: client_email,
                    signing_key: signing_key,
                    private_key: private_key,
                    signer: signer,
                    query: query
  when :v4
    sign = File::SignerV4.new bucket, path, service
    sign.signed_url method: method,
                    expires: expires,
                    headers: headers,
                    issuer: issuer,
                    client_email: client_email,
                    signing_key: signing_key,
                    private_key: private_key,
                    signer: signer,
                    query: query,
                    scheme: scheme,
                    virtual_hosted_style: virtual_hosted_style,
                    bucket_bound_hostname: bucket_bound_hostname
  else
    raise ArgumentError, "version '#{version}' not supported"
  end
end

def universe_domain
  service.universe_domain
end