class AWS::S3::PresignedPost

def build_uri(request)
  uri_class = secure? ? URI::HTTPS : URI::HTTP
  uri_class.build(:host => request.host,
                  :path => request.path,
                  :query => request.querystring)
end

def field_name(option_name)
  case option_name
  when :expires_header
    "Expires"
  when :server_side_encryption
    "x-amz-server-side-encryption"
  when :acl, :success_action_redirect, :success_action_status
    option_name.to_s
  else
    # e.g. Cache-Control from cache_control
    field_name = option_name.to_s.tr("_", "-").
      gsub(/-(.)/) { |m| m.upcase }
    field_name[0,1] = field_name[0,1].upcase
    field_name
  end
end

def field_value(option_name)
  case option_name
  when :acl
    @fields[:acl].to_s.tr("_", "-")
  when :server_side_encryption
    value = @fields[:server_side_encryption]
    if value.kind_of?(Symbol)
      value.to_s.upcase
    else
      value.to_s
    end
  else
    @fields[option_name].to_s
  end
end

def fields
  signature =
    config.signer.sign(policy, "sha1")
  {
    "AWSAccessKeyId" => config.signer.access_key_id,
    "key" => key,
    "policy" => policy,
    "signature" => signature
  }.merge(optional_fields)
end

def format_expiration
  time = expires || Time.now.utc + 60*60
  time =
    case time
    when Time
      time
    when DateTime
      Time.parse(time.to_s)
    when Integer
      (Time.now + time)
    when String
      Time.parse(time)
    end
  time.utc.iso8601
end

def generate_conditions
  conditions.inject([]) do |ary, (field, field_conds)|
    ary += field_conds
  end +
    [{ "bucket" => bucket.name }] +
    key_conditions +
    optional_fields.map { |(n, v)| Hash[[[n, v]]] } +
    range_conditions +
    ignored_conditions
end

def ignored_conditions
  ignored_fields.map do |field|
    ["starts-with", "$#{field}", ""]
  end
end

def initialize(bucket, opts = {})
  @bucket = bucket
  @key = opts[:key]
  @secure = (opts[:secure] != false)
  @fields = {}
  SPECIAL_FIELDS.each do |name|
    @fields[name] = opts[name] if opts.key?(name)
  end
  @metadata = opts[:metadata] || {}
  @content_length = range_value(opts[:content_length])
  @conditions = opts[:conditions] || {}
  @ignored_fields = [opts[:ignore]].flatten.compact
  @expires = opts[:expires]
  super
  @fields[:server_side_encryption] =
    config.s3_server_side_encryption unless
    @fields.key?(:server_side_encryption)
  @fields.delete(:server_side_encryption) if
    @fields[:server_side_encryption].nil?
end

def key_conditions
  [if key && key.include?("${filename}")
     ["starts-with", "$key", key[/^(.*)\$\{filename\}/, 1]]
   elsif key
     { "key" => key }
   else
     ["starts-with", "$key", ""]
   end]
end

def optional_fields
  fields = (SPECIAL_FIELDS &
            @fields.keys).inject({}) do |fields, option_name|
    fields[field_name(option_name)] =
      field_value(option_name)
    fields
  end
  @metadata.each do |key, value|
    fields["x-amz-meta-#{key}"] = value.to_s
  end
  fields
end

def policy
  json = {
    "expiration" => format_expiration,
    "conditions" => generate_conditions
  }.to_json
  Base64.encode64(json).tr("\n","")
end

def range_conditions
  if content_length
    [["content-length-range", *split_range(content_length)]]
  else
    []
  end
end

def range_value(range)
  case range
  when Integer
    range..range
  when Range
    range
  end
end

def refine(opts)
  self.class.new(bucket, {
                   :conditions => conditions,
                   :key => key,
                   :metadata => metadata,
                   :secure => secure?,
                   :content_length => content_length,
                   :expires => expires,
                   :ignore => ignored_fields
                 }.merge(@fields).
                 merge(opts))
end

def secure?
  @secure
end

def split_range(range)
  range = range_value(range)
  [range.begin,
   (range.exclude_end? ?
    range.end-1 :
    range.end)]
end

def url
  req = Request.new
  req.bucket = bucket.name
  req.host = config.s3_endpoint
  build_uri(req)
end

def where(field)
  raise ArgumentError.new("unrecognized field name #{field}") unless
    [:key, :content_length, *SPECIAL_FIELDS].include?(field) or
    field =~ /^x-amz-meta-/
  ConditionBuilder.new(self, field)
end

def where_metadata(field)
  where("x-amz-meta-#{field}")
end

def with_condition(field, condition)
  conditions = self.conditions.dup
  (conditions[field] ||= []) << condition
  refine(:conditions => conditions)
end

def with_equality_condition(option_name, value)
  field_name = field_name(option_name)
  with_condition(option_name, Hash[[[field_name, value]]])
end

def with_prefix_condition(option_name, prefix)
  field_name = field_name(option_name)
  with_condition(option_name,
                 ["starts-with", "$#{field_name}", prefix])
end