class Rails::Application

def self.add_lib_to_load_path!(root) # :nodoc:
  path = File.join root, "lib"
  if File.exist?(path) && !$LOAD_PATH.include?(path)
    $LOAD_PATH.unshift(path)
  end
end

def build_middleware
  config.app_middleware + super
end

def build_request(env)
  req = super
  env["ORIGINAL_FULLPATH"] = req.fullpath
  env["ORIGINAL_SCRIPT_NAME"] = req.script_name
  req
end

def coerce_same_site_protection(protection)
  protection.respond_to?(:call) ? protection : proc { protection }
end

def config # :nodoc:
  @config ||= Application::Configuration.new(self.class.find_root(self.class.called_from))
end

def config_for(name, env: Rails.env)
  yaml = name.is_a?(Pathname) ? name : Pathname.new("#{paths["config"].existent.first}/#{name}.yml")
  if yaml.exist?
    require "erb"
    all_configs    = ActiveSupport::ConfigurationFile.parse(yaml).deep_symbolize_keys
    config, shared = all_configs[env.to_sym], all_configs[:shared]
    if shared
      config = {} if config.nil? && shared.is_a?(Hash)
      if config.is_a?(Hash) && shared.is_a?(Hash)
        config = shared.deep_merge(config)
      elsif config.nil?
        config = shared
      end
    end
    if config.is_a?(Hash)
      config = ActiveSupport::OrderedOptions.new.update(config)
    end
    config
  else
    raise "Could not load configuration. No such file - #{yaml}"
  end
end

def console(&blk)
  self.class.console(&blk)
end

def create(initial_variable_values = {}, &block)
  new(initial_variable_values, &block).run_load_hooks!
end

def credentials
  @credentials ||= encrypted(config.credentials.content_path, key_path: config.credentials.key_path)
end

def default_middleware_stack # :nodoc:
  default_stack = DefaultMiddlewareStack.new(self, config, paths)
  default_stack.build_stack
end

def eager_load!
  Rails.autoloaders.each(&:eager_load)
end

def encrypted(path, key_path: "config/master.key", env_key: "RAILS_MASTER_KEY")
  ActiveSupport::EncryptedConfiguration.new(
    config_path: Rails.root.join(path),
    key_path: Rails.root.join(key_path),
    env_key: env_key,
    raise_if_missing_key: config.require_master_key
  )
end

def env_config
  @app_env_config ||= super.merge(
      "action_dispatch.parameter_filter" => config.filter_parameters,
      "action_dispatch.redirect_filter" => config.filter_redirect,
      "action_dispatch.secret_key_base" => secret_key_base,
      "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions,
      "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
      "action_dispatch.log_rescued_responses" => config.action_dispatch.log_rescued_responses,
      "action_dispatch.logger" => Rails.logger,
      "action_dispatch.backtrace_cleaner" => Rails.backtrace_cleaner,
      "action_dispatch.key_generator" => key_generator,
      "action_dispatch.http_auth_salt" => config.action_dispatch.http_auth_salt,
      "action_dispatch.signed_cookie_salt" => config.action_dispatch.signed_cookie_salt,
      "action_dispatch.encrypted_cookie_salt" => config.action_dispatch.encrypted_cookie_salt,
      "action_dispatch.encrypted_signed_cookie_salt" => config.action_dispatch.encrypted_signed_cookie_salt,
      "action_dispatch.authenticated_encrypted_cookie_salt" => config.action_dispatch.authenticated_encrypted_cookie_salt,
      "action_dispatch.use_authenticated_cookie_encryption" => config.action_dispatch.use_authenticated_cookie_encryption,
      "action_dispatch.encrypted_cookie_cipher" => config.action_dispatch.encrypted_cookie_cipher,
      "action_dispatch.signed_cookie_digest" => config.action_dispatch.signed_cookie_digest,
      "action_dispatch.cookies_serializer" => config.action_dispatch.cookies_serializer,
      "action_dispatch.cookies_digest" => config.action_dispatch.cookies_digest,
      "action_dispatch.cookies_rotations" => config.action_dispatch.cookies_rotations,
      "action_dispatch.cookies_same_site_protection" => coerce_same_site_protection(config.action_dispatch.cookies_same_site_protection),
      "action_dispatch.use_cookies_with_metadata" => config.action_dispatch.use_cookies_with_metadata,
      "action_dispatch.content_security_policy" => config.content_security_policy,
      "action_dispatch.content_security_policy_report_only" => config.content_security_policy_report_only,
      "action_dispatch.content_security_policy_nonce_generator" => config.content_security_policy_nonce_generator,
      "action_dispatch.content_security_policy_nonce_directives" => config.content_security_policy_nonce_directives,
      "action_dispatch.permissions_policy" => config.permissions_policy,
    )
end

def find_root(from)
  find_root_with_flag "config.ru", from, Dir.pwd
end

def generate_development_secret
  if secrets.secret_key_base.nil?
    key_file = Rails.root.join("tmp/development_secret.txt")
    if !File.exist?(key_file)
      random_key = SecureRandom.hex(64)
      FileUtils.mkdir_p(key_file.dirname)
      File.binwrite(key_file, random_key)
    end
    secrets.secret_key_base = File.binread(key_file)
  end
  secrets.secret_key_base
end

def generators(&blk)
  self.class.generators(&blk)
end

def helpers_paths # :nodoc:
  config.helpers_paths
end

def inherited(base)
  super
  Rails.app_class = base
  add_lib_to_load_path!(find_root(base.called_from))
  ActiveSupport.run_load_hooks(:before_configuration, base)
