class GxG::Networking::Pop3Client

# File lib/gxg/net_clients.rb, line 1626
def initialize(host=nil,port=nil,options={})
  if port.is_a?(::Hash)
    options = port
    port = nil
  end
  @user = nil
  @password = nil
  @client = nil
  @host = host
  unless @host
    raise ArgumentError, "You MUST provide a HOST, like this: <host>,(<port>),(<options>)"
  end
  if options[:use_ssl] == true
    @port = (port || 995)
  else
    @port = (port || 110)
  end
  @client = ::Net::POP3.new(@host, @port, (options[:use_apop] || false))
  if options[:use_ssl] == true
    if options[:ignore_ssl_errors] == true
      @client.enable_ssl(OpenSSL::SSL::VERIFY_NONE)
    else
      @client.enable_ssl(OpenSSL::SSL::VERIFY_PEER)
    end
  end
  #
  self
end

# File lib/gxg/net_clients.rb, line 1655
def login(user_id=nil,password=nil,options={})
  if @client
    @user = user_id
    @password = password
    unless @password
      raise ArgumentError, "You MUST provide a PASSWORD, like this: <user_id>,<password>,(<options>)"
    end
    @client.start(@user, @password)
    true
  else
    false
  end
  #
end

# File lib/gxg/net_clients.rb, line 1670
def logout()
  if @client
    @client.finish
    @client = nil
    true
  end
end

# File lib/gxg/net_clients.rb, line 1678
def message_count()
  # Return the number of emails on the server.
  if @client
    @client.n_mails()
  else
    0
  end
end

# File lib/gxg/net_clients.rb, line 1687
def retrieve_messages(options={:read_only=>false},&block)
  result = []
  begin
    if @client
      if @client.started?
        if @client.active?
          parse_message = Proc.new do |the_raw_message|
            header = {}
            body = []
            attachments = []
            parser = ::Mail.new(the_raw_message.pop)
            parser.header_fields.each do |field|
              the_key = field.name.to_s.to_sym
              the_data = field.to_s.transcode({:replace => "."},::Encoding::UTF_8)
              the_data.gsub!("         ","")
              the_data.gsub!("        ","")
              the_data.gsub!("   ","")
              the_data.gsub!("\r\n","")
              if header[(the_key)]
                unless header[(the_key)].is_a?(::Array)
                  header[(the_key)] = [(header[(the_key)])]
                end
                header[(the_key)] << the_data
              else
                header[(the_key)] = the_data
              end
            end
            if parser.multipart?
              link_db = []
              body << {:preamble => parser.body.preamble}
              parser.parts.each do |part|
                if part.multipart?
                  link_db << part
                else
                  if part.attachment?
                    attachments << {:content_type => {:type => part.mime_type, :parameters => part.content_type_parameters}, :filename => part.filename, :path => nil, :content => ::GxG::ByteArray.new(part.decoded)}
                  else
                    body << {:content_type => {:type => part.mime_type, :parameters => part.content_type_parameters}, :content => part.body.to_s.transcode({:replace => "."},::Encoding::UTF_8)}
                  end
                end
              end
              while link_db.size > 0 do
                part = link_db.shift
                if part.multipart?
                  part.parts.each do |the_sub_part|
                    link_db << the_sub_part
                  end
                else
                  if part.attachment?
                    attachments << {:content_type => {:type => part.mime_type, :parameters => part.content_type_parameters}, :filename => part.filename, :path => nil, :content => ::GxG::ByteArray.new(part.decoded)}
                  else
                    body << {:content_type => {:type => part.mime_type, :parameters => part.content_type_parameters}, :content => part.body.to_s.transcode({:replace => "."},::Encoding::UTF_8)}
                  end
                end
              end
              body << {:epilogue => parser.body.epilogue}
            else
              body << {:preamble => parser.body.preamble.to_s.transcode({:replace => "."},::Encoding::UTF_8)}
              mime_type = "text/plain"
              parameters = {"charset" => "UTF-8"}
              body_text = parser.body.to_s.transcode({:replace => "."},::Encoding::UTF_8)
              if body_text.xml?
                mime_type = "text/xml"
              end
              if body_text.html?
                mime_type = "text/html"
              end
              body << {:content_type => {:type => mime_type, :parameters => parameters}, :content => body_text}
              body << {:epilogue => parser.body.epilogueto_s.transcode({:replace => "."},::Encoding::UTF_8)}
            end
            gxg_message = new_message
            gxg_message[:sender] = parser.from
            gxg_message[:id] = parser.message_id
            gxg_message[:to] = parser.to
            gxg_message[:cc] = parser.cc
            gxg_message[:bcc] = parser.bcc
            gxg_message[:subject] = parser.subject
            gxg_message[:date] = parser.date
            gxg_message[:header] = header
            gxg_message[:body] = body
            gxg_message[:attachments] = attachments
            gxg_message
          end
          @client.each_mail do |raw_message|
            if block.respond_to?(:call)
              block.call(parse_message.call(raw_message))
            else
              result << parse_message.call(raw_message)
            end
            unless options[:read_only] == true
              raw_message.delete
            end
          end
        end
      end
    end
  rescue Exception => the_error
    log_error({:error => the_error, :parameters => {}})
  end
  result
end