class Playwright::ChannelOwners::ElementHandle

def as_element
  self
end

def bounding_box
  @channel.send_message_to_server('boundingBox')
end

def check(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil)
  params = {
    force: force,
    noWaitAfter:  noWaitAfter,
    position: position,
    timeout: timeout,
    trial: trial,
  }.compact
  @channel.send_message_to_server('check', params)
  nil
end

def checked?
  @channel.send_message_to_server('isChecked')
end

def click(
      button: nil,
      clickCount: nil,
      delay: nil,
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  params = {
    button: button,
    clickCount: clickCount,
    delay: delay,
    force: force,
    modifiers: modifiers,
    noWaitAfter: noWaitAfter,
    position: position,
    timeout: timeout,
    trial: trial,
  }.compact
  @channel.send_message_to_server('click', params)
  nil
end

def content_frame
  resp = @channel.send_message_to_server('contentFrame')
  ChannelOwners::Frame.from_nullable(resp)
end

def dblclick(
      button: nil,
      delay: nil,
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  params = {
    button: button,
    delay: delay,
    force: force,
    modifiers: modifiers,
    noWaitAfter: noWaitAfter,
    position: position,
    timeout: timeout,
    trial: trial,
  }.compact
  @channel.send_message_to_server('dblclick', params)
  nil
end

def disabled?
  @channel.send_message_to_server('isDisabled')
end

def dispatch_event(type, eventInit: nil)
  params = {
    type: type,
    eventInit: JavaScript::ValueSerializer.new(eventInit).serialize,
  }.compact
  @channel.send_message_to_server('dispatchEvent', params)
  nil
end

def editable?
  @channel.send_message_to_server('isEditable')
end

def enabled?
  @channel.send_message_to_server('isEnabled')
end

def eval_on_selector(selector, pageFunction, arg: nil)
  JavaScript::Expression.new(pageFunction, arg).eval_on_selector(@channel, selector)
end

def eval_on_selector_all(selector, pageFunction, arg: nil)
  JavaScript::Expression.new(pageFunction, arg).eval_on_selector_all(@channel, selector)
end

def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
  params = {
    value: value,
    force: force,
    noWaitAfter: noWaitAfter,
    timeout: timeout,
  }.compact
  @channel.send_message_to_server('fill', params)
  nil
end

def focus
  @channel.send_message_to_server('focus')
  nil
end

def get_attribute(name)
  @channel.send_message_to_server('getAttribute', name: name)
end

def hidden?
  @channel.send_message_to_server('isHidden')
end

def hover(
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  params = {
    force: force,
    modifiers: modifiers,
    noWaitAfter: noWaitAfter,
    position: position,
    timeout: timeout,
    trial: trial,
  }.compact
  @channel.send_message_to_server('hover', params)
  nil
end

def inner_html
  @channel.send_message_to_server('innerHTML')
end

def inner_text
  @channel.send_message_to_server('innerText')
end

def input_value(timeout: nil)
  params = { timeout: timeout }.compact
  @channel.send_message_to_server('inputValue', params)
end

def owner_frame
  resp = @channel.send_message_to_server('ownerFrame')
  ChannelOwners::Frame.from_nullable(resp)
end

def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
  params = {
    key: key,
    delay: delay,
    noWaitAfter: noWaitAfter,
    timeout: timeout,
  }.compact
  @channel.send_message_to_server('press', params)
  nil
end

def query_selector(selector)
  resp = @channel.send_message_to_server('querySelector', selector: selector)
  ChannelOwners::ElementHandle.from_nullable(resp)
end

def query_selector_all(selector)
  @channel.send_message_to_server('querySelectorAll', selector: selector).map do |el|
    ChannelOwners::ElementHandle.from(el)
  end
end

def screenshot(
  animations: nil,
  caret: nil,
  mask: nil,
  maskColor: nil,
  omitBackground: nil,
  path: nil,
  quality: nil,
  scale: nil,
  style: nil,
  timeout: nil,
  type: nil)
  params = {
    animations: animations,
    caret: caret,
    maskColor: maskColor,
    omitBackground: omitBackground,
    path: path,
    quality: quality,
    scale: scale,
    style: style,
    timeout: timeout,
    type: type,
  }.compact
  if mask.is_a?(Enumerable)
    params[:mask] = mask.map do |locator|
      locator.send(:to_protocol)
    end
  end
  encoded_binary = @channel.send_message_to_server('screenshot', params)
  decoded_binary = Base64.strict_decode64(encoded_binary)
  if path
    File.open(path, 'wb') do |f|
      f.write(decoded_binary)
    end
  end
  decoded_binary
end

def scroll_into_view_if_needed(timeout: nil)
  params = {
    timeout: timeout,
  }.compact
  @channel.send_message_to_server('scrollIntoViewIfNeeded', params)
  nil
end

def select_option(
      element: nil,
      index: nil,
      value: nil,
      label: nil,
      force: nil,
      noWaitAfter: nil,
      timeout: nil)
  base_params = SelectOptionValues.new(
    element: element,
    index: index,
    value: value,
    label: label,
  ).as_params
  params = base_params.merge({ force: force, noWaitAfter: noWaitAfter, timeout: timeout }.compact)
  @channel.send_message_to_server('selectOption', params)
end

def select_text(force: nil, timeout: nil)
  params = { force: force, timeout: timeout }.compact
  @channel.send_message_to_server('selectText', params)
  nil
end

def set_checked(checked, **options)
  if checked
    check(**options)
  else
    uncheck(**options)
  end
end

def set_input_files(files, noWaitAfter: nil, timeout: nil)
  frame = owner_frame
  unless frame
    raise 'Cannot set input files to detached element'
  end
  method_name, params = InputFiles.new(frame.page.context, files).as_method_and_params
  params.merge!({ noWaitAfter: noWaitAfter, timeout: timeout }.compact)
  @channel.send_message_to_server(method_name, params)
  nil
end

def tap_point(
      force: nil,
      modifiers: nil,
      noWaitAfter: nil,
      position: nil,
      timeout: nil,
      trial: nil)
  params = {
    force: force,
    modifiers: modifiers,
    noWaitAfter: noWaitAfter,
    position: position,
    timeout: timeout,
    trial: trial,
  }.compact
  @channel.send_message_to_server('tap', params)
  nil
end

def text_content
  @channel.send_message_to_server('textContent')
end

def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
  params = {
    text: text,
    delay: delay,
    noWaitAfter: noWaitAfter,
    timeout: timeout,
  }.compact
  @channel.send_message_to_server('type', params)
  nil
end

def uncheck(force: nil, noWaitAfter: nil, position: nil, timeout: nil, trial: nil)
  params = {
    force: force,
    noWaitAfter:  noWaitAfter,
    position: position,
    timeout: timeout,
    trial: trial,
  }.compact
  @channel.send_message_to_server('uncheck', params)
  nil
end

def visible?
  @channel.send_message_to_server('isVisible')
end

def wait_for_element_state(state, timeout: nil)
  params = { state: state, timeout: timeout }.compact
  @channel.send_message_to_server('waitForElementState', params)
  nil
end

def wait_for_selector(selector, state: nil, strict: nil, timeout: nil)
  params = { selector: selector, state: state, strict: strict, timeout: timeout }.compact
  resp = @channel.send_message_to_server('waitForSelector', params)
  ChannelOwners::ElementHandle.from_nullable(resp)
end