class Slack::RealTime::Concurrency::Celluloid::Socket

def build_driver
  ::WebSocket::Driver.client(self)
end

def build_socket
  socket = ::Celluloid::IO::TCPSocket.new(addr, port)
  socket = ::Celluloid::IO::SSLSocket.new(socket, build_ssl_context) if secure?
  socket
end

def build_ssl_context
  OpenSSL::SSL::SSLContext.new(:TLSv1_2_client)
end

def close
  @closing = true
  driver.close
  super
end

def connect
  @driver = build_driver
end

def connect!
  super
  run_loop
end

def connected?
  !@connected.nil?
end

def handle_read(buffer)
  logger.debug("#{self.class}##{__method__}") { buffer }
  driver.parse buffer
end

def initialize(*args)
  super
end

def read
  buffer = socket.readpartial(BLOCK_SIZE)
  async.handle_read(buffer)
end

def run_client_loop
  @client.run_loop
end

def run_loop
  @closing = false
  @socket = build_socket
  @connected = @socket.connect
  driver.start
  loop { read } if socket
rescue EOFError, Errno::EPIPE => e
  logger.debug("#{self.class}##{__method__}") { e }
  driver.emit(:close, WebSocket::Driver::CloseEvent.new(1001, 'server closed connection')) unless @closing
ensure
  current_actor.terminate if current_actor.alive? rescue nil
end

def start_async(client)
  @client = client
  Actor.new(future.run_client_loop)
end

def write(data)
  logger.debug("#{self.class}##{__method__}") { data }
  socket.write(data)
end