# Copyright (c) 2005, Benjamin Stiglitz
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# Modifications (c) 2005  by littlegreen
#
require 'net/imap'

Net::IMAP.debug = true if CDF::CONFIG[:debug_imap]

class Net::IMAP
  class PlainAuthenticator
    def process(data)
      return "\0#{@user}\0#{@password}"
    end

    private
    def initialize(user, password)
      @user = user
      @password = password
    end
  end
  add_authenticator('PLAIN', PlainAuthenticator)

  class Address
    def to_s
      if(name)
        "#{name} #{mailbox}@#{host}"
      else
        "#{mailbox}@#{host}"
      end
    end
  end
end

class AuthenticationError < RuntimeError
end

class IMAPMailbox
  attr_reader :connected
  attr_accessor :selected_mailbox
  cattr_accessor :logger

  def initialize(logger)
    @selected_mailbox = ''
    @folders          = {}
    @connected = false
    @logger = logger
  end

  def connect(username, password)
	#logger.debug "*** connect: @connected"
    unless @connected
      use_ssl = CDF::CONFIG[:imap_use_ssl] ? true : false
      port    = CDF::CONFIG[:imap_port] || (use_ssl ? 993 : 143)
     # logger.debug "*** IMAP params: use_ssl => #{use_ssl}, port => #{port}"
      begin
        @imap   = Net::IMAP.new(CDF::CONFIG[:imap_server], port, use_ssl)
      rescue Net::IMAP::ByeResponseError => bye
        # make a timeout and retry
        begin
          System.sleep(CDF::CONFIG[:imap_bye_timeout_retry_seconds])
          @imap   = Net::IMAP.new(CDF::CONFIG[:imap_server], port, use_ssl)
        rescue Error => ex
      #    logger.error "Error on authentication!"
      #	  logger.error bye.backtrace.join("\n")
          raise AuthenticationError.new
        end
      rescue Net::IMAP::NoResponseError => noresp
      #  logger.error "Error on authentication!"
      #	logger.error noresp.backtrace.join("\n")
        raise AuthenticationError.new
      rescue Net::IMAP::BadResponseError => bad
      #  logger.error "Error on authentication!"
      #	logger.error bad.backtrace.join("\n")
        raise AuthenticationError.new
      rescue Net::IMAP::ResponseError => resp
      #  logger.error "Error on authentication!"
      #	logger.error resp.backtrace.join("\n")
        raise AuthenticationError.new
      end
      @username = username
      begin
      #	logger.error "IMAP authentication - #{CDF::CONFIG[:imap_auth]}."
        if CDF::CONFIG[:imap_auth] == 'NOAUTH'
          @imap.login(username, password)
        else
          @imap.authenticate(CDF::CONFIG[:imap_auth], username, password)
        end
        @connected = true
      rescue Exception => ex
      #  logger.error "Error on authentication!"
      #	logger.error ex.backtrace.join("\n")
        raise AuthenticationError.new
      end
    end
  end

  def imap
    @imap
  end

  # Function chnage password works only if root has run imap_backend
  # and users courier-authlib utility authtest - from courier-imap version 4.0.1
  def change_password(username, password, new_password)
    ret = ""
    cin, cout, cerr = Open3.popen3("/usr/sbin/authtest #{username} #{password} #{new_password}")
    ret << cerr.gets
    if ret.include?("Password change succeeded.")
      return true
    else
      logger.error "[!] Error on change password! - #{ret}"
      return false
    end
  end

  def disconnect
    if @connected
      @imap.logout
      #@imap.disconnect
      @imap = nil
      @connected = false
    end
  end

  def [](mailboxname)
    @last_folder = IMAPFolderList.new(self, @username)[mailboxname]
  end

  def folders
    # reference just to stop GC
    @folder_list ||= IMAPFolderList.new(self, @username)
    @folder_list
  end

  def reload
    @folder_list.reload if @folder_list
  end

  def create_folder(name)
#     begin
    @imap.create(Net::IMAP.encode_utf7(name))
    reload
