class ActionController::Parameters

def ==(other)
  if other.respond_to?(:permitted?)
    self.permitted? == other.permitted? && self.parameters == other.parameters
  elsif other.is_a?(Hash)
    ActiveSupport::Deprecation.warn <<-WARNING.squish
      Comparing equality between `ActionController::Parameters` and a
      `Hash` is deprecated and will be removed in Rails 5.1. Please only do
      comparisons between instances of `ActionController::Parameters`. If
      you need to compare to a hash, first convert it using
      `ActionController::Parameters#new`.
    WARNING
    @parameters == other.with_indifferent_access
  else
    @parameters == other
  end
end

def [](key)
  convert_hashes_to_parameters(key, @parameters[key])
end

def []=(key, value)
  @parameters[key] = value
end

def array_of_permitted_scalars?(value)
  if value.is_a?(Array) && value.all? {|element| permitted_scalar?(element)}
    yield value
  end
end

def convert_hashes_to_parameters(key, value)
  converted = convert_value_to_parameters(value)
  @parameters[key] = converted unless converted.equal?(value)
  converted
end

def convert_parameters_to_hashes(value, using)
  case value
  when Array
    value.map { |v| convert_parameters_to_hashes(v, using) }
  when Hash
    value.transform_values do |v|
      convert_parameters_to_hashes(v, using)
    end.with_indifferent_access
  when Parameters
    value.send(using)
  else
    value
  end
end

def convert_value_to_parameters(value)
  case value
  when Array
    return value if converted_arrays.member?(value)
    converted = value.map { |_| convert_value_to_parameters(_) }
    converted_arrays << converted
    converted
  when Hash
    self.class.new(value)
  else
    value
  end
end

def converted_arrays
  @converted_arrays ||= Set.new
end

def delete(key)
  convert_value_to_parameters(@parameters.delete(key))
end

def dig(*keys)
  convert_value_to_parameters(@parameters.dig(*keys))
end

def dup
  super.tap do |duplicate|
    duplicate.permitted = @permitted
  end
end

def each_element(object)
  case object
  when Array
    object.grep(Parameters).map { |el| yield el }.compact
  when Parameters
    if object.fields_for_style?
      hash = object.class.new
      object.each { |k,v| hash[k] = yield v }
      hash
    else
      yield object
    end
  end
end

def each_pair(&block)
  @parameters.each_pair do |key, value|
    yield key, convert_hashes_to_parameters(key, value)
  end
end

def except(*keys)
  new_instance_with_inherited_permitted_status(@parameters.except(*keys))
end

def extract!(*keys)
  new_instance_with_inherited_permitted_status(@parameters.extract!(*keys))
end

def fetch(key, *args)
  convert_value_to_parameters(
    @parameters.fetch(key) {
      if block_given?
        yield
      else
        args.fetch(0) { raise ActionController::ParameterMissing.new(key) }
      end
    }
  )
end

def fields_for_style?
  @parameters.all? { |k, v| k =~ /\A-?\d+\z/ && (v.is_a?(Hash) || v.is_a?(Parameters)) }
end

def hash_filter(params, filter)
  filter = filter.with_indifferent_access
  # Slicing filters out non-declared keys.
  slice(*filter.keys).each do |key, value|
    next unless value
    next unless has_key? key
    if filter[key] == EMPTY_ARRAY
      # Declaration { comment_ids: [] }.
      array_of_permitted_scalars?(self[key]) do |val|
        params[key] = val
      end
    elsif non_scalar?(value)
      # Declaration { user: :name } or { user: [:name, :age, { address: ... }] }.
      params[key] = each_element(value) do |element|
        element.permit(*Array.wrap(filter[key]))
      end
    end
  end
end

def initialize(parameters = {})
  @parameters = parameters.with_indifferent_access
  @permitted = self.class.permit_all_parameters
end

def inspect
  "<#{self.class} #{@parameters} permitted: #{@permitted}>"
end

def merge(other_hash)
  new_instance_with_inherited_permitted_status(
    @parameters.merge(other_hash)
  )
end

