class ActionController::Parameters

def [](key)
  convert_hashes_to_parameters(key, super)
end

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

def array_of_permitted_scalars_filter(params, key)
  if has_key?(key) && array_of_permitted_scalars?(self[key])
    params[key] = self[key]
  end
end

def convert_hashes_to_parameters(key, value, assign_if_converted=true)
  converted = convert_value_to_parameters(value)
  self[key] = converted if assign_if_converted && !converted.equal?(value)
  converted
end

def convert_value_to_parameters(value)
  if value.is_a?(Array) && !converted_arrays.member?(value)
    converted = value.map { |_| convert_value_to_parameters(_) }
    converted_arrays << converted
    converted
  elsif value.is_a?(Parameters) || !value.is_a?(Hash)
    value
  else
    self.class.new(value)
  end
end

def converted_arrays
  @converted_arrays ||= Set.new
end

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

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

def fetch(key, *args)
  convert_hashes_to_parameters(key, super, false)
rescue KeyError
  raise ActionController::ParameterMissing.new(key)
end

def fields_for_style?(object)
  object.is_a?(Hash) && object.all? { |k, v| k =~ /\A-?\d+\z/ && v.is_a?(Hash) }
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
    if filter[key] == EMPTY_ARRAY
      # Declaration { comment_ids: [] }.
      array_of_permitted_scalars_filter(params, key)
    else
      # Declaration { user: :name } or { user: [:name, :age, { address: ... }] }.
      params[key] = each_element(value) do |element|
        if element.is_a?(Hash)
          element = self.class.new(element) unless element.respond_to?(:permit)
          element.permit(*Array.wrap(filter[key]))
        end
      end
    end
  end
end

def initialize(attributes = nil)
  super(attributes)
  @permitted = self.class.permit_all_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|
    value = convert_hashes_to_parameters(key, value)
    Array.wrap(value).each do |_|
      _.permit! if _.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 require(key)
  value = self[key]
  if value.present? || value == false
    value
  else
    raise ParameterMissing.new(key)
  end
end

def slice(*keys)
  self.class.new(super).tap do |new_instance|
    new_instance.permitted = @permitted
  end
end

def unpermitted_keys(params)
  self.keys - params.keys - NEVER_UNPERMITTED_PARAMS
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