class Capybara::Selector::Definition

def css(*allowed_filters, &block)
  expression(:css, allowed_filters, &block)
end

def custom_filters
  warn "Deprecated: Selector#custom_filters is not valid when same named expression and node filter exist - don't use"
  node_filters.merge(expression_filters).freeze
end

def default_format
  return nil if @expressions.keys.empty?
  if @expressions.size == 1
    @expressions.keys.first
  else
    :xpath
  end
end

def default_visibility(fallback = Capybara.ignore_hidden_elements, options = {})
  vis = if @default_visibility.respond_to?(:call)
    @default_visibility.call(options)
  else
    @default_visibility
  end
  vis.nil? ? fallback : vis
end

def describe_all_expression_filters(**opts)
  expression_filters.map do |ef_name, ef|
    if ef.matcher?
      handled_custom_options(ef, opts).map { |option, value| " with #{ef_name}[#{option} => #{value}]" }.join
    elsif opts.key?(ef_name)
      " with #{ef_name} #{opts[ef_name]}"
    end
  end.join
end

def describe_expression_filters(&block)
  if block
    describe(:expression_filters, &block)
  else
    describe(:expression_filters) do |**options|
      describe_all_expression_filters(**options)
    end
  end
end

def describe_node_filters(&block)
  describe(:node_filters, &block)
end

def expression(type, allowed_filters, &block)
  if block
    @expressions[type] = block
    allowed_filters = parameter_names(block) if allowed_filters.empty?
    allowed_filters.flatten.each do |ef|
      expression_filters[ef] = Capybara::Selector::Filters::IdentityExpressionFilter.new(ef)
    end
  end
  @expressions[type]
end

def expression_filters
  @filter_set.expression_filters
end

def filter_set(name, filters_to_use = nil)
  @filter_set.import(name, filters_to_use)
end

def handled_custom_options(filter, options)
  options.select do |option, _|
    filter.handles_option?(option) && !::Capybara::Queries::SelectorQuery::VALID_KEYS.include?(option)
  end
end

def initialize(name, locator_type: nil, raw_locator: false, supports_exact: nil, &block)
  @name = name
  @filter_set = Capybara::Selector::FilterSet.add(name)
  @match = nil
  @label = nil
  @failure_message = nil
  @expressions = {}
  @expression_filters = {}
  @locator_filter = nil
  @default_visibility = nil
  @locator_type = locator_type
  @raw_locator = raw_locator
  @supports_exact = supports_exact
  instance_eval(&block)
end

def label(label = nil)
  @label = label if label
  @label
end

def locator_filter(*types, **options, &block)
  types.each { |type| options[type] = true }
  @locator_filter = Capybara::Selector::Filters::LocatorFilter.new(block, **options) if block
  @locator_filter
end

def locator_types
  return nil unless @locator_type
  Array(@locator_type)
end

def match(&block)
  @match = block if block
  @match
end

def match?(locator)
  @match&.call(locator)
end

def node_filters
  @filter_set.node_filters
end

def parameter_names(block)
  key_types = %i[key keyreq]
  # user filter_map when we drop dupport for 2.6
  # block.parameters.select { |(type, _name)| key_types.include? type }.map { |(_, name)| name }
  block.parameters.filter_map { |(type, name)| name if key_types.include? type }
end

def raw_locator?
  !!@raw_locator
end

def supports_exact?
  @supports_exact
end

def visible(default_visibility = nil, &block)
  @default_visibility = block || default_visibility
end

def xpath(*allowed_filters, &block)
  expression(:xpath, allowed_filters, &block)
end