module ActionDispatch::Routing::Mapper::Resources

def action_options?(options)
  options[:only] || options[:except]
end

def action_path(name)
  @scope[:path_names][name.to_sym] || name
end

def add_route(action, controller, options, _path, to, via, formatted, anchor, options_constraints)
  path = path_for_action(action, _path)
  raise ArgumentError, "path is required" if path.blank?
  action = action.to_s
  default_action = options.delete(:action) || @scope[:action]
  if /^[\w\-\/]+$/.match?(action)
    default_action ||= action.tr("-", "_") unless action.include?("/")
  else
    action = nil
  end
  as = if !options.fetch(:as, true) # if it's set to nil or false
    options.delete(:as)
  else
    name_for_action(options.delete(:as), action)
  end
  path = Mapping.normalize_path URI::RFC2396_PARSER.escape(path), formatted
  ast = Journey::Parser.parse path
  mapping = Mapping.build(@scope, @set, ast, controller, default_action, to, via, formatted, options_constraints, anchor, options)
  @set.add_route(mapping, as)
end

def api_only? # :doc:
  @set.api_only?
end

def applicable_actions_for(method)
  case method
  when :resource
    SingletonResource.default_actions(api_only?)
  when :resources
    Resource.default_actions(api_only?)
  end
end

def apply_action_options(method, options)
  return options if action_options? options
  options.merge scope_action_options(method)
end

def apply_common_behavior_for(method, resources, options, &block)
  if resources.length > 1
    resources.each { |r| public_send(method, r, options, &block) }
    return true
  end
  if options[:shallow]
    options.delete(:shallow)
    shallow do
      public_send(method, resources.pop, options, &block)
    end
    return true
  end
  if resource_scope?
    nested { public_send(method, resources.pop, options, &block) }
    return true
  end
  options.keys.each do |k|
    (options[:constraints] ||= {})[k] = options.delete(k) if options[k].is_a?(Regexp)
  end
  scope_options = options.slice!(*RESOURCE_OPTIONS)
  unless scope_options.empty?
    scope(scope_options) do
      public_send(method, resources.pop, options, &block)
    end
    return true
  end
  false
end

def canonical_action?(action)
  resource_method_scope? && CANONICAL_ACTIONS.include?(action.to_s)
end

def collection(&block)
  unless resource_scope?
    raise ArgumentError, "can't use collection outside resource(s) scope"
  end
  with_scope_level(:collection) do
    path_scope(parent_resource.collection_scope, &block)
  end
end

def decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints)
  if on = options.delete(:on)
    send(on) { decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints) }
  else
    case @scope.scope_level
    when :resources
      nested { decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints) }
    when :resource
      member { decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints) }
    else
      add_route(path, controller, options, _path, to, via, formatted, anchor, options_constraints)
    end
  end
end

def draw(name)
  path = @draw_paths.find do |_path|
    File.exist? "#{_path}/#{name}.rb"
  end
  unless path
    msg  = "Your router tried to #draw the external file #{name}.rb,\n" \
           "but the file was not found in:\n\n"
    msg += @draw_paths.map { |_path| " * #{_path}" }.join("\n")
    raise ArgumentError, msg
  end
  route_path = "#{path}/#{name}.rb"
  instance_eval(File.read(route_path), route_path.to_s)
end

def get_to_from_path(path, to, action)
  return to if to || action
  path_without_format = path.sub(/\(\.:format\)$/, "")
  if using_match_shorthand?(path_without_format)
    path_without_format.delete_prefix("/").sub(%r{/([^/]*)$}, '#\1').tr("-", "_")
  else
    nil
  end
end

