module Faraday::Utils

def URI(url)
  if url.respond_to?(:host)
    url
  elsif url.respond_to?(:to_str)
    default_uri_parser.call(url)
  else
    raise ArgumentError, "bad argument (expected URI object or URI string)"
  end
end

def build_nested_query(params)
  NestedParamsEncoder.encode(params)
end

def build_query(params)
  FlatParamsEncoder.encode(params)
end

def deep_merge(source, hash)
  deep_merge!(source.dup, hash)
end

def deep_merge!(target, hash)
  hash.each do |key, value|
    if Hash === value and Hash === target[key]
      target[key] = deep_merge(target[key], value)
    else
      target[key] = value
    end
  end
  target
end

def default_params_encoder
  @default_params_encoder ||= NestedParamsEncoder
end

def default_uri_parser
  @default_uri_parser ||= begin
    require 'uri'
    Kernel.method(:URI)
  end
end

def default_uri_parser=(parser)
  @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
    parser
  else
    parser.method(:parse)
  end
end

def escape(s)
  s.to_s.gsub(ESCAPE_RE) {|match|
    '%' + match.unpack('H2' * match.bytesize).join('%').upcase
  }.tr(' ', '+')
end

def normalize_params(params, name, v = nil)
  name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
  k = $1 || ''
  after = $' || ''
  return if k.empty?
  if after == ""
    if params[k]
      params[k] = Array[params[k]] unless params[k].kind_of?(Array)
      params[k] << v
    else
      params[k] = v
    end
  elsif after == "[]"
    params[k] ||= []
    raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
    params[k] << v
  elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
    child_key = $1
    params[k] ||= []
    raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
    if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
      normalize_params(params[k].last, child_key, v)
    else
      params[k] << normalize_params({}, child_key, v)
    end
  else
    params[k] ||= {}
    raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
    params[k] = normalize_params(params[k], after, v)
  end
  return params
end

def normalize_path(url)
  url = URI(url)
  (url.path.start_with?('/') ? url.path : '/' + url.path) +
  (url.query ? "?#{sort_query_params(url.query)}" : "")
end

def parse_nested_query(query)
  NestedParamsEncoder.decode(query)
end

def parse_query(query)
  FlatParamsEncoder.decode(query)
end

def sort_query_params(query)
  query.split('&').sort.join('&')
end

def unescape(s) CGI.unescape s.to_s end