class Capybara::Node::Element

def [](attribute)
  synchronize { base[attribute] }
end

def allow_reload!
  @allow_reload = true
end

def checked?
  synchronize { base.checked? }
end

def click(*keys, **offset)
  synchronize { base.click(keys, offset) }
  self
end

def disabled?
  synchronize { base.disabled? }
end

def double_click(*keys, **offset)
  synchronize { base.double_click(keys, offset) }
  self
end

def drag_to(node)
  synchronize { base.drag_to(node.base) }
  self
end

def evaluate_async_script(script, *args)
  session.evaluate_async_script(<<~JS, self, *args)
    (function (){
      #{script}
    }).apply(arguments[0], Array.prototype.slice.call(arguments,1));
  JS
end

def evaluate_script(script, *args)
  session.evaluate_script(<<~JS, self, *args)
    (function(){
      return #{script.strip}
    }).apply(arguments[0], Array.prototype.slice.call(arguments,1));
  JS
end

def execute_script(script, *args)
  session.execute_script(<<~JS, self, *args)
    (function (){
      #{script}
    }).apply(arguments[0], Array.prototype.slice.call(arguments,1));
  JS
end

def hover
  synchronize { base.hover }
  self
end

def initialize(session, base, query_scope, query)
  super(session, base)
  @query_scope = query_scope
  @query = query
  @allow_reload = false
end

def inspect
  %(#<Capybara::Node::Element tag="#{base.tag_name}" path="#{base.path}">)
rescue NotSupportedByDriverError
  %(#<Capybara::Node::Element tag="#{base.tag_name}">)
rescue StandardError => err
  raise unless session.driver.invalid_element_errors.any? { |et| err.is_a?(et) }
  %(Obsolete #<Capybara::Node::Element>)
end

def multiple?
  synchronize { base.multiple? }
end

def native
  synchronize { base.native }
end

def path
  synchronize { base.path }
end

def readonly?
  synchronize { base.readonly? }
end

def reload
  if @allow_reload
    begin
      reloaded = query_scope.reload.first(@query.name, @query.locator, @query.options)
      @base = reloaded.base if reloaded
    rescue StandardError => err
      raise err unless catch_error?(err)
    end
  end
  self
end

def right_click(*keys, **offset)
  synchronize { base.right_click(keys, offset) }
  self
end

def select_option
  warn "Attempt to select disabled option: #{value || text}" if disabled?
  synchronize { base.select_option }
  self
end

def selected?
  synchronize { base.selected? }
end

def send_keys(*args)
  synchronize { base.send_keys(*args) }
  self
end

def set(value, **options)
  raise Capybara::ReadOnlyElementError, "Attempt to set readonly element with value: #{value}" if readonly?
  options = session_options.default_set_options.to_h.merge(options)
  synchronize { base.set(value, options) }
  self
end

def style(*styles)
  styles = styles.flatten.map(&:to_s)
  raise ArgumentError, 'You must specify at least one CSS style' if styles.empty?
  begin
    synchronize { base.style(styles) }
  rescue NotImplementedError => err
    begin
      evaluate_script(STYLE_SCRIPT, *styles)
    rescue Capybara::NotSupportedByDriverError
      raise err
    end
  end
end

def tag_name
  synchronize { base.tag_name }
end

def text(type = nil, normalize_ws: false)
  type ||= :all unless session_options.ignore_hidden_elements || session_options.visible_text_only
  txt = synchronize { type == :all ? base.all_text : base.visible_text }
  normalize_ws ? txt.gsub(/[[:space:]]+/, ' ').strip : txt
end

def trigger(event)
  synchronize { base.trigger(event) }
  self
end

def unselect_option
  synchronize { base.unselect_option }
  self
end

def value
  synchronize { base.value }
end

def visible?
  synchronize { base.visible? }
end