def map_match(paths, options)
  ActionDispatch.deprecator.warn(<<-MSG.squish) if paths.count > 1
    Mapping a route with multiple paths is deprecated and
    will be removed in Rails 8.1. Please use multiple method calls instead.
  MSG
  if (on = options[:on]) && !VALID_ON_OPTIONS.include?(on)
    raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
  end
  if @scope[:to]
    options[:to] ||= @scope[:to]
  end
  if @scope[:controller] && @scope[:action]
    options[:to] ||= "#{@scope[:controller]}##{@scope[:action]}"
  end
  controller = options.delete(:controller) || @scope[:controller]
  option_path = options.delete :path
  to = options.delete :to
  via = Mapping.check_via Array(options.delete(:via) {
    @scope[:via]
  })
  formatted = options.delete(:format) { @scope[:format] }
  anchor = options.delete(:anchor) { true }
  options_constraints = options.delete(:constraints) || {}
  path_types = paths.group_by(&:class)
  (path_types[String] || []).each do |_path|
    route_options = options.dup
    if _path && option_path
      raise ArgumentError, "Ambiguous route definition. Both :path and the route path were specified as strings."
    end
    to = get_to_from_path(_path, to, route_options[:action])
    decomposed_match(_path, controller, route_options, _path, to, via, formatted, anchor, options_constraints)
  end
  (path_types[Symbol] || []).each do |action|
    route_options = options.dup
    decomposed_match(action, controller, route_options, option_path, to, via, formatted, anchor, options_constraints)
  end
  self
end

def match(path, *rest, &block)
  if rest.empty? && Hash === path
    options  = path
    path, to = options.find { |name, _value| name.is_a?(String) }
    raise ArgumentError, "Route path not specified" if path.nil?
    case to
    when Symbol
      options[:action] = to
    when String
      if to.include?("#")
        options[:to] = to
      else
        options[:controller] = to
      end
    else
      options[:to] = to
    end
    options.delete(path)
    paths = [path]
  else
    options = rest.pop || {}
    paths = [path] + rest
  end
  if options.key?(:defaults)
    defaults(options.delete(:defaults)) { map_match(paths, options, &block) }
  else
    map_match(paths, options, &block)
  end
end

def match_root_route(options)
  args = ["/", { as: :root, via: :get }.merge(options)]
  match(*args)
end

def member(&block)
  unless resource_scope?
    raise ArgumentError, "can't use member outside resource(s) scope"
  end
  with_scope_level(:member) do
    if shallow?
      shallow_scope {
        path_scope(parent_resource.member_scope, &block)
      }
    else
      path_scope(parent_resource.member_scope, &block)
    end
  end
end

def name_for_action(as, action)
  prefix = prefix_name_for_action(as, action)
  name_prefix = @scope[:as]
  if parent_resource
    return nil unless as || action
    collection_name = parent_resource.collection_name
    member_name = parent_resource.member_name
  end
  action_name = @scope.action_name(name_prefix, prefix, collection_name, member_name)
  candidate = action_name.select(&:present?).join("_")
  unless candidate.empty?
    # If a name was not explicitly given, we check if it is valid and return nil in
    # case it isn't. Otherwise, we pass the invalid name forward so the underlying
    # router engine treats it and raises an exception.
    if as.nil?
      candidate unless !candidate.match?(/\A[_a-z]/i) || has_named_route?(candidate)
    else
      candidate
    end
  end
end

def namespace(path, options = {})
  if resource_scope?
    nested { super }
  else
    super
  end
end

def nested(&block)
  unless resource_scope?
    raise ArgumentError, "can't use nested outside resource(s) scope"
  end
  with_scope_level(:nested) do
    if shallow? && shallow_nesting_depth >= 1
      shallow_scope do
        path_scope(parent_resource.nested_scope) do
          scope(nested_options, &block)
        end
      end
    else
      path_scope(parent_resource.nested_scope) do
        scope(nested_options, &block)
      end
    end
  end
end

def nested_options
  options = { as: parent_resource.member_name }
  options[:constraints] = {
    parent_resource.nested_param => param_constraint
  } if param_constraint?
  options
end

def nested_scope?
  @scope.nested?
end

def new(&block)
  unless resource_scope?
    raise ArgumentError, "can't use new outside resource(s) scope"
  end
  with_scope_level(:new) do
    path_scope(parent_resource.new_scope(action_path(:new)), &block)
  end
end

def param_constraint
  @scope[:constraints][parent_resource.param]
end

def param_constraint?
  @scope[:constraints] && @scope[:constraints][parent_resource.param].is_a?(Regexp)
end

def parent_resource
  @scope[:scope_level_resource]
end