#     rescue Exception=>e
#     end
  end

  def delete_folder(name)
    begin
      @imap.delete(folders[name].utf7_name)
      reload
    rescue Exception=>e
      logger.error("Exception on delete #{name} folder #{e}")
    end
  end

  def message_sent(message)
    # ensure we have sent folder
    begin
      @imap.create(CDF::CONFIG[:mail_sent])
    rescue Exception=>e
    end
    begin
      @imap.append(CDF::CONFIG[:mail_sent], message)
      folders[CDF::CONFIG[:mail_sent]].cached = false if folders[CDF::CONFIG[:mail_sent]]
    rescue Exception=>e
      logger.error("Error on append  - #{e}")
    end

  end

  def message_bulk(message)
    # ensure we have sent folder
    begin
      @imap.create(CDF::CONFIG[:mail_bulk_sent])
    rescue Exception=>e
    end
    begin
      @imap.append(CDF::CONFIG[:mail_bulk_sent], message)
      folders[CDF::CONFIG[:mail_sent]].cached = false if folders[CDF::CONFIG[:mail_bulk_sent]]
    rescue Exception=>e
      logger.error("Error on bulk -  #{e}")
    end
  end
end

class IMAPFolderList
  include Enumerable
  cattr_accessor :logger

  def initialize(mailbox, username)
    @mailbox = mailbox
    @folders = Hash.new
    @username = username
  end

  def each
    refresh if @folders.empty?
    #@folders.each_value { |folder| yield folder }
    # We want to allow sorted access; for now only (FIXME)

    @folders.sort.each { |pair| yield pair.last }
  end

  def reload
    refresh
  end

  def [](name)
    refresh if @folders.empty?
    @folders[name]
  end

  private
  def refresh
    @folders = {}
    result = @mailbox.imap.list('', '*')
    if result
      result.each do |info|
        folder = IMAPFolder.new(@mailbox, info.name, @username, info.attr, info.delim)
        @folders[folder.name] = folder
      end
    else
      # if there are no folders subscribe to INBOX - this is on first use
      @mailbox.imap.subscribe(CDF::CONFIG[:mail_inbox])
      # try again to list them - we should find INBOX
      @mailbox.imap.list('', '*').each do |info|
        @folders[info.name] = IMAPFolder.new(@mailbox, info.name, @username, info.attr, info.delim)
      end
    end
    @folders
  end
end

