module Devise::Controllers::Helpers

def self.define_helpers(mapping) #:nodoc:
  mapping = mapping.name
  class_eval <<-METHODS, __FILE__, __LINE__ + 1
    def authenticate_#{mapping}!(opts={})
      opts[:scope] = :#{mapping}
      warden.authenticate!(opts) if !devise_controller? || opts.delete(:force)
    end
    def #{mapping}_signed_in?
      !!current_#{mapping}
    end
    def current_#{mapping}
      @current_#{mapping} ||= warden.authenticate(:scope => :#{mapping})
    end
    def #{mapping}_session
      current_#{mapping} && warden.session(:#{mapping})
    end
  METHODS
  ActiveSupport.on_load(:action_controller) do
    helper_method "current_#{mapping}", "#{mapping}_signed_in?", "#{mapping}_session"
  end
end

def after_sign_in_path_for(resource_or_scope)
  stored_location_for(resource_or_scope) || signed_in_root_path(resource_or_scope)
end

def after_sign_out_path_for(resource_or_scope)
  respond_to?(:root_path) ? root_path : "/"
end

def allow_params_authentication!
  request.env["devise.allow_params_authentication"] = true
end

def devise_controller?
  is_a?(DeviseController)
end

def expire_devise_cached_variables!
  Devise.mappings.each { |_,m| instance_variable_set("@current_#{m.name}", nil) }
end

def expire_session_data_after_sign_in!
  session.keys.grep(/^devise\./).each { |k| session.delete(k) }
end

def handle_unverified_request
  sign_out_all_scopes(false)
  request.env["devise.skip_storage"] = true
  expire_devise_cached_variables!
  super # call the default behaviour which resets the session
end

def is_navigational_format?
  Devise.navigational_formats.include?(request_format)
end

def request_format
  @request_format ||= request.format.try(:ref)
end

def sign_in(resource_or_scope, *args)
  options  = args.extract_options!
  scope    = Devise::Mapping.find_scope!(resource_or_scope)
  resource = args.last || resource_or_scope
  expire_session_data_after_sign_in!
  if options[:bypass]
    warden.session_serializer.store(resource, scope)
  elsif warden.user(scope) == resource && !options.delete(:force)
    # Do nothing. User already signed in and we are not forcing it.
    true
  else
    warden.set_user(resource, options.merge!(:scope => scope))
  end
end

def sign_in_and_redirect(resource_or_scope, *args)
  options  = args.extract_options!
  scope    = Devise::Mapping.find_scope!(resource_or_scope)
  resource = args.last || resource_or_scope
  sign_in(scope, resource, options)
  redirect_to after_sign_in_path_for(resource)
end

def sign_out(resource_or_scope=nil)
  return sign_out_all_scopes unless resource_or_scope
  scope = Devise::Mapping.find_scope!(resource_or_scope)
  user = warden.user(:scope => scope, :run_callbacks => false) # If there is no user
  warden.raw_session.inspect # Without this inspect here. The session does not clear.
  warden.logout(scope)
  warden.clear_strategies_cache!(:scope => scope)
  instance_variable_set(:"@current_#{scope}", nil)
  !!user
end

def sign_out_all_scopes(lock=true)
  users = Devise.mappings.keys.map { |s| warden.user(:scope => s, :run_callbacks => false) }
  warden.raw_session.inspect
  warden.logout
  expire_devise_cached_variables!
  warden.clear_strategies_cache!
  warden.lock! if lock
  users.any?
end

def sign_out_and_redirect(resource_or_scope)
  scope = Devise::Mapping.find_scope!(resource_or_scope)
  redirect_path = after_sign_out_path_for(scope)
  Devise.sign_out_all_scopes ? sign_out : sign_out(scope)
  redirect_to redirect_path
end

def signed_in?(scope=nil)
  [ scope || Devise.mappings.keys ].flatten.any? do |_scope|
    warden.authenticate?(:scope => _scope)
  end
end

def signed_in_root_path(resource_or_scope)
  scope = Devise::Mapping.find_scope!(resource_or_scope)
  home_path = "#{scope}_root_path"
  if respond_to?(home_path, true)
    send(home_path)
  elsif respond_to?(:root_path)
    root_path
  else
    "/"
  end
end

def stored_location_for(resource_or_scope)
  scope = Devise::Mapping.find_scope!(resource_or_scope)
  if is_navigational_format?
    session.delete("#{scope}_return_to")
  else
    session["#{scope}_return_to"]
  end
end

def warden
  request.env['warden']
end