class Net::POP3

def apop?
  @apop
end

def auth_only(account, password)
  raise IOError, 'opening previously opened POP session' if started?
  start(account, password) {
    ;
  }
end

def command # :nodoc:
  raise IOError, 'POP session not opened yet' \
                                  if not @socket or @socket.closed?
  @command
end

def delete_all # :yield: message
  mails().each do |m|
    yield m if block_given?
    m.delete unless m.deleted?
  end
end

def disable_ssl
  @ssl_params = nil
end

def do_finish # :nodoc:
  @mails = nil
  @n_mails = nil
  @n_bytes = nil
  @command.quit if @command
ensure
  @started = false
  @command = nil
  @socket.close if @socket
  @socket = nil
end

def do_start(account, password) # :nodoc:
  begin
    s = Socket.tcp @address, port, nil, nil, connect_timeout: @open_timeout
  rescue Errno::ETIMEDOUT #raise Net:OpenTimeout instead for compatibility with previous versions
    raise Net::OpenTimeout, "Timeout to open TCP connection to "\
        "#{@address}:#{port} (exceeds #{@open_timeout} seconds)"
  end
  if use_ssl?
    raise 'openssl library not installed' unless defined?(OpenSSL)
    context = OpenSSL::SSL::SSLContext.new
    context.set_params(@ssl_params)
    s = OpenSSL::SSL::SSLSocket.new(s, context)
    s.hostname = @address
    s.sync_close = true
    ssl_socket_connect(s, @open_timeout)
    if context.verify_mode != OpenSSL::SSL::VERIFY_NONE
      s.post_connection_check(@address)
    end
  end
  @socket = InternetMessageIO.new(s,
                                  read_timeout: @read_timeout,
                                  debug_output: @debug_output)
  logging "POP session started: #{@address}:#{@port} (#{@apop ? 'APOP' : 'POP'})"
  on_connect
  @command = POP3Command.new(@socket)
  if apop?
    @command.apop account, password
  else
    @command.auth account, password
  end
  @started = true
ensure
  # Authentication failed, clean up connection.
  unless @started
    s.close if s
    @socket = nil
    @command = nil
  end
end

def each_mail(&block)  # :yield: message
  mails().each(&block)
end

def enable_ssl(verify_or_params = {}, certs = nil, port = nil)
  begin
    @ssl_params = verify_or_params.to_hash.dup
    @port = @ssl_params.delete(:port) || @port
  rescue NoMethodError
    @ssl_params = POP3.create_ssl_params(verify_or_params, certs)
    @port = port || @port
  end
end

def finish
  raise IOError, 'POP session not yet started' unless started?
  do_finish
end

def initialize(addr, port = nil, isapop = false)
  @address = addr
  @ssl_params = POP3.ssl_params
  @port = port
  @apop = isapop
  @command = nil
  @socket = nil
  @started = false
  @open_timeout = 30
  @read_timeout = 60
  @debug_output = nil
  @mails = nil
  @n_mails = nil
  @n_bytes = nil
end

def inspect
  +"#<#{self.class} #{@address}:#{@port} open=#{@started}>"
end

def logging(msg)
  @debug_output << msg + "\n" if @debug_output
end

def mails
  return @mails.dup if @mails
  if n_mails() == 0
    # some popd raises error for LIST on the empty mailbox.
    @mails = []
    return []
  end
  @mails = command().list.map {|num, size|
    POPMail.new(num, size, self, command())
  }
  @mails.dup
end

def n_bytes
  return @n_bytes if @n_bytes
  @n_mails, @n_bytes = command().stat
  @n_bytes
end

def n_mails
  return @n_mails if @n_mails
  @n_mails, @n_bytes = command().stat
  @n_mails
end

def on_connect # :nodoc:
end

def port
  return @port || (use_ssl? ? POP3.default_pop3s_port : POP3.default_pop3_port)
end

def read_timeout=(sec)
  @command.socket.read_timeout = sec if @command
  @read_timeout = sec
end

def reset
  command().rset
  mails().each do |m|
    m.instance_eval {
      @deleted = false
    }
  end
end

def set_all_uids   #:nodoc: internal use only (called from POPMail#uidl)
  uidl = command().uidl
  @mails.each {|m| m.uid = uidl[m.number] }
end

def set_debug_output(arg)
  @debug_output = arg
end

def start(account, password) # :yield: pop
  raise IOError, 'POP session already started' if @started
  if block_given?
    begin
      do_start account, password
      return yield(self)
    ensure
      do_finish
    end
  else
    do_start account, password
    return self
  end
end

def started?
  @started
end

def use_ssl?
  return !@ssl_params.nil?
end