class Selenium::WebDriver::Remote::Capabilities

def ==(other)
  return false unless other.is_a? self.class
  as_json == other.as_json
end

def [](key)
  @capabilities[key]
end

def []=(key, value)
  @capabilities[key] = value
end

def always_match(capabilities)
  new(always_match: capabilities)
end

def as_json(*)
  @capabilities.each_with_object({}) do |(key, value), hash|
    hash[convert_key(key)] = process_capabilities(key, value, hash)
  end
end

def camel_case(str_or_sym)
  str_or_sym.to_s.gsub(/_([a-z])/) { Regexp.last_match(1)&.upcase }
end

def convert_key(key)
  case key
  when String
    key.to_s
  when Symbol
    self.class.camel_case(key)
  else
    raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class}"
  end
end

def convert_value(key, value)
  case key
  when :platform
    value.to_s.upcase
  when :proxy
    value&.as_json
  when :unhandled_prompt_behavior
    value.is_a?(Symbol) ? value.to_s.tr('_', ' ') : value
  else
    value
  end
end

def first_match(*capabilities)
  new(first_match: capabilities)
end

def implicit_timeout
  timeouts[:implicit]
end

def implicit_timeout=(timeout)
  timeouts[:implicit] = timeout
end

def initialize(opts = {})
  @capabilities = {}
  self.proxy = opts.delete(:proxy) if opts[:proxy]
  @capabilities.merge!(opts)
end

def json_create(data)
  data = data.dup
  caps = new
  process_timeouts(caps, data.delete('timeouts'))
  if data.key?('proxy')
    proxy = data.delete('proxy')
    caps.proxy = Proxy.json_create(proxy) unless proxy.nil? || proxy.empty?
  end
  # Remote Server Specific
  if data.key?('webdriver.remote.sessionid')
    caps[:remote_session_id] =
      data.delete('webdriver.remote.sessionid')
  end
  KNOWN.each do |cap|
    data_value = camel_case(cap)
    caps[cap] = data.delete(data_value) if data.key?(data_value)
  end
  # any remaining pairs will be added as is, with no conversion
  caps.merge!(data)
  caps
end

def merge!(other)
  if other.respond_to?(:capabilities, true) && other.capabilities.is_a?(Hash)
    @capabilities.merge! other.capabilities
  elsif other.is_a? Hash
    @capabilities.merge! other
  else
    raise ArgumentError, 'argument should be a Hash or implement #capabilities'
  end
end

def page_load_timeout
  timeouts[:page_load] || timeouts[:pageLoad]
end

def page_load_timeout=(timeout)
  timeouts[:page_load] = timeout
end

def process_capabilities(key, value, hash)
  case value
  when Array
    value.map { |v| process_capabilities(key, v, hash) }
  when Hash
    value.each_with_object({}) do |(k, v), h|
      h[convert_key(k)] = process_capabilities(k, v, h)
    end
  when Capabilities, Options
    value.as_json
  else
    convert_value(key, value)
  end
end

def process_timeouts(caps, timeouts)
  return if timeouts.nil?
  caps.implicit_timeout = timeouts['implicit']
  caps.page_load_timeout = timeouts['pageLoad']
  caps.script_timeout = timeouts['script']
end

def proxy
  @capabilities[:proxy]
end

def proxy=(proxy)
  case proxy
  when Hash
    @capabilities[:proxy] = Proxy.new(proxy)
  when Proxy, nil
    @capabilities[:proxy] = proxy
  else
    raise TypeError, "expected Hash or #{Proxy.name}, got #{proxy.inspect}:#{proxy.class}"
  end
end

def script_timeout
  timeouts[:script]
end

def script_timeout=(timeout)
  timeouts[:script] = timeout
end

def timeouts
  @capabilities[:timeouts] ||= {}
end

def timeouts=(timeouts)
  @capabilities[:timeouts] = timeouts
end

def to_json(*)
  JSON.generate as_json
end