class Puma::MiniSSL::Socket

def bad_tlsv1_3?
  HAS_TLS1_3 && ssl_version_state == ['TLSv1.3', 'SSLERR']
end

def close
  begin
    unless @engine.shutdown
      while alert_data = @engine.extract
        @socket.write alert_data
      end
    end
  rescue IOError, SystemCallError
    Puma::Util.purge_interrupt_queue
    # nothing
  ensure
    @socket.close
  end
end

def closed?
  @socket.closed?
end

def engine_read_all
  output = @engine.read
  while output and additional_output = @engine.read
    output << additional_output
  end
  output
end

def flush
  @socket.flush
end

def initialize(socket, engine)
  @socket = socket
  @engine = engine
  @peercert = nil
  @reuse = nil
end

def peeraddr
  @socket.peeraddr
end

def peercert
  return @peercert if @peercert
  raw = @engine.peercert
  return nil unless raw
  @peercert = OpenSSL::X509::Certificate.new raw
end

def read_nonblock(size, *_)
  # *_ is to deal with keyword args that were added
  # at some point (and being used in the wild)
  while true
    output = engine_read_all
    return output if output
    data = @socket.read_nonblock(size, exception: false)
    if data == :wait_readable || data == :wait_writable
      # It would make more sense to let @socket.read_nonblock raise
      # EAGAIN if necessary but it seems like it'll misbehave on Windows.
      # I don't have a Windows machine to debug this so I can't explain
      # exactly whats happening in that OS. Please let me know if you
      # find out!
      #
      # In the meantime, we can emulate the correct behavior by
      # capturing :wait_readable & :wait_writable and raising EAGAIN
      # ourselves.
      raise IO::EAGAINWaitReadable
    elsif data.nil?
      raise SSLError.exception "HTTP connection?" if bad_tlsv1_3?
      return nil
    end
    @engine.inject(data)
    output = engine_read_all
    return output if output
    while neg_data = @engine.extract
      @socket.write neg_data
    end
  end
end

def readpartial(size)
  while true
    output = @engine.read
    return output if output
    data = @socket.readpartial(size)
    @engine.inject(data)
    output = @engine.read
    return output if output
    while neg_data = @engine.extract
      @socket.write neg_data
    end
  end
end

def ssl_version_state
  IS_JRUBY ? [nil, nil] : @engine.ssl_vers_st
end

def to_io
  @socket
end

def write(data)
  return 0 if data.empty?
  data_size = data.bytesize
  need = data_size
  while true
    wrote = @engine.write data
    enc_wr = +''
    while (enc = @engine.extract)
      enc_wr << enc
    end
    @socket.write enc_wr unless enc_wr.empty?
    need -= wrote
    return data_size if need == 0
    data = data.byteslice(wrote..-1)
  end
end

def write_nonblock(data, *_)
  write data
end