module Capybara

def HTML(html) # rubocop:disable Naming/MethodName
  Nokogiri::HTML(html).tap do |document|
    document.xpath('//textarea').each do |textarea|
      textarea['_capybara_raw_value'] = textarea.content.sub(/\A\n/, '')
    end
  end
end

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

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

def configure
  yield config
end

def current_driver
  if threadsafe
    Thread.current['capybara_current_driver']
  else
    @current_driver
  end || default_driver
end

def current_driver=(name)
  if threadsafe
    Thread.current['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 ||= {}
end

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

def register_driver(name, &block)
  drivers[name] = block
end

def register_server(name, &block)
  servers[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 ||= {}
end

def session_name
  if threadsafe
    Thread.current['capybara_session_name'] ||= :default
  else
    @session_name ||= :default
  end
end

def session_name=(name)
  if threadsafe
    Thread.current['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['capybara_specified_session']
  else
    @specified_session
  end
end

def specified_session=(session)
  if threadsafe
    Thread.current['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)
  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
  yield
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