class IMAPFolder
  attr_reader :mailbox
  attr_reader :name
  attr_reader :utf7_name
  attr_reader :username
  attr_reader :delim
  attr_reader :attribs

  attr_writer :cached
  attr_writer :mcached

  cattr_accessor :logger

  @@fetch_attr = ['ENVELOPE','BODYSTRUCTURE', 'FLAGS', 'UID', 'RFC822.SIZE']

  def initialize(mailbox, utf7_name, username, attribs, delim)
    @mailbox = mailbox
    @utf7_name = utf7_name
    @name = Net::IMAP.decode_utf7 utf7_name
    @username = username
    @messages = Array.new
    @delim = delim
    @attribs = attribs
    @cached = false
    @mcached = false
  end

  def activate
    if(@mailbox.selected_mailbox != @name)
      @mailbox.selected_mailbox = @name
      @mailbox.imap.select(@utf7_name)
      load_total_unseen if !@cached
    end
  end

  # Just delete message without interaction with Trash folder
  def delete(message)
    activate
    uid = (message.kind_of?(Integer) ? message : message.uid)
    @mailbox.imap.uid_store(uid, "+FLAGS", :Deleted)
    @mailbox.imap.expunge
    # Sync with trash cannot be made - new uid generated - so just delete message from current folder
    ImapMessage.delete_all(["username = ? and folder_name = ? and uid = ?", @username, @name, uid])
    @cached = false
  end

  # Deleted messages - move to trash folder
  def delete_multiple(uids)
    # ensure we have trash folder
    begin
      @mailbox.imap.create(CDF::CONFIG[:mail_trash])
    rescue
    end
    move_multiple(uids, CDF::CONFIG[:mail_trash])
  end

  def copy(message, dst_folder)
    uid = (message.kind_of?(Integer) ? message : message.uid)
    activate
    @mailbox.imap.uid_copy(uid, dst_folder)
    @mailbox.folders[dst_folder].cached = false if @mailbox.folders[dst_folder]
    @mailbox.folders[dst_folder].mcached = false if @mailbox.folders[dst_folder]
  end

  def copy_multiple(message_uids, dst_folder)
    activate
    @mailbox.imap.uid_copy(message_uids, dst_folder)
    @mailbox.folders[dst_folder].cached = false if @mailbox.folders[dst_folder]
    @mailbox.folders[dst_folder].mcached = false if @mailbox.folders[dst_folder]
  end

  def move(message, dst_folder)
    uid = (message.kind_of?(Integer) ? message : message.uid)
    activate
    @mailbox.imap.uid_copy(uid, dst_folder)
    @mailbox.imap.uid_store(uid, "+FLAGS", :Deleted)
    @mailbox.folders[dst_folder].cached = false if @mailbox.folders[dst_folder]
    @mailbox.folders[dst_folder].mcached = false if @mailbox.folders[dst_folder]
    @mailbox.imap.expunge
    ImapMessage.delete_all(["username = ? and folder_name = ? and uid = ? ", @username, @name, uid])
    @cached = false
    @mcached = false
  end

  def move_multiple(message_uids, dst_folder)
    activate
    @mailbox.imap.uid_copy(message_uids, @mailbox.folders[dst_folder].utf7_name)
    @mailbox.imap.uid_store(message_uids, "+FLAGS", :Deleted)
    @mailbox.folders[dst_folder].cached = false if @mailbox.folders[dst_folder]
    @mailbox.folders[dst_folder].mcached = false if @mailbox.folders[dst_folder]
    @mailbox.imap.expunge
    ImapMessage.delete_all(["username = ? and folder_name = ? and uid in ( ? )", @username, @name, message_uids])
    @cached = false
    @mcached = false
  end

  def mark_read(message_uid)
  	activate
    cached = ImapMessage.find(:first, :conditions => ["username = ? and folder_name = ? and uid = ?", @username, @name, message_uid])
    if cached.unread
      cached.unread = false
      cached.save
      @mailbox.imap.select(@name)
      @mailbox.imap.uid_store(message_uid, "+FLAGS", :Seen)
      @unseen_messages = @unseen_messages - 1
    end
  end

  def mark_unread(message_uid)
  	activate
    cached = ImapMessage.find(:first, :conditions => ["username = ? and folder_name = ? and uid = ?", @username, @name, message_uid])
    if !cached.unread
      cached.unread = true
      cached.save
      @mailbox.imap.select(@name)
      @mailbox.imap.uid_store(message_uid, "-FLAGS", :Seen)
      @unseen_messages = @unseen_messages + 1
    end
  end

  def expunge
    activate
    @mailbox.imap.expunge
  end

  def synchronize_cache(offset=0, limit = 10)
    to = limit+offset
    startSync = Time.now
    activate
    startUidFetch = Time.now

    #Count all messages
    count = @mailbox.imap.fetch(1..-1, "UID")
    to = count.size if count.size < to


    range = (offset..to)
    #logger.info range.inspect

    server_messages = @mailbox.imap.fetch(range, "(UID FLAGS)")
    #server_messages = @mailbox.imap.uid_fetch(sequence_uids, ["UID", "FLAGS"])

    startDbFetch = Time.now
    cached_messages = ImapMessage.find(:all, :conditions => ["username = ? and folder_name = ?", @username, @name])

    cached_unread_uids = Array.new
    cached_read_uids = Array.new
    uids_to_be_deleted = Array.new

    cached_messages.each { |msg|
      cached_unread_uids << msg.uid if msg.unread
      cached_read_uids << msg.uid unless msg.unread
      uids_to_be_deleted << msg.uid
    }

    uids_to_be_fetched = Array.new
    server_msg_uids = Array.new

    uids_unread = Array.new
    uids_read = Array.new

    server_messages.each { |server_msg|
      uid, flags = server_msg.attr['UID'], server_msg.attr['FLAGS']
      server_msg_uids << uid
      unless uids_to_be_deleted.include?(uid)
        uids_to_be_fetched << uid
      else
        if flags.member?(:Seen) && cached_unread_uids.include?(uid)
          uids_read << uid
        elsif !flags.member?(:Seen) && cached_read_uids.include?(uid)
          uids_unread << uid
        end
      end
      uids_to_be_deleted.delete(uid)
    } unless server_messages.nil?

    ImapMessage.delete_all(["username = ? and folder_name = ? and uid in ( ? )", @username, @name, uids_to_be_deleted]) unless uids_to_be_deleted.empty?
    ImapMessage.update_all('unread = 0', ["username = ? and folder_name = ? and uid in ( ? )", @username, @name, uids_read]) unless uids_read.empty?
    ImapMessage.update_all('unread = 1', ["username = ? and folder_name = ? and uid in ( ? )", @username, @name, uids_unread])  unless uids_unread.empty?


    # fetch and store not cached messages
    unless uids_to_be_fetched.empty?
   #   logger.debug("About to fetch #{uids_to_be_fetched.join(",")}")
      uids_to_be_fetched.each_slice(20) do |slice|
        fetch_uids(slice)
      end
    end
    #FIX: @mcached = true
  #  logger.debug("Synchonization done for folder #{@name} in #{Time.now - startSync} ms.")
  end

  def fetch_uids(uids)
      imapres = @mailbox.imap.uid_fetch(uids, @@fetch_attr)
      imapres.each { |cache|
        envelope = cache.attr['ENVELOPE'];
        message = ImapMessage.create( :folder_name => @name,
                                      :username => @username,
                                      :msg_id => envelope.message_id,
                                      :uid => cache.attr['UID'],
                                      :from_addr => envelope.from,
                                      :to_addr => envelope.to,
                                      :subject => envelope.subject,
                                      :content_type => cache.attr['BODYSTRUCTURE'].multipart? ? 'multipart' : 'text',
                                      :date => envelope.date,
                                      :unread => !(cache.attr['FLAGS'].member? :Seen),
                                      :size => cache.attr['RFC822.SIZE'])
      }
  end

  def messages(offset = 0, limit = 10, sort = 'date desc')
    # Synchronize first retrieval time
    synchronize_cache(offset+1, limit) #unless @mcached

    if limit == -1
      @messages = ImapMessage.find(:all, :conditions => ["username = ? and folder_name = ?", @username, @name], :order => sort)
    else
      @messages = ImapMessage.find(:all, :conditions => ["username = ? and folder_name = ?", @username, @name], :order => sort )
    end
  end

  def messages_search(query = ["ALL"], sort = 'date desc')
    activate
    uids = @mailbox.imap.uid_search(query)
    if uids.size > 1
      ImapMessage.find(:all, :conditions => ["username = ? and folder_name = ? and uid in ( ? )", @username, @name, uids], :order => sort )
    elsif uids.size == 1
      ImapMessage.find(:all, :conditions => ["username = ? and folder_name = ? and uid = ? ", @username, @name, uids.first], :order => sort )
    else
      return Array.new
    end

  end

  def message(uid)
    activate
    message = ImapMessage.find(:first, :conditions => ["username = ? and folder_name = ? and uid = ?", @username, @name, uid])
    message.set_folder(self)
    message
  end

  def unseen
    activate
    load_total_unseen if !@cached
    @unseen_messages
  end

  def total
    activate
    load_total_unseen if !@cached
    @total_messages
  end

  def load_total_unseen
    stat = @mailbox.imap.status(@utf7_name, ["MESSAGES", "UNSEEN"])
    @total_messages, @unseen_messages = stat["MESSAGES"], stat['UNSEEN']
    @cached = true
  end

  def update_status
    @status ||= @mailbox.imap.status(@utf7_name, ["MESSAGES"])
  end

  def subscribe
    @mailbox.imap.subscribe(@utf7_name)
  end

  def trash?
    self.name == CDF::CONFIG[:mail_trash]
  end
end