module Sinatra::Helpers

def attachment(filename=nil)
  response['Content-Disposition'] = 'attachment'
  if filename
    params = '; filename="%s"' % File.basename(filename)
    response['Content-Disposition'] << params
  end
end

def back ; request.referer ; end

def body(value=nil, &block)
  if block_given?
    def block.each; yield(call) end
    response.body = block
  elsif value
    response.body = value
  else
    response.body
  end
end

def cache_control(*values)
  if values.last.kind_of?(Hash)
    hash = values.pop
    hash.reject! { |k,v| v == false }
    hash.reject! { |k,v| values << k if v == true }
  else
    hash = {}
  end
  values = values.map { |value| value.to_s.tr('_','-') }
  hash.each do |key, value|
    key = key.to_s.tr('_', '-')
    value = value.to_i if key == "max-age"
    values << [key, value].join('=')
  end
  response['Cache-Control'] = values.join(', ') if values.any?
end

def content_type(type, params={})
  default = params.delete :default
  mime_type = mime_type(type) || default
  fail "Unknown media type: %p" % type if mime_type.nil?
  mime_type = mime_type.dup
  unless params.include? :charset or settings.add_charset.all? { |p| not p === mime_type }
    params[:charset] = params.delete('charset') || settings.default_encoding
  end
  mime_type << ";#{params.map { |kv| kv.join('=') }.join(', ')}" unless params.empty?
  response['Content-Type'] = mime_type
end

def error(code, body=nil)
  code, body    = 500, code.to_str if code.respond_to? :to_str
  response.body = body unless body.nil?
  halt code
end

def etag(value, kind=:strong)
  raise TypeError, ":strong or :weak expected" if ![:strong,:weak].include?(kind)
  value = '"%s"' % value
  value = 'W/' + value if kind == :weak
  response['ETag'] = value
  # Conditional GET check
  if etags = env['HTTP_IF_NONE_MATCH']
    etags = etags.split(/\s*,\s*/)
    halt 304 if etags.include?(value) || etags.include?('*')
  end
end

def expires(amount, *values)
  values << {} unless values.last.kind_of?(Hash)
  if amount.respond_to?(:to_time)
    max_age = amount.to_time - Time.now
    time = amount.to_time
  else
    max_age = amount
    time = Time.now + amount
  end
  values.last.merge!(:max_age => max_age)
  cache_control(*values)
  response['Expires'] = time.httpdate
end

def headers(hash=nil)
  response.headers.merge! hash if hash
  response.headers
end

def last_modified(time)
  return unless time
  if time.respond_to?(:to_time)
      time = time.to_time
  else
      ## make a best effort to convert something else to a time object
      ## if this fails, this should throw an ArgumentError, then the
      # rescue will result in an http 200, which should be safe
      time = Time.parse(time.to_s)
  end
  response['Last-Modified'] = time.httpdate
  # compare based on seconds since epoch
  halt 304 if Time.httpdate(request.env['HTTP_IF_MODIFIED_SINCE']).to_i >= time.to_i
rescue ArgumentError
end

def mime_type(type)
  Base.mime_type(type)
end

def not_found(body=nil)
  error 404, body
end

def redirect(uri, *args)
  if not uri =~ /^https?:\/\//
    # According to RFC 2616 section 14.30, "the field value consists of a
    # single absolute URI"
    abs_uri = "#{request.scheme}://#{request.host}"
    if request.scheme == 'https' && request.port != 443 ||
          request.scheme == 'http' && request.port != 80
      abs_uri << ":#{request.port}"
    end
    uri = (abs_uri << uri)
  end
  status 302
  response['Location'] = uri
  halt(*args)
end

def send_file(path, opts={})
  stat = File.stat(path)
  last_modified stat.mtime
  if opts[:type] or not response['Content-Type']
    content_type opts[:type] || File.extname(path), :default => 'application/octet-stream'
  end
  if opts[:disposition] == 'attachment' || opts[:filename]
    attachment opts[:filename] || path
  elsif opts[:disposition] == 'inline'
    response['Content-Disposition'] = 'inline'
  end
  file_length = opts[:length] || stat.size
  sf = StaticFile.open(path, 'rb')
  if ! sf.parse_ranges(env, file_length)
    response['Content-Range'] = "bytes */#{file_length}"
    halt 416
  elsif r=sf.range
    response['Content-Range'] = "bytes #{r.begin}-#{r.end}/#{file_length}"
    response['Content-Length'] = (r.end - r.begin + 1).to_s
    halt 206, sf
  else
    response['Content-Length'] ||= file_length.to_s
    halt sf
  end
rescue Errno::ENOENT
  not_found
end

def session
  request.session
end

def status(value=nil)
  response.status = value if value
  response.status
end