module ActiveSupport::Callbacks::ClassMethods

def __update_callbacks(name) # :nodoc:
  ([self] + self.descendants).reverse_each do |target|
    chain = target.get_callbacks name
    yield target, chain.dup
  end
end

def define_callbacks(*names)
  options = names.extract_options!
  names.each do |name|
    name = name.to_sym
    ([self] + self.descendants).each do |target|
      target.set_callbacks name, CallbackChain.new(name, options)
    end
    module_eval <<-RUBY, __FILE__, __LINE__ + 1
      def _run_#{name}_callbacks(&block)
        run_callbacks #{name.inspect}, &block
      end
      def self._#{name}_callbacks
        get_callbacks(#{name.inspect})
      end
      def self._#{name}_callbacks=(value)
        set_callbacks(#{name.inspect}, value)
      end
      def _#{name}_callbacks
        __callbacks[#{name.inspect}]
      end
    RUBY
  end
end

def get_callbacks(name) # :nodoc:
  __callbacks[name.to_sym]
end

def normalize_callback_params(filters, block) # :nodoc:
  type = CALLBACK_FILTER_TYPES.include?(filters.first) ? filters.shift : :before
  options = filters.extract_options!
  filters.unshift(block) if block
  [type, filters, options.dup]
end

def reset_callbacks(name)
  callbacks = get_callbacks name
  self.descendants.each do |target|
    chain = target.get_callbacks(name).dup
    callbacks.each { |c| chain.delete(c) }
    target.set_callbacks name, chain
  end
  set_callbacks(name, callbacks.dup.clear)
end

def set_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)
  self_chain = get_callbacks name
  mapped = filters.map do |filter|
    Callback.build(self_chain, filter, type, options)
  end
  __update_callbacks(name) do |target, chain|
    options[:prepend] ? chain.prepend(*mapped) : chain.append(*mapped)
    target.set_callbacks name, chain
  end
end

def set_callbacks(name, callbacks) # :nodoc:
  unless singleton_class.method_defined?(:__callbacks, false)
    self.__callbacks = __callbacks.dup
  end
  self.__callbacks[name.to_sym] = callbacks
  self.__callbacks
end

def skip_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)
  options[:raise] = true unless options.key?(:raise)
  __update_callbacks(name) do |target, chain|
    filters.each do |filter|
      callback = chain.find { |c| c.matches?(type, filter) }
      if !callback && options[:raise]
        raise ArgumentError, "#{type.to_s.capitalize} #{name} callback #{filter.inspect} has not been defined"
      end
      if callback && (options.key?(:if) || options.key?(:unless))
        new_callback = callback.merge_conditional_options(chain, if_option: options[:if], unless_option: options[:unless])
        chain.insert(chain.index(callback), new_callback)
      end
      chain.delete(callback)
    end
    target.set_callbacks name, chain
  end
end