module AWS::S3::Client::Validators

def dns_compatible_bucket_name?(bucket_name)
  return false if
    !valid_bucket_name?(bucket_name) or
    # Bucket names should not contain underscores (_)
    bucket_name["_"] or
    # Bucket names should be between 3 and 63 characters long
    bucket_name.size > 63 or
    # Bucket names should not end with a dash
    bucket_name[-1,1] == '-' or
    # Bucket names cannot contain two, adjacent periods
    bucket_name['..'] or
    # Bucket names cannot contain dashes next to periods
    # (e.g., "my-.bucket.com" and "my.-bucket" are invalid)
    (bucket_name['-.'] || bucket_name['.-'])
  true
end

def json_validation_message(obj)
  if obj.respond_to?(:to_str)
    obj = obj.to_str
  elsif obj.respond_to?(:to_json)
    obj = obj.to_json
  end
  error = nil
  begin
    JSON.parse(obj)
  rescue => e
    error = e
  end
  "contains invalid JSON: #{error}" if error
end

def path_style_bucket_name? bucket_name
  if dns_compatible_bucket_name?(bucket_name)
    bucket_name =~ /\./ ? true : false
  else
    true
  end
end

def require_acl!(acl)
  validate!('acl', acl) do
    case
    when acl.kind_of?(Hash)
      AccessControlList.new(acl).validate!
      nil
    when !acl.respond_to?(:to_str) && !acl.respond_to?(:to_xml)
      "must support to_xml: #{acl.inspect}"
    when acl.nil? || acl == ''
      'may not be blank'
    else
      xml_validation_message(acl)
    end
  end
end

def require_bucket_name! bucket_name
  if [nil, ''].include?(bucket_name)
    raise ArgumentError, "bucket_name may not be blank"
  end
end

def require_policy!(policy)
  validate!('policy', policy) do
    case
    when policy.nil? || policy == ''
      'may not be blank'
    else
      json_validation_message(policy)
    end
  end
end

def require_upload_id!(upload_id)
  validate!("upload_id", upload_id) do
    "must not be blank" if upload_id.to_s.empty?
  end
end

def valid_bucket_name?(bucket_name)
  validate_bucket_name!(bucket_name) rescue false
end

def validate! name, value, &block
  if error_msg = yield
    raise ArgumentError, "#{name} #{error_msg}"
  end
  value
end

def validate_bucket_name!(bucket_name)
  validate!('bucket_name', bucket_name) do
    case
    when bucket_name.nil? || bucket_name == ''
      'may not be blank'
    when bucket_name !~ /^[a-z0-9._\-]+$/
      'may only contain lowercase letters, numbers, periods (.), ' +
      'underscores (_), and dashes (-)'
    when bucket_name !~ /^[a-z0-9]/
      'must start with a letter or a number'
    when !(3..255).include?(bucket_name.size)
      'must be between 3 and 255 characters long'
    when bucket_name =~ /(\d+\.){3}\d+/
      'must not be formatted like an IP address (e.g., 192.168.5.4)'
    when bucket_name =~ /\n/
      'must not contain a newline character'
    end
  end
end

def validate_key!(key)
  validate!('key', key) do
    case
    when key.nil? || key == ''
      'may not be blank'
    end
  end
end

def validate_parts!(parts)
  validate!("parts", parts) do
    if !parts.kind_of?(Array)
      "must not be blank"
    elsif parts.empty?
      "must contain at least one entry"
    elsif !parts.all? { |p| p.kind_of?(Hash) }
      "must be an array of hashes"
    elsif !parts.all? { |p| p[:part_number] }
      "must contain part_number for each part"
    elsif !parts.all? { |p| p[:etag] }
      "must contain etag for each part"
    elsif parts.any? { |p| p[:part_number].to_i < 1 }
      "must not have part numbers less than 1"
    end
  end
end

def xml_validation_message(obj)
  if obj.respond_to?(:to_str)
    obj = obj.to_str
  elsif obj.respond_to?(:to_xml)
    obj = obj.to_xml
  end
  error = nil
  begin
    REXML::Document.new(obj)
  rescue => e
    error = e
  end
  "contains invalid XML: #{error}" if error
end