def path_for_action(action, path)
  return "#{@scope[:path]}/#{path}" if path
  if canonical_action?(action)
    @scope[:path].to_s
  else
    "#{@scope[:path]}/#{action_path(action)}"
  end
end

def path_scope(path)
  @scope = @scope.new(path: merge_path_scope(@scope[:path], path))
  yield
ensure
  @scope = @scope.parent
end

def prefix_name_for_action(as, action)
  if as
    prefix = as
  elsif !canonical_action?(action)
    prefix = action
  end
  if prefix && prefix != "/" && !prefix.empty?
    Mapper.normalize_name prefix.to_s.tr("-", "_")
  end
end

def resource(*resources, &block)
  options = resources.extract_options!.dup
  if apply_common_behavior_for(:resource, resources, options, &block)
    return self
  end
  with_scope_level(:resource) do
    options = apply_action_options :resource, options
    resource_scope(SingletonResource.new(resources.pop, api_only?, @scope[:shallow], options)) do
      yield if block_given?
      concerns(options[:concerns]) if options[:concerns]
      new do
        get :new
      end if parent_resource.actions.include?(:new)
      set_member_mappings_for_resource
      collection do
        post :create
      end if parent_resource.actions.include?(:create)
    end
  end
  self
end

def resource_method_scope?
  @scope.resource_method_scope?
end

def resource_scope(resource, &block)
  @scope = @scope.new(scope_level_resource: resource)
  controller(resource.resource_scope, &block)
ensure
  @scope = @scope.parent
end

def resource_scope?
  @scope.resource_scope?
end

def resources(*resources, &block)
  options = resources.extract_options!.dup
  if apply_common_behavior_for(:resources, resources, options, &block)
    return self
  end
  with_scope_level(:resources) do
    options = apply_action_options :resources, options
    resource_scope(Resource.new(resources.pop, api_only?, @scope[:shallow], options)) do
      yield if block_given?
      concerns(options[:concerns]) if options[:concerns]
      collection do
        get  :index if parent_resource.actions.include?(:index)
        post :create if parent_resource.actions.include?(:create)
      end
      new do
        get :new
      end if parent_resource.actions.include?(:new)
      set_member_mappings_for_resource
    end
  end
  self
end

def resources_path_names(options)
  @scope[:path_names].merge!(options)
end

def root(path, options = {})
  if path.is_a?(String)
    options[:to] = path
  elsif path.is_a?(Hash) && options.empty?
    options = path
  else
    raise ArgumentError, "must be called with a path and/or options"
  end
  if @scope.resources?
    with_scope_level(:root) do
      path_scope(parent_resource.path) do
        match_root_route(options)
      end
    end
  else
    match_root_route(options)
  end
end

def scope_action_options(method)
  return {} unless @scope[:action_options]
  actions = applicable_actions_for(method)
  @scope[:action_options].dup.tap do |options|
    (options[:only] = Array(options[:only]) & actions) if options[:only]
    (options[:except] = Array(options[:except]) & actions) if options[:except]
  end
end

def set_member_mappings_for_resource # :doc:
  member do
    get :edit if parent_resource.actions.include?(:edit)
    get :show if parent_resource.actions.include?(:show)
    if parent_resource.actions.include?(:update)
      patch :update
      put   :update
    end
    delete :destroy if parent_resource.actions.include?(:destroy)
  end
end

def shallow
  @scope = @scope.new(shallow: true)
  yield
ensure
  @scope = @scope.parent
end

def shallow?
  !parent_resource.singleton? && @scope[:shallow]
end

def shallow_nesting_depth
  @scope.find_all { |node|
    node.frame[:scope_level_resource]
  }.count { |node| node.frame[:scope_level_resource].shallow? }
end

def shallow_scope
  scope = { as: @scope[:shallow_prefix],
            path: @scope[:shallow_path] }
  @scope = @scope.new scope
  yield
ensure
  @scope = @scope.parent
end

def using_match_shorthand?(path)
  %r{^/?[-\w]+/[-\w/]+$}.match?(path)
end

def with_scope_level(kind) # :doc:
  @scope = @scope.new_level(kind)
  yield
ensure
  @scope = @scope.parent
end