class Faye::WebSocket

def self.determine_url(env)
  secure = if env.has_key?('HTTP_X_FORWARDED_PROTO')
             env['HTTP_X_FORWARDED_PROTO'] == 'https'
           else
             env['HTTP_ORIGIN'] =~ /^https:/i
           end
  scheme = secure ? 'wss:' : 'ws:'
  "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
end

def self.encode(string, validate_encoding = false)
  if Array === string
    string = utf8_string(string)
    return nil if validate_encoding and !valid_utf8?(string)
  end
  utf8_string(string)
end

def self.jruby?
  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
end

def self.load_adapter(backend)
  const = Kernel.const_get(ADAPTERS[backend]) rescue nil
  require(backend) unless const
  require File.expand_path("../adapters/#{backend}", __FILE__)
end

def self.parser(env)
  if env['HTTP_SEC_WEBSOCKET_VERSION']
    HybiParser
  elsif env['HTTP_SEC_WEBSOCKET_KEY1']
    Draft76Parser
  else
    Draft75Parser
  end
end

def self.rbx?
  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
end

def self.utf8_string(string)
  string = string.pack('C*') if Array === string
  string.respond_to?(:force_encoding) ?
      string.force_encoding('UTF-8') :
      string
end

def self.valid_utf8?(byte_array)
  string = utf8_string(byte_array)
  if defined?(UTF8_MATCH)
    UTF8_MATCH =~ string ? true : false
  else
    string.valid_encoding?
  end
end

def self.websocket?(env)
  env['REQUEST_METHOD'] == 'GET' and
  env['HTTP_CONNECTION'] and
  env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and
  env['HTTP_UPGRADE'].downcase == 'websocket'
end

def initialize(env, supported_protos = nil, options = {})
  @env     = env
  @stream  = Stream.new(self)
  @ping    = options[:ping]
  @ping_id = 0
  @url = WebSocket.determine_url(@env)
  @ready_state = CONNECTING
  @buffered_amount = 0
  @parser = WebSocket.parser(@env).new(self, :protocols => supported_protos)
  @send_buffer = []
  EventMachine.next_tick { open }
  @callback = @env['async.callback']
  @callback.call([101, {}, @stream])
  @stream.write(@parser.handshake_response)
  @ready_state = OPEN if @parser.open?
  if @ping
    @ping_timer = EventMachine.add_periodic_timer(@ping) do
      @ping_id += 1
      ping(@ping_id.to_s)
    end
  end
end

def parse(data)
  response = @parser.parse(data)
  return unless response
  @stream.write(response)
  open
end

def ping(message = '', &callback)
  return false unless @parser.respond_to?(:ping)
  @parser.ping(message, &callback)
end

def protocol
  @parser.protocol || ''
end

def rack_response
  [ -1, {}, [] ]
end