module Capybara

def HTML(html) # rubocop:disable Naming/MethodName
  # Nokogiri >= 1.12.0 or Nokogumbo installed and allowed for use
  html_parser, using_html5 = if defined?(Nokogiri::HTML5) && Capybara.use_html5_parsing
    [Nokogiri::HTML5, true]
  else
    [defined?(Nokogiri::HTML4) ? Nokogiri::HTML4 : Nokogiri::HTML, false]
  end
  html_parser.parse(html).tap do |document|
    document.xpath('//template').each do |template|
      # template elements content is not part of the document
      template.inner_html = ''
    end
    document.xpath('//textarea').each do |textarea|
      # The Nokogiri HTML5 parser already returns spec compliant contents
      textarea['_capybara_raw_value'] = using_html5 ? textarea.content : textarea.content.delete_prefix("\n")
    end
  end
end

def add_selector(name, **options, &block)
  Capybara::Selector.add(name, **options, &block)
end

def config
  @config ||= Capybara::Config.new
end

def configure
  yield config
end

def current_driver
  if threadsafe
    Thread.current.thread_variable_get :capybara_current_driver
  else
    @current_driver
  end || default_driver
end

def current_driver=(name)
  if threadsafe
    Thread.current.thread_variable_set :capybara_current_driver, name
  else
    @current_driver = name
  end
end

def current_session
  specified_session || session_pool["#{current_driver}:#{session_name}:#{app.object_id}"]
end

def drivers
  @drivers ||= RegistrationContainer.new
end

def modify_selector(name, &block)
  Capybara::Selector.update(name, &block)
end

def register_driver(name, &block)
  drivers.send(:register, name, block)
end

def register_server(name, &block)
  servers.send(:register, name.to_sym, block)
end

def reset_sessions!
  # reset in reverse so sessions that started servers are reset last
  session_pool.reverse_each { |_mode, session| session.reset! }
end

def run_default_server(app, port)
  servers[:puma].call(app, port, server_host)
end

def servers
  @servers ||= RegistrationContainer.new
end

def session_name
  if threadsafe
    Thread.current.thread_variable_get(:capybara_session_name) ||
      Thread.current.thread_variable_set(:capybara_session_name, :default)
  else
    @session_name ||= :default
  end
end

def session_name=(name)
  if threadsafe
    Thread.current.thread_variable_set :capybara_session_name, name
  else
    @session_name = name
  end
end

def session_options
  config.session_options
end

def session_pool
  @session_pool ||= Hash.new do |hash, name|
    hash[name] = Capybara::Session.new(current_driver, app)
  end
end

def specified_session
  if threadsafe
    Thread.current.thread_variable_get :capybara_specified_session
  else
    @specified_session ||= nil
  end
end

def specified_session=(session)
  if threadsafe
    Thread.current.thread_variable_set :capybara_specified_session, session
  else
    @specified_session = session
  end
end

def string(html)
  Capybara::Node::Simple.new(html)
end

def use_default_driver
  self.current_driver = nil
end

def using_driver(driver)
  previous_driver = Capybara.current_driver
  Capybara.current_driver = driver
  yield
ensure
  self.current_driver = previous_driver
end

def using_session(name_or_session, &block)
  previous_session = current_session
  previous_session_info = {
    specified_session: specified_session,
    session_name: session_name,
    current_driver: current_driver,
    app: app
  }
  self.specified_session = self.session_name = nil
  if name_or_session.is_a? Capybara::Session
    self.specified_session = name_or_session
  else
    self.session_name = name_or_session
  end
  if block.arity.zero?
    yield
  else
    yield current_session, previous_session
  end
ensure
  self.session_name, self.specified_session = previous_session_info.values_at(:session_name, :specified_session)
  self.current_driver, self.app = previous_session_info.values_at(:current_driver, :app) if threadsafe
end

def using_wait_time(seconds)
  previous_wait_time = Capybara.default_max_wait_time
  Capybara.default_max_wait_time = seconds
  yield
ensure
  Capybara.default_max_wait_time = previous_wait_time
end