module Merb
  module ControllerMixin
  
    # redirect to another url It can be like /foo/bar
    # for redirecting within your same app. Or it can
    # be a fully qualified url to another site.
    def redirect(url)
      MERB_LOGGER.info("Redirecting to: #{url}")
      @status = 302
      headers.merge!({'Location'=> url})
      return ''
    end
    
    # pass in a path to a file and this will set the
    # right headers and let mongrel do its thang and
    # serve the static file directly.
    def send_file(file)
      headers['X-SENDFILE'] = file
      return
    end
    
    # This uses nginx X-Accel-Redirect header to send
    # a file directly from nginx. See the nginx wiki:
    # http://wiki.codemongers.com/NginxXSendfile
    def nginx_send_file(file)
      headers['X-Accel-Redirect'] = file
      return
    end  
  
    # parses a query string or the payload of a POST
    # request into the params hash. So for example:
    # /foo?bar=nik&post[title]=heya&post[body]=whatever
    # parses into:
    # {:bar => 'nik', :post => {:title => 'heya', :body => 'whatever}}
    def query_parse(qs, d = '&;')
      m = proc {|_,o,n|o.u(n,&m)rescue([*o]<<n)}
      (qs||'').split(/[#{d}] */n).inject(MerbHash[]) { |h,p| 
              k, v=unescape(p).split('=',2)
              h.u(k.split(/[\]\[]+/).reverse.
                inject(v) { |x,i| MerbHash[i,x] },&m)
          }
    end
  
    def make_token
      require 'digest/md5'
      Digest::MD5.hexdigest("#{inspect}#{Time.now}#{rand}")
    end  
  
    # does url escaping
    def escape(s)
      Mongrel::HttpRequest.escape(s)
    end
  
    # does url unescaping
    def unescape(s)
      Mongrel::HttpRequest.unescape(s)
    end
  
    # returns true if the request is an ajax request.
    def xml_http_request?
      not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil?
    end
    alias xhr? :xml_http_request?
    alias ajax? :xml_http_request?
  
    # returns the remote IP address if it can find it.
    def remote_ip
      return @env['HTTP_CLIENT_IP'] if @env.include?('HTTP_CLIENT_IP')
  
      if @env.include?(Mongrel::Const::HTTP_X_FORWARDED_FOR) then
        remote_ips = @env[Mongrel::Const::HTTP_X_FORWARDED_FOR].split(',').reject do |ip|
          ip =~ /^unknown$|^(127|10|172\.16|192\.168)\./i
        end
  
        return remote_ips.first.strip unless remote_ips.empty?
      end
  
      return @env[Mongrel::Const::REMOTE_ADDR]
    end
    
    # returns either 'https://' or 'http://' depending on
    # the HTTPS header
    def protocol
      @env['HTTPS'] == 'on' ? 'https://' : 'http://'
    end
    
    # returns true if the request is an SSL request
    def ssl?
      @env['HTTPS'] == 'on'
    end
    
    # The request uri.
    def uri
      @env['REQUEST_URI']
    end
    
    # The path is the uri without the query string.
    def path
      uri ? uri.split('?').first : ''
    end
  
    def path_info
      @env['PATH_INFO']
    end
    
    def port
      @env['SERVER_PORT'].to_i
    end
  
    def host
      @env['HTTP_X_FORWARDED_HOST'] || @env['HTTP_HOST'] 
    end
    
    def subdomains(tld_length = 1)
      parts = host.split('.')
      parts[0..-(tld_length+2)]
    end
    
    def domain(tld_length = 1)
      host.split('.').last(1 + tld_length).join('.')
    end
    
    def method
      @method ||= @env['REQUEST_METHOD']
    end  
    
    [:get, :post, :put, :delete, :head].each do |m|
      eval %{
        def #{m}?; method == :#{m}; end
      }
    end
  end
end