def method_missing(method_sym, *args, &block)
  if @parameters.respond_to?(method_sym)
    message = <<-DEPRECATE.squish
      Method #{method_sym} is deprecated and will be removed in Rails 5.1,
      as `ActionController::Parameters` no longer inherits from
      hash. Using this deprecated behavior exposes potential security
      problems. If you continue to use this method you may be creating
      a security vulnerability in your app that can be exploited. Instead,
      consider using one of these documented methods which are not
      deprecated: http://api.rubyonrails.org/v#{ActionPack.version}/classes/ActionController/Parameters.html
    DEPRECATE
    ActiveSupport::Deprecation.warn(message)
    @parameters.public_send(method_sym, *args, &block)
  else
    super
  end
end

def new_instance_with_inherited_permitted_status(hash)
  self.class.new(hash).tap do |new_instance|
    new_instance.permitted = @permitted
  end
end

def non_scalar?(value)
  value.is_a?(Array) || value.is_a?(Parameters)
end

def permit(*filters)
  params = self.class.new
  filters.flatten.each do |filter|
    case filter
    when Symbol, String
      permitted_scalar_filter(params, filter)
    when Hash then
      hash_filter(params, filter)
    end
  end
  unpermitted_parameters!(params) if self.class.action_on_unpermitted_parameters
  params.permit!
end

def permit!
  each_pair do |key, value|
    Array.wrap(value).each do |v|
      v.permit! if v.respond_to? :permit!
    end
  end
  @permitted = true
  self
end

def permitted=(new_permitted)
  @permitted = new_permitted
end

def permitted?
  @permitted
end

def permitted_scalar?(value)
  PERMITTED_SCALAR_TYPES.any? {|type| value.is_a?(type)}
end

def permitted_scalar_filter(params, key)
  if has_key?(key) && permitted_scalar?(self[key])
    params[key] = self[key]
  end
  keys.grep(/\A#{Regexp.escape(key)}\(\d+[if]?\)\z/) do |k|
    if permitted_scalar?(self[k])
      params[k] = self[k]
    end
  end
end

def reject(&block)
  new_instance_with_inherited_permitted_status(@parameters.reject(&block))
end

def reject!(&block)
  @parameters.reject!(&block)
  self
end

def require(key)
  return key.map { |k| require(k) } if key.is_a?(Array)
  value = self[key]
  if value.present? || value == false
    value
  else
    raise ParameterMissing.new(key)
  end
end

def select(&block)
  new_instance_with_inherited_permitted_status(@parameters.select(&block))
end

def select!(&block)
  @parameters.select!(&block)
  self
end

def slice(*keys)
  new_instance_with_inherited_permitted_status(@parameters.slice(*keys))
end

def slice!(*keys)
  @parameters.slice!(*keys)
  self
end

def stringify_keys # :nodoc:
  dup
end

def to_h
  if permitted?
    convert_parameters_to_hashes(@parameters, :to_h)
  else
    slice(*self.class.always_permitted_parameters).permit!.to_h
  end
end

def to_unsafe_h
  convert_parameters_to_hashes(@parameters, :to_unsafe_h)
end

def transform_keys(&block)
  if block
    new_instance_with_inherited_permitted_status(
      @parameters.transform_keys(&block)
    )
  else
    @parameters.transform_keys
  end
end

def transform_keys!(&block)
  @parameters.transform_keys!(&block)
  self
end

def transform_values(&block)
  if block
    new_instance_with_inherited_permitted_status(
      @parameters.transform_values(&block)
    )
  else
    @parameters.transform_values
  end
end

def transform_values!(&block)
  @parameters.transform_values!(&block)
  self
end

def unpermitted_keys(params)
  self.keys - params.keys - self.always_permitted_parameters
end

def unpermitted_parameters!(params)
  unpermitted_keys = unpermitted_keys(params)
  if unpermitted_keys.any?
    case self.class.action_on_unpermitted_parameters
    when :log
      name = "unpermitted_parameters.action_controller"
      ActiveSupport::Notifications.instrument(name, keys: unpermitted_keys)
    when :raise
      raise ActionController::UnpermittedParameters.new(unpermitted_keys)
    end
  end
end

def values_at(*keys)
  convert_value_to_parameters(@parameters.values_at(*keys))
end