unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__) + "/.."))
  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/.."))
end

require "uri"
require "rack"
require "rack/mock_session"
require "rack/test/cookie_jar"
require "rack/test/mock_digest_request"
require "rack/test/utils"
require "rack/test/methods"
require "rack/test/uploaded_file"

module Rack
  module Test

    VERSION = "0.4.0"

    DEFAULT_HOST = "example.org"
    MULTIPART_BOUNDARY = "----------XnJLe9ZIbbGUYtzPQJ16u1"

    # The common base class for exceptions raised by Rack::Test
    class Error < StandardError; end

    class Session
      extend Forwardable
      include Rack::Test::Utils

      def_delegators :@rack_mock_session, :clear_cookies, :set_cookie, :last_response, :last_request

      # Initialize a new session for the given Rack app
      def initialize(mock_session)
        @headers = {}

        if mock_session.is_a?(MockSession)
          @rack_mock_session = mock_session
        else
          @rack_mock_session = MockSession.new(mock_session)
        end

        @default_host = @rack_mock_session.default_host
      end

      # Issue a GET request for the given URI with the given params and Rack
      # environment. Stores the issues request object in #last_request and
      # the app's response in #last_response. Yield #last_response to a block
      # if given.
      #
      # Example:
      #   get "/"
      def get(uri, params = {}, env = {}, &block)
        env = env_for(uri, env.merge(:method => "GET", :params => params))
        process_request(uri, env, &block)
      end

      # Issue a POST request for the given URI. See #get
      #
      # Example:
      #   post "/signup", "name" => "Bryan"
      def post(uri, params = {}, env = {}, &block)
        env = env_for(uri, env.merge(:method => "POST", :params => params))
        process_request(uri, env, &block)
      end

      # Issue a PUT request for the given URI. See #get
      #
      # Example:
      #   put "/"
      def put(uri, params = {}, env = {}, &block)
        env = env_for(uri, env.merge(:method => "PUT", :params => params))
        process_request(uri, env, &block)
      end

      # Issue a DELETE request for the given URI. See #get
      #
      # Example:
      #   delete "/"
      def delete(uri, params = {}, env = {}, &block)
        env = env_for(uri, env.merge(:method => "DELETE", :params => params))
        process_request(uri, env, &block)
      end

      # Issue a HEAD request for the given URI. See #get
      #
      # Example:
      #   head "/"
      def head(uri, params = {}, env = {}, &block)
        env = env_for(uri, env.merge(:method => "HEAD", :params => params))
        process_request(uri, env, &block)
      end

      # Issue a request to the Rack app for the given URI and optional Rack
      # environment. Stores the issues request object in #last_request and
      # the app's response in #last_response. Yield #last_response to a block
      # if given.
      #
      # Example:
      #   request "/"
      def request(uri, env = {}, &block)
        env = env_for(uri, env)
        process_request(uri, env, &block)
      end

      # Set a header to be included on all subsequent requests through the
      # session. Use a value of nil to remove a previously configured header.
      #
      # Example:
      #   header "User-Agent", "Firefox"
      def header(name, value)
        if value.nil?
          @headers.delete(name)
        else
          @headers[name] = value
        end
      end

      # Set the username and password for HTTP Basic authorization, to be
      # included in subsequent requests in the HTTP_AUTHORIZATION header.
      #
      # Example:
      #   basic_authorize "bryan", "secret"
      def basic_authorize(username, password)
        encoded_login = ["#{username}:#{password}"].pack("m*")
        header('HTTP_AUTHORIZATION', "Basic #{encoded_login}")
      end

      alias_method :authorize, :basic_authorize

      def digest_authorize(username, password)
        @digest_username = username
        @digest_password = password
      end

      # Rack::Test will not follow any redirects automatically. This method
      # will follow the redirect returned in the last response. If the last
      # response was not a redirect, an error will be raised.
      def follow_redirect!
        unless last_response.redirect?
          raise Error.new("Last response was not a redirect. Cannot follow_redirect!")
        end

        get(last_response["Location"])
      end

    private

      def env_for(path, env)
        uri = URI.parse(path)
        uri.host ||= @default_host

        env = default_env.merge(env)

        env.update("HTTPS" => "on")                if URI::HTTPS === uri
        env["X-Requested-With"] = "XMLHttpRequest" if env[:xhr]

        if (env[:method] == "POST" || env["REQUEST_METHOD"] == "POST" ||
            env[:method] == "PUT" || env["REQUEST_METHOD"] == "PUT") && !env.has_key?(:input)
          env["CONTENT_TYPE"] ||= "application/x-www-form-urlencoded"

          multipart = (Hash === env[:params]) &&
            env[:params].any? { |_, v| UploadedFile === v }

          if multipart
            env[:input] = multipart_body(env.delete(:params))
            env["CONTENT_LENGTH"] ||= env[:input].length.to_s
            env["CONTENT_TYPE"] = "multipart/form-data; boundary=#{MULTIPART_BOUNDARY}"
          else
            env[:input] = params_to_string(env.delete(:params))
          end
        end

        params = env[:params] || {}
        params.update(parse_query(uri.query))

        uri.query = requestify(params)

        if env.has_key?(:cookie)
          set_cookie(env.delete(:cookie), uri)
        end

        Rack::MockRequest.env_for(uri.to_s, env)
      end

      def process_request(uri, env)
        uri = URI.parse(uri)
        uri.host ||= @default_host

        @rack_mock_session.request(uri, env)

        if retry_with_digest_auth?(env)
          auth_env = env.merge({
            "HTTP_AUTHORIZATION"          => digest_auth_header,
            "rack-test.digest_auth_retry" => true
          })
          auth_env.delete('rack.request')
          process_request(uri.path, auth_env)
        else
          yield last_response if block_given?

          last_response
        end
      end

      def digest_auth_header
        challenge = last_response["WWW-Authenticate"].split(" ", 2).last
        params = Rack::Auth::Digest::Params.parse(challenge)

        params.merge!({
          "username"  => @digest_username,
          "nc"        => "00000001",
          "cnonce"    => "nonsensenonce",
          "uri"       => last_request.path_info,
          "method"    => last_request.env["REQUEST_METHOD"],
        })

        params["response"] = MockDigestRequest.new(params).response(@digest_password)

        "Digest #{params}"
      end

      def retry_with_digest_auth?(env)
        last_response.status == 401 &&
        digest_auth_configured? &&
        !env["rack-test.digest_auth_retry"]
      end

      def digest_auth_configured?
        @digest_username
      end

      def default_env
        { "rack.test" => true, "REMOTE_ADDR" => "127.0.0.1" }.merge(@headers)
      end

      def params_to_string(params)
        case params
        when Hash then requestify(params)
        when nil  then ""
        else params
        end
      end

    end

  end
end