module InheritedResources::ClassMethods

def actions(*actions_to_keep)
  raise ArgumentError, 'Wrong number of arguments. You have to provide which actions you want to keep.' if actions_to_keep.empty?
  options = actions_to_keep.extract_options!
  actions_to_remove = Array(options[:except])
  actions_to_remove += ACTIONS - actions_to_keep.map { |a| a.to_sym } unless actions_to_keep.first == :all
  actions_to_remove.map! { |a| a.to_sym }.uniq!
  (instance_methods.map { |m| m.to_sym } & actions_to_remove).each do |action|
    undef_method action, "#{action}!"
  end
end

def acts_as_polymorphic! #:nodoc:
  unless self.parents_symbols.include?(:polymorphic)
    include PolymorphicHelpers
    helper_method :parent, :parent_type, :parent_class, :parent?
  end
end

def acts_as_singleton! #:nodoc:
  unless self.resources_configuration[:self][:singleton]
    self.resources_configuration[:self][:singleton] = true
    include SingletonHelpers
    actions :all, :except => :index
  end
end

def belongs_to(*symbols, &block)
  options = symbols.extract_options!
  options.symbolize_keys!
  options.assert_valid_keys(:class_name, :parent_class, :instance_name, :param,
                            :finder, :route_name, :collection_name, :singleton,
                            :polymorphic, :optional)
  optional    = options.delete(:optional)
  singleton   = options.delete(:singleton)
  polymorphic = options.delete(:polymorphic)
  finder      = options.delete(:finder)
  include BelongsToHelpers if self.parents_symbols.empty?
  acts_as_singleton!   if singleton
  acts_as_polymorphic! if polymorphic || optional
  raise ArgumentError, 'You have to give me at least one association name.' if symbols.empty?
  raise ArgumentError, 'You cannot define multiple associations with options: #{options.keys.inspect} to belongs to.' unless symbols.size == 1 || options.empty?
  symbols.each do |symbol|
    symbol = symbol.to_sym
    if polymorphic || optional
      self.parents_symbols << :polymorphic unless self.parents_symbols.include?(:polymorphic)
      self.resources_configuration[:polymorphic][:symbols]   << symbol
      self.resources_configuration[:polymorphic][:optional] ||= optional
    else
      self.parents_symbols << symbol
    end
    config = self.resources_configuration[symbol] = {}
    config[:parent_class] = options.delete(:parent_class) || begin
      class_name = (options.delete(:class_name) || symbol).to_s.pluralize.classify
      class_name.constantize
    rescue NameError => e
      raise unless e.message.include?(class_name)
      nil
    end
    config[:collection_name] = options.delete(:collection_name) || symbol.to_s.pluralize.to_sym
    config[:instance_name]   = options.delete(:instance_name) || symbol
    config[:param]           = options.delete(:param) || :"#{symbol}_id"
    config[:route_name]      = options.delete(:route_name) || symbol
    config[:finder]          = finder || :find
  end
  if block_given?
    class_eval(&block)
  else
    create_resources_url_helpers!
  end
end

def defaults(options)
  raise ArgumentError, 'Class method :defaults expects a hash of options.' unless options.is_a? Hash
  options.symbolize_keys!
  options.assert_valid_keys(:resource_class, :collection_name, :instance_name,
                            :class_name, :route_prefix, :route_collection_name,
                            :route_instance_name, :singleton)
  self.resource_class = options.delete(:resource_class)         if options.key?(:resource_class)
  self.resource_class = options.delete(:class_name).constantize if options.key?(:class_name)
  acts_as_singleton! if options.delete(:singleton)
  config = self.resources_configuration[:self]
  config[:route_prefix] = options.delete(:route_prefix) if options.key?(:route_prefix)
  options.each do |key, value|
    config[key] = value.to_sym
  end
  create_resources_url_helpers!
end

def inherited(base) #:nodoc:
  super(base)
  base.send :initialize_resources_class_accessors!
  base.send :create_resources_url_helpers!
end

def initialize_resources_class_accessors! #:nodoc:
  # Initialize resource class
  self.resource_class = begin
    class_name = self.controller_name.classify
    class_name.constantize
  rescue NameError => e
    raise unless e.message.include?(class_name)
    nil
  end
  # Initialize resources configuration hash
  self.resources_configuration ||= {}
  config = self.resources_configuration[:self] = {}
  config[:collection_name] = self.controller_name.to_sym
  config[:instance_name]   = self.controller_name.singularize.to_sym
  config[:route_collection_name] = config[:collection_name]
  config[:route_instance_name]   = config[:instance_name]
  # Deal with namespaced controllers
  namespaces = self.controller_path.split('/')[0..-2]
  config[:route_prefix] = namespaces.join('_') unless namespaces.empty?
  # Initialize polymorphic, singleton, scopes and belongs_to parameters
  self.parents_symbols ||= []
  self.resources_configuration[:polymorphic] ||= { :symbols => [], :optional => false }
end

def optional_belongs_to(*symbols, &block)
  options = symbols.extract_options!
  options.merge!(:optional => true)
  belongs_to(*symbols << options, &block)
end

def polymorphic_belongs_to(*symbols, &block)
  options = symbols.extract_options!
  options.merge!(:polymorphic => true)
  belongs_to(*symbols << options, &block)
end

def singleton_belongs_to(*symbols, &block)
  options = symbols.extract_options!
  options.merge!(:singleton => true)
  belongs_to(*symbols << options, &block)
end