module HTTParty::ClassMethods

def base_uri(uri = nil)
  return default_options[:base_uri] unless uri
  default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
end

def basic_auth(u, p)
  default_options[:basic_auth] = {username: u, password: p}
end

def ciphers(cipher_names)
  default_options[:ciphers] = cipher_names
end

def connection_adapter(custom_adapter = nil, options = nil)
  if custom_adapter.nil?
    default_options[:connection_adapter]
  else
    default_options[:connection_adapter] = custom_adapter
    default_options[:connection_adapter_options] = options
  end
end

def cookies(h = {})
  raise ArgumentError, 'Cookies must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
  default_cookies.add_cookies(h)
end

def copy(path, options = {}, &block)
  perform_request Net::HTTP::Copy, path, options, &block
end

def debug_output(stream = $stderr)
  default_options[:debug_output] = stream
end

def default_params(h = {})
  raise ArgumentError, 'Default params must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
  default_options[:default_params] ||= {}
  default_options[:default_params].merge!(h)
end

def default_timeout(t)
  raise ArgumentError, 'Timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
  default_options[:timeout] = t
end

def delete(path, options = {}, &block)
  perform_request Net::HTTP::Delete, path, options, &block
end

def digest_auth(u, p)
  default_options[:digest_auth] = {username: u, password: p}
end

def disable_rails_query_string_format
  query_string_normalizer Request::NON_RAILS_QUERY_STRING_NORMALIZER
end

def ensure_method_maintained_across_redirects(options)
  unless options.key?(:maintain_method_across_redirects)
    options[:maintain_method_across_redirects] = true
  end
end

def follow_redirects(value = true)
  default_options[:follow_redirects] = value
end

def format(f = nil)
  if f.nil?
    default_options[:format]
  else
    parser(Parser) if parser.nil?
    default_options[:format] = f
    validate_format
  end
end

def get(path, options = {}, &block)
  perform_request Net::HTTP::Get, path, options, &block
end

def head(path, options = {}, &block)
  ensure_method_maintained_across_redirects options
  perform_request Net::HTTP::Head, path, options, &block
end

def headers(h = nil)
  if h
    raise ArgumentError, 'Headers must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
    default_options[:headers] ||= {}
    default_options[:headers].merge!(h.to_hash)
  else
    default_options[:headers] || {}
  end
end

def http_proxy(addr = nil, port = nil, user = nil, pass = nil)
  default_options[:http_proxyaddr] = addr
  default_options[:http_proxyport] = port
  default_options[:http_proxyuser] = user
  default_options[:http_proxypass] = pass
end

def logger(logger, level = :info, format = :apache)
  default_options[:logger]     = logger
  default_options[:log_level]  = level
  default_options[:log_format] = format
end

def maintain_method_across_redirects(value = true)
  default_options[:maintain_method_across_redirects] = value
end

def mkcol(path, options = {}, &block)
  perform_request Net::HTTP::Mkcol, path, options, &block
end

def move(path, options = {}, &block)
  perform_request Net::HTTP::Move, path, options, &block
end

def no_follow(value = false)
  default_options[:no_follow] = value
end

def open_timeout(t)
  raise ArgumentError, 'open_timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
  default_options[:open_timeout] = t
end

def options(path, options = {}, &block)
  perform_request Net::HTTP::Options, path, options, &block
end

def parser(custom_parser = nil)
  if custom_parser.nil?
    default_options[:parser]
  else
    default_options[:parser] = custom_parser
    validate_format
  end
end

def patch(path, options = {}, &block)
  perform_request Net::HTTP::Patch, path, options, &block
end

def pem(pem_contents, password = nil)
  default_options[:pem] = pem_contents
  default_options[:pem_password] = password
end

def perform_request(http_method, path, options, &block) #:nodoc:
  options = ModuleInheritableAttributes.hash_deep_dup(default_options).merge(options)
  process_headers(options)
  process_cookies(options)
  Request.new(http_method, path, options).perform(&block)
end

def pkcs12(p12_contents, password)
  default_options[:p12] = p12_contents
  default_options[:p12_password] = password
end

def post(path, options = {}, &block)
  perform_request Net::HTTP::Post, path, options, &block
end

def process_cookies(options) #:nodoc:
  return unless options[:cookies] || default_cookies.any?
  options[:headers] ||= headers.dup
  options[:headers]["cookie"] = cookies.merge(options.delete(:cookies) || {}).to_cookie_string
end

def process_headers(options)
  if options[:headers] && headers.any?
    options[:headers] = headers.merge(options[:headers])
  end
end

def put(path, options = {}, &block)
  perform_request Net::HTTP::Put, path, options, &block
end

def query_string_normalizer(normalizer)
  default_options[:query_string_normalizer] = normalizer
end

def raise_on(codes = [])
  default_options[:raise_on] = *codes
end

def read_timeout(t)
  raise ArgumentError, 'read_timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
  default_options[:read_timeout] = t
end

def resend_on_redirect(value = true)
  default_options[:resend_on_redirect] = value
end

def ssl_ca_file(path)
  default_options[:ssl_ca_file] = path
end

def ssl_ca_path(path)
  default_options[:ssl_ca_path] = path
end

def ssl_version(version)
  default_options[:ssl_version] = version
end

def uri_adapter(uri_adapter)
  raise ArgumentError, 'The URI adapter should respond to #parse' unless uri_adapter.respond_to?(:parse)
  default_options[:uri_adapter] = uri_adapter
end

def validate_format
  if format && parser.respond_to?(:supports_format?) && !parser.supports_format?(format)
    raise UnsupportedFormat, "'#{format.inspect}' Must be one of: #{parser.supported_formats.map(&:to_s).sort.join(', ')}"
  end
end