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
  session_pool["#{current_driver}:#{session_name}:#{app.object_id}"] ||= Capybara::Session.new(current_driver, app)
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 ||= {}
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)
  previous_session_info = {
    session_name: session_name,
    current_driver: current_driver,
    app: app
  }
  self.session_name = name
  yield
ensure
  self.session_name = previous_session_info[:session_name]
  if threadsafe
    self.current_driver = previous_session_info[:current_driver]
    self.app = previous_session_info[:app]
  end
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