end

def initialize(initial_variable_values = {}, &block)
  super()
  @initialized       = false
  @reloaders         = []
  @routes_reloader   = nil
  @app_env_config    = nil
  @ordered_railties  = nil
  @railties          = nil
  @message_verifiers = {}
  @ran_load_hooks    = false
  @executor          = Class.new(ActiveSupport::Executor)
  @reloader          = Class.new(ActiveSupport::Reloader)
  @reloader.executor = @executor
  @autoloaders = Rails::Autoloaders.new
  # are these actually used?
  @initial_variable_values = initial_variable_values
  @block = block
end

def initialize!(group = :default) # :nodoc:
  raise "Application has been already initialized." if @initialized
  run_initializers(group, self)
  @initialized = true
  self
end

def initialized?
  @initialized
end

def initializer(name, opts = {}, &block)
  self.class.initializer(name, opts, &block)
end

def initializers # :nodoc:
  Bootstrap.initializers_for(self) +
  railties_initializers(super) +
  Finisher.initializers_for(self)
end

def instance
  super.run_load_hooks!
end

def isolate_namespace(mod)
  self.class.isolate_namespace(mod)
end

def key_generator
  # number of iterations selected based on consultation with the google security
  # team. Details at https://github.com/rails/rails/pull/6952#issuecomment-7661220
  @caching_key_generator ||= ActiveSupport::CachingKeyGenerator.new(
    ActiveSupport::KeyGenerator.new(secret_key_base, iterations: 1000)
  )
end

def message_verifier(verifier_name)
  @message_verifiers[verifier_name] ||= begin
    secret = key_generator.generate_key(verifier_name.to_s)
    ActiveSupport::MessageVerifier.new(secret)
  end
end

def migration_railties # :nodoc:
  ordered_railties.flatten - [self]
end

def ordered_railties # :nodoc:
  @ordered_railties ||= begin
    order = config.railties_order.map do |railtie|
      if railtie == :main_app
        self
      elsif railtie.respond_to?(:instance)
        railtie.instance
      else
        railtie
      end
    end
    all = (railties - order)
    all.push(self)   unless (all + order).include?(self)
    order.push(:all) unless order.include?(:all)
    index = order.index(:all)
    order[index] = all
    order
  end
end

def railties_initializers(current) # :nodoc:
  initializers = []
  ordered_railties.reverse.flatten.each do |r|
    if r == self
      initializers += current
    else
      initializers += r.initializers
    end
  end
  initializers
end

def rake_tasks(&block)
  self.class.rake_tasks(&block)
end

def reload_routes!
  routes_reloader.reload!
end

def require_environment! # :nodoc:
  environment = paths["config/environment"].existent.first
  require environment if environment
end

def routes_reloader # :nodoc:
  @routes_reloader ||= RoutesReloader.new
end

def run_console_blocks(app) # :nodoc:
  railties.each { |r| r.run_console_blocks(app) }
  super
end

def run_generators_blocks(app) # :nodoc:
  railties.each { |r| r.run_generators_blocks(app) }
  super
end

def run_load_hooks! # :nodoc:
  return self if @ran_load_hooks
  @ran_load_hooks = true
  @initial_variable_values.each do |variable_name, value|
    if INITIAL_VARIABLES.include?(variable_name)
      instance_variable_set("@#{variable_name}", value)
    end
  end
  instance_eval(&@block) if @block
  self
end

def run_runner_blocks(app) # :nodoc:
  railties.each { |r| r.run_runner_blocks(app) }
  super
end

def run_server_blocks(app) # :nodoc:
  railties.each { |r| r.run_server_blocks(app) }
  super
end

def run_tasks_blocks(app) # :nodoc:
  railties.each { |r| r.run_tasks_blocks(app) }
  super
  load "rails/tasks.rb"
  task :environment do
    ActiveSupport.on_load(:before_initialize) { config.eager_load = config.rake_eager_load }
    require_environment!
  end
end

def runner(&blk)
  self.class.runner(&blk)
end

def secret_key_base
  if Rails.env.development? || Rails.env.test?
    secrets.secret_key_base ||= generate_development_secret
  else
    validate_secret_key_base(
      ENV["SECRET_KEY_BASE"] || credentials.secret_key_base || secrets.secret_key_base
    )
  end
end

def secrets
  @secrets ||= begin
    secrets = ActiveSupport::OrderedOptions.new
    files = config.paths["config/secrets"].existent
    files = files.reject { |path| path.end_with?(".enc") } unless config.read_encrypted_secrets
    secrets.merge! Rails::Secrets.parse(files, env: Rails.env)
    # Fallback to config.secret_key_base if secrets.secret_key_base isn't set
    secrets.secret_key_base ||= config.secret_key_base
    secrets
  end
end

def server(&blk)
  self.class.server(&blk)
end

def to_app # :nodoc:
  self
end

def validate_secret_key_base(secret_key_base)
  if secret_key_base.is_a?(String) && secret_key_base.present?
    secret_key_base
  elsif secret_key_base
    raise ArgumentError, "`secret_key_base` for #{Rails.env} environment must be a type of String`"
  else
    raise ArgumentError, "Missing `secret_key_base` for '#{Rails.env}' environment, set this string with `bin/rails credentials:edit`"
  end
end

def watchable_args # :nodoc:
  files, dirs = config.watchable_files.dup, config.watchable_dirs.dup
  ActiveSupport::Dependencies.autoload_paths.each do |path|
    File.file?(path) ? files << path.to_s : dirs[path.to_s] = [:rb]
  end
  [files, dirs]
end