class Warden::Proxy

def _fetch_strategy: (Symbol name, Symbol scope) -> untyped

def _fetch_strategy(name, scope)
  @strategies[scope][name] ||= if klass = Warden::Strategies[name]
    klass.new(@env, scope)
  elsif @config.silence_missing_strategies?
    nil
  else
    raise "Invalid strategy #{name}"
  end
end

def _perform_authentication: (* args) -> untyped

def _perform_authentication(*args)
  scope, opts = _retrieve_scope_and_opts(args)
  user = nil
  # Look for an existing user in the session for this scope.
  # If there was no user in the session, see if we can get one from the request.
  return user, opts if user = user(opts.merge(:scope => scope))
  _run_strategies_for(scope, args)
  if winning_strategy && winning_strategy.successful?
    opts[:store] = opts.fetch(:store, winning_strategy.store?)
    set_user(winning_strategy.user, opts.merge!(:event => :authentication))
  end
  [@users[scope], opts]
end

def _retrieve_scope_and_opts: ( args) -> untyped

def _retrieve_scope_and_opts(args) #:nodoc:
  opts  = args.last.is_a?(Hash) ? args.pop : {}
  scope = opts[:scope] || @config.default_scope
  opts  = (@config[:scope_defaults][scope] || {}).merge(opts)
  [scope, opts]
end

def _run_strategies_for: (Symbol scope,  args) -> untyped

def _run_strategies_for(scope, args) #:nodoc:
  self.winning_strategy = @winning_strategies[scope]
  return if winning_strategy && winning_strategy.halted?
  # Do not run any strategy if locked
  return if @locked
  if args.empty?
    defaults   = @config[:default_strategies]
    strategies = defaults[scope] || defaults[:_all]
  end
  (strategies || args).each do |name|
    strategy = _fetch_strategy(name, scope)
    next unless strategy && !strategy.performed? && strategy.valid?
    catch(:warden) do
      _update_winning_strategy(strategy, scope)
    end
    strategy._run!
    _update_winning_strategy(strategy, scope)
    break if strategy.halted?
  end
end

def _update_winning_strategy(strategy, scope)
  self.winning_strategy = @winning_strategies[scope] = strategy
end

def asset_request?
  ::Warden::asset_paths.any? { |r| env['PATH_INFO'].to_s.match(r) }
end

def authenticate: (* args) -> untyped

def authenticate(*args)
  user, _opts = _perform_authentication(*args)
  user
end

def authenticate!(*args)
  user, opts = _perform_authentication(*args)
  throw(:warden, opts) unless user
  user
end

def authenticate?: (* args) -> untyped

def authenticate?(*args)
  result = !!authenticate(*args)
  yield if result && block_given?
  result
end

def authenticated?(scope = @config.default_scope)
  result = !!user(scope)
  yield if block_given? && result
  result
end

def clear_strategies_cache!(*args)
  scope, _opts = _retrieve_scope_and_opts(args)
  @winning_strategies.delete(scope)
  @strategies[scope].each do |k, v|
    v.clear! if args.empty? || args.include?(k)
  end
end

def custom_failure!
  @custom_failure = true
end

def custom_failure?
  if instance_variable_defined?(:@custom_failure)
    !!@custom_failure
  else
    false
  end
end

def errors
  @env[ENV_WARDEN_ERRORS] ||= Errors.new
end

def initialize(env, manager) #:nodoc:
  @env, @users, @winning_strategies, @locked = env, {}, {}, false
  @manager, @config = manager, manager.config.dup
  @strategies = Hash.new { |h,k| h[k] = {} }
end

def inspect(*args)
  "Warden::Proxy:#{object_id} @config=#{@config.inspect}"
end

def lock!
  @locked = true
end

def logout(*scopes)
  if scopes.empty?
    scopes = @users.keys
    reset_session = true
  end
  scopes.each do |scope|
    user = @users.delete(scope)
    manager._run_callbacks(:before_logout, user, self, :scope => scope)
    raw_session.delete("warden.user.#{scope}.session") unless raw_session.nil?
    session_serializer.delete(scope, user)
  end
  reset_session! if reset_session
end

def message
  winning_strategy && winning_strategy.message
end

def on_request
  manager._run_callbacks(:on_request, self)
end

def result # :nodoc:
  winning_strategy && winning_strategy.result
end

def session(scope = @config.default_scope)
  raise NotAuthenticated, "#{scope.inspect} user is not logged in" unless authenticated?(scope)
  raw_session["warden.user.#{scope}.session"] ||= {}
end

def session_serializer
  @session_serializer ||= Warden::SessionSerializer.new(@env)
end

def set_user(user, opts = {})
  scope = (opts[:scope] ||= @config.default_scope)
  # Get the default options from the master configuration for the given scope
  opts = (@config[:scope_defaults][scope] || {}).merge(opts)
  opts[:event] ||= :set_user
  @users[scope] = user
  if opts[:store] != false && opts[:event] != :fetch
    options = env[ENV_SESSION_OPTIONS]
    if options
      if options.frozen?
        env[ENV_SESSION_OPTIONS] = options.merge(:renew => true).freeze
      else
        options[:renew] = true
      end
    end
    session_serializer.store(user, scope)
  end
  run_callbacks = opts.fetch(:run_callbacks, true)
  manager._run_callbacks(:after_set_user, user, self, opts) if run_callbacks
  @users[scope]
end

def to_s(*args)
  inspect(*args)
end

def unauthenticated?(scope = @config.default_scope)
  result = !authenticated?(scope)
  yield if block_given? && result
  result
end

def user: (?scope | Symbol argument) -> User

def user(argument = {})
  opts  = argument.is_a?(Hash) ? argument : { :scope => argument }
  scope = (opts[:scope] ||= @config.default_scope)
  if @users.has_key?(scope)
    @users[scope]
  else
    unless user = session_serializer.fetch(scope)
      run_callbacks = opts.fetch(:run_callbacks, true)
      manager._run_callbacks(:after_failed_fetch, user, self, :scope => scope) if run_callbacks
    end
    @users[scope] = user ? set_user(user, opts.merge(:event => :fetch)) : nil
  end
end