require 'uri'
require 'query_string_parser'

module Fanforce::Utils

  def self.included(base)
    base.extend(Fanforce::Utils)
  end

  def self.blank?(obj)
    obj.respond_to?(:empty?) ? obj.empty? : !obj
  end

  def self.present?(obj)
    !blank?(obj)
  end

  def self.valid_request?(params)
    return false if !params.is_a?(Hash)
    return false if blank?(params[:fanforce_id])
    return false if blank?(params[:app_id]) and blank?(params[:behavior_id]) and blank?(params[:module_id]) and blank?(params[:widget_id])
    return true
  end

  def self.valid_install_request?(params)
    return false if !params.is_a?(Hash)
    return false if blank?(params[:fanforce_id])
    return false if blank?(params[:app_id]) and blank?(params[:behavior_id]) and blank?(params[:module_id]) and blank?(params[:widget_id])
    return false if blank?(params[:api_key])
    return true
  end

  def self.valid_uninstall_request?(params)
    return false if !params.is_a?(Hash)
    return false if blank?(params[:fanforce_id])
    return false if blank?(params[:app_id]) and blank?(params[:behavior_id]) and blank?(params[:module_id]) and blank?(params[:widget_id])
    return false if blank?(params[:api_key])
    return true
  end

  def self.parse_params(params)
    if present?(params[:app_id])
      plugin_type = :app
      plugin_id = params[:app_id]
    elsif present?(params[:behavior_id])
      plugin_type = :behavior
      plugin_id = params[:behavior_id]
    elsif present?(params[:module_id])
      plugin_type = :module
      plugin_id = params[:module_id]
    elsif present?(params[:widget_id])
      plugin_type = :widget
      plugin_id = params[:widget_id]
    end
    {:"#{plugin_type}_id" => params["#{plugin_type}_id"], plugin_type: plugin_type, plugin_id: plugin_id, fanforce_id: params[:fanforce_id], api_key: params[:api_key]}
  end

  def self.parse_url(raw_url)
    return if blank?(raw_url)
    url = URI::parse(raw_url)
    query_params = QueryStringParser.qs_parse(url.query).inject({}) do |result, (k,v)|
      result[k] = v if k !~ /^ff_.+/
      result
    end
    query_string = to_query_string(Hash[query_params.sort]) if present?(query_params)
    _external_id = url.host + url.path
    clean_url = "#{url.scheme}://#{url.host}#{(if ![80,443].include?(url.port) then ":#{url.port}" end)}#{url.path}#{(if present?(query_string) then "?#{query_string}" end)}"

    { _external_id: _external_id, clean_url: clean_url, raw_url: raw_url, query_params: query_params, query_string: query_string, scheme: url.scheme, host: url.host, port: url.port, path: url.path, fragment: url.fragment }
  end

  def self.to_query_string(params, namespace = nil)
    if params.is_a?(String)
      params
    elsif params.is_a?(Array)
      params.collect { |value| to_query_chunk(value, "#{namespace}[]") }.join '&'
    elsif params.is_a?(Hash)
      params.collect { |key, value| to_query_chunk(value, namespace ? "#{namespace}[#{key}]" : key) }.sort * '&'
    else
      raise "params must be an Object, Hash, or Array"
    end
  end

  def self.to_query_chunk(value,key)
    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
    "#{CGI.escape(to_query_string(key))}=#{CGI.escape(to_query_string(value).to_s)}"
  end

end