module InheritedResources::UrlHelpers

def create_resources_url_helpers!
  resource_segments, resource_ivars = [], []
  resource_config = self.resources_configuration[:self]
  singleton   = resource_config[:singleton]
  uncountable = !singleton && resource_config[:route_collection_name] == resource_config[:route_instance_name]
  polymorphic = self.parents_symbols.include?(:polymorphic)
  # Add route_prefix if any.
  unless resource_config[:route_prefix].blank?
    if polymorphic
      resource_ivars << resource_config[:route_prefix]
    else
      resource_segments << resource_config[:route_prefix]
    end
  end
  # Deal with belongs_to associations and polymorphic associations.
  # Remember that we don't have to build the segments in polymorphic cases,
  # because the url will be polymorphic_url.
  #
  self.parents_symbols.each do |symbol|
    if symbol == :polymorphic
      resource_ivars << :parent
    else
      config = self.resources_configuration[symbol]
      if config[:singleton] && polymorphic
        resource_ivars << config[:instance_name]
      else
        resource_segments << config[:route_name]
      end
      if !config[:singleton]
        resource_ivars    << :"@#{config[:instance_name]}"
      end
    end
  end
  collection_ivars    = resource_ivars.dup
  collection_segments = resource_segments.dup
  # Generate parent url before we add resource instances.
  unless parents_symbols.empty?
    generate_url_and_path_helpers nil,   :parent, resource_segments, resource_ivars
    generate_url_and_path_helpers :edit, :parent, resource_segments, resource_ivars
  end
  # In singleton cases, we do not send the current element instance variable
  # because the id is not in the URL. For example, we should call:
  #
  #   project_manager_url(@project)
  #
  # Instead of:
  #
  #   project_manager_url(@project, @manager)
  #
  # Another exception in singleton cases is that collection url does not
  # exist. In such cases, we create the parent collection url. So in the
  # manager case above, the collection url will be:
  #
  #    project_url(@project)
  #
  # If the singleton does not have a parent, it will default to root_url.
  #
  collection_segments << resource_config[:route_collection_name] unless singleton
  resource_segments   << resource_config[:route_instance_name]
  resource_ivars      << :"@#{resource_config[:instance_name]}" unless singleton
  # Finally, polymorphic cases we have to give hints to the polymorphic url
  # builder. This works by attaching new ivars as symbols or records.
  #
  if polymorphic && singleton
    resource_ivars << resource_config[:instance_name]
    new_ivars       = resource_ivars
  end
  # If route is uncountable then add "_index" suffix to collection index route name
  if uncountable
    collection_segments << :"#{collection_segments.pop}_index"
  end
  generate_url_and_path_helpers nil,   :collection, collection_segments, collection_ivars
  generate_url_and_path_helpers :new,  :resource,   resource_segments,   new_ivars || collection_ivars
  generate_url_and_path_helpers nil,   :resource,   resource_segments,   resource_ivars
  generate_url_and_path_helpers :edit, :resource,   resource_segments,   resource_ivars
  if resource_config[:custom_actions]
    [*resource_config[:custom_actions][:resource]].each do | method |
      generate_url_and_path_helpers method, :resource, resource_segments, resource_ivars
    end
    [*resource_config[:custom_actions][:collection]].each do | method |
      generate_url_and_path_helpers method, :resources, collection_segments, collection_ivars
    end
  end
end

def define_helper_method(prefix, name, suffix, segments)
  method_name = [prefix, name, suffix].compact.join('_')
  params_method_name = ['', prefix, name, :params].compact.join('_')
  segments_method = [prefix, segments, suffix].compact.join('_')
  undef_method method_name if method_defined? method_name
  define_method method_name do |*given_args|
    given_args = send params_method_name, *given_args
    send segments_method, *given_args
  end
  protected method_name
end

def define_params_helper(prefix, name, singleton, polymorphic, parent_index, ivars)
  params_method_name = ['', prefix, name, :params].compact.join('_')
  undef_method params_method_name if method_defined? params_method_name
  define_method params_method_name do |*given_args|
    given_args = given_args.collect { |arg| arg.respond_to?(:permitted?) ? arg.to_h : arg }
    given_options = given_args.extract_options!
    args = ivars.map do |ivar|
      ivar.is_a?(Symbol) && ivar.to_s.start_with?('@') ? instance_variable_get(ivar) : ivar
    end
    args[parent_index] = parent if parent_index
    if !(singleton && name != :parent) && args.present? && name != :collection && prefix != :new
      resource = args.pop
      args.push(given_args.first || resource)
    end
    if polymorphic
      if name == :collection
        args[parent_index] = given_args.present? ? given_args.first : parent
      end
      if (name == :collection || name == :resource && prefix == :new) && !singleton
        args << (@_resource_class_new ||= resource_class.new)
      end
      args.compact! if self.resources_configuration[:polymorphic][:optional]
      args = [args]
    end
    args << given_options
  end
  protected params_method_name
end

def generate_url_and_path_helpers(prefix, name, resource_segments, resource_ivars) #:nodoc:
  resource_segments, resource_ivars = handle_shallow_resource(prefix, name, resource_segments, resource_ivars)
  ivars       = resource_ivars.dup
  singleton   = self.resources_configuration[:self][:singleton]
  polymorphic = self.parents_symbols.include?(:polymorphic)
  # In collection in polymorphic cases, allow an argument to be given as a
  # replacemente for the parent.
  #
  parent_index = ivars.index(:parent) if polymorphic
  segments = if polymorphic
    :polymorphic
  elsif resource_segments.empty?
    'root'
  else
    resource_segments.join('_')
  end
  define_params_helper(prefix, name, singleton, polymorphic, parent_index, ivars)
  define_helper_method(prefix, name, :path, segments)
  define_helper_method(prefix, name, :url, segments)
end

def handle_shallow_resource(prefix, name, segments, ivars) #:nodoc:
  return segments, ivars unless self.resources_configuration[:self][:shallow]
  case name
  when :collection, :resources
    segments = segments[-2..-1]
    ivars = [ivars.last]
  when :resource
    if prefix == :new
      segments = segments[-2..-1]
      ivars = [ivars.last]
    else
      segments = [segments.last]
      ivars = [ivars.last]
    end
  when :parent
    segments = [segments.last]
    ivars = [ivars.last]
  end
  segments ||= []
  unless self.resources_configuration[:self][:route_prefix].blank?
    segments.unshift self.resources_configuration[:self][:route_prefix]
  end
  return segments, ivars
end