class EventMachine::Connection

def self.new(sig, *args)
  allocate.instance_eval do
    # Store signature
    @signature = sig
    # associate_callback_target sig
    # Call a superclass's #initialize if it has one
    initialize(*args)
    # post initialize callback
    post_init
    self
  end
end

def associate_callback_target sig
  # No-op for the time being
end

def close_connection after_writing = false
  EventMachine::close_connection @signature, after_writing
end

def close_connection_after_writing
  close_connection true
end

def comm_inactivity_timeout
  EventMachine::get_comm_inactivity_timeout @signature
end

def comm_inactivity_timeout= value
  EventMachine::set_comm_inactivity_timeout @signature, value.to_f
end

def connection_completed
end

def detach
  EventMachine::detach_fd @signature
end

def error?
  errno = EventMachine::report_connection_error_status(@signature)
  case errno
  when 0
    false
  when -1
    true
  else
    EventMachine::ERRNOS[errno]
  end
end

def get_cipher_bits
  EventMachine::get_cipher_bits @signature
end

def get_cipher_name
  EventMachine::get_cipher_name @signature
end

def get_cipher_protocol
  EventMachine::get_cipher_protocol @signature
end

def get_idle_time
  EventMachine::get_idle_time @signature
end

def get_outbound_data_size
  EventMachine::get_outbound_data_size @signature
end

def get_outbound_data_size
  EM._get_outbound_data_size @signature
end

def get_peer_cert
  EventMachine::get_peer_cert @signature
end

def get_peername
  EventMachine::get_peername @signature
end

def get_pid
  EventMachine::get_subprocess_pid @signature
end

def get_proxied_bytes
  EventMachine::get_proxied_bytes(@signature)
end

def get_sni_hostname
  EventMachine::get_sni_hostname @signature
end

def get_sock_opt level, option
  EventMachine::get_sock_opt @signature, level, option
end

def get_sockname
  EventMachine::get_sockname @signature
end

def get_status
  EventMachine::get_subprocess_status @signature
end

def initialize(*args)
end

def notify_readable= mode
  EventMachine::set_notify_readable @signature, mode
end

def notify_readable?
  EventMachine::is_notify_readable @signature
end

def notify_writable= mode
  EventMachine::set_notify_writable @signature, mode
end

def notify_writable?
  EventMachine::is_notify_writable @signature
end

def pause
  EventMachine::pause_connection @signature
end

def paused?
  EventMachine::connection_paused? @signature
end

def pending_connect_timeout
  EventMachine::get_pending_connect_timeout @signature
end

def pending_connect_timeout= value
  EventMachine::set_pending_connect_timeout @signature, value.to_f
end

def post_init
end

def proxy_completed
end

def proxy_incoming_to(conn,bufsize=0)
  EventMachine::enable_proxy(self, conn, bufsize)
end

def proxy_target_unbound
end

def receive_data data
  puts "............>>>#{data.length}"
end

def reconnect server, port
  EventMachine::reconnect server, port, self
end

def resume
  EventMachine::resume_connection @signature
end

def send_data data
  data = data.to_s
  size = data.bytesize if data.respond_to?(:bytesize)
  size ||= data.size
  EventMachine::send_data @signature, data, size
end

def send_datagram data, recipient_address, recipient_port
  data = data.to_s
  size = data.bytesize if data.respond_to?(:bytesize)
  size ||= data.size
  EventMachine::send_datagram @signature, data, size, recipient_address, Integer(recipient_port)
end

def send_file_data filename
  EventMachine::send_file_data @signature, filename
end

def set_sock_opt level, optname, optval
  EventMachine::set_sock_opt @signature, level, optname, optval
end

def ssl_handshake_completed
end

def ssl_verify_peer(cert)
end

def start_tls args={}
  priv_key     = args[:private_key_file]
  cert_chain   = args[:cert_chain_file]
  verify_peer  = args[:verify_peer]
  sni_hostname = args[:sni_hostname]
  cipher_list  = args[:cipher_list]
  ssl_version  = args[:ssl_version]
  ecdh_curve   = args[:ecdh_curve]
  dhparam      = args[:dhparam]
  fail_if_no_peer_cert = args[:fail_if_no_peer_cert]
  [priv_key, cert_chain].each do |file|
    next if file.nil? or file.empty?
    raise FileNotFoundException,
    "Could not find #{file} for start_tls" unless File.exist? file
  end
  protocols_bitmask = 0
  if ssl_version.nil?
    protocols_bitmask |= EventMachine::EM_PROTO_TLSv1
    protocols_bitmask |= EventMachine::EM_PROTO_TLSv1_1
    protocols_bitmask |= EventMachine::EM_PROTO_TLSv1_2
  else
    [ssl_version].flatten.each do |p|
      case p.to_s.downcase
      when 'sslv2'
        protocols_bitmask |= EventMachine::EM_PROTO_SSLv2
      when 'sslv3'
        protocols_bitmask |= EventMachine::EM_PROTO_SSLv3
      when 'tlsv1'
        protocols_bitmask |= EventMachine::EM_PROTO_TLSv1
      when 'tlsv1_1'
        protocols_bitmask |= EventMachine::EM_PROTO_TLSv1_1
      when 'tlsv1_2'
        protocols_bitmask |= EventMachine::EM_PROTO_TLSv1_2
      else
        raise("Unrecognized SSL/TLS Protocol: #{p}")
      end
    end
  end
  EventMachine::set_tls_parms(@signature, priv_key || '', cert_chain || '', verify_peer, fail_if_no_peer_cert, sni_hostname || '', cipher_list || '', ecdh_curve || '', dhparam || '', protocols_bitmask)
  EventMachine::start_tls @signature
end

def stop_proxying
  EventMachine::disable_proxy(self)
end

def stream_file_data filename, args={}
  EventMachine::FileStreamer.new( self, filename, args )
end

def unbind
end