class Selenium::WebDriver::Remote::Bridge

def self.handshake(**opts)
  desired_capabilities = opts.delete(:desired_capabilities)
  if desired_capabilities.is_a?(Symbol)
    unless Remote::Capabilities.respond_to?(desired_capabilities)
      raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
    end
    desired_capabilities = Remote::Capabilities.__send__(desired_capabilities)
  end
  bridge = new(opts)
  capabilities = bridge.create_session(desired_capabilities)
  case bridge.dialect
  when :oss
    Remote::OSS::Bridge.new(capabilities, bridge.session_id, opts)
  when :w3c
    Remote::W3C::Bridge.new(capabilities, bridge.session_id, opts)
  else
    raise WebDriverError, 'cannot understand dialect'
  end
end

def browser
  @browser ||= begin
    name = @capabilities.browser_name
    name ? name.tr(' ', '_').to_sym : 'unknown'
  end
end

def commands(command)
  raise NotImplementedError unless command == :new_session
  COMMANDS[command]
end

def create_session(desired_capabilities)
  response = execute(:new_session, {}, merged_capabilities(desired_capabilities))
  @session_id = response['sessionId']
  oss_status = response['status']
  value = response['value']
  if value.is_a?(Hash)
    @session_id = value['sessionId'] if value.key?('sessionId')
    if value.key?('capabilities')
      value = value['capabilities']
    elsif value.key?('value')
      value = value['value']
    end
  end
  unless @session_id
    raise Error::WebDriverError, 'no sessionId in returned payload'
  end
  if oss_status
    WebDriver.logger.info 'Detected OSS dialect.'
    @dialect = :oss
    Capabilities.json_create(value)
  else
    WebDriver.logger.info 'Detected W3C dialect.'
    @dialect = :w3c
    W3C::Capabilities.json_create(value)
  end
end

def escaper
  @escaper ||= defined?(URI::Parser) ? URI::Parser.new : URI
end

def execute(command, opts = {}, command_hash = nil)
  verb, path = commands(command) || raise(ArgumentError, "unknown command: #{command.inspect}")
  path = path.dup
  path[':session_id'] = session_id if path.include?(':session_id')
  begin
    opts.each { |key, value| path[key.inspect] = escaper.escape(value.to_s) }
  rescue IndexError
    raise ArgumentError, "#{opts.inspect} invalid for #{command.inspect}"
  end
  WebDriver.logger.info("-> #{verb.to_s.upcase} #{path}")
  http.call(verb, path, command_hash)
end

def initialize(opts = {})
  opts = opts.dup
  WebDriver.logger.deprecate ':port', 'full URL' if opts.key?(:port)
  port = opts.delete(:port) || 4444
  http_client = opts.delete(:http_client) { Http::Default.new }
  url = opts.delete(:url) { "http://#{Platform.localhost}:#{port}/wd/hub" }
  unless opts.empty?
    raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
  end
  uri = url.is_a?(URI) ? url : URI.parse(url)
  uri.path += '/' unless uri.path =~ %r{\/$}
  http_client.server_url = uri
  @http = http_client
  @file_detector = nil
end

def merged_capabilities(oss_capabilities)
  w3c_capabilities = W3C::Capabilities.from_oss(oss_capabilities)
  {
    desiredCapabilities: oss_capabilities,
    capabilities: {
      firstMatch: [w3c_capabilities]
    }
  }
end

def session_id
  @session_id || raise(Error::WebDriverError, 'no current session exists')
end