#!/usr/bin/python

import string
import sys
import ConfigParser
import socket
import smtplib
import email
import imaplib
import quopri
import re
import calendar
import time


def logthis(prefix,msg):
    print "[%s] %s" %(prefix,msg)

class Config:
    def __init__(self):
        self.config = ConfigParser.ConfigParser()
        self.config.read("file.conf")
        self.sections = self.config.sections

    def get_atributes(self,list_name):
        try:
            self.list_name = list_name
            self.username = list_name
            self.domain = self.config.get(list_name,'domain')
            self.source = self.config.get(list_name,'source')
            self.max_size = int(self.config.get(list_name,'max_size'))
            self.subject = self.config.get(list_name,'subject')
            self.password = self.config.get(list_name,'password')
            self.imapserver = self.config.get(list_name,'imap_host')
            self.smtpserver = self.config.get(list_name,'smtp_host')
            return True
        except ConfigParser.NoOptionError,e:
            logthis(self.list_name,e)
            return False

class Baloo:

    def __init__(self,list_name):
        self.cfg = Config()
        # Check config attributes
        if self.cfg.get_atributes(list_name) == True:
            # Check source users list
            if self.read_source() == True:
                self._connect()

    def read_source(self):
        try:
            with open(self.cfg.source) as f:
                self.USER_DATABASE = f.readlines()
            # remove newline char
            self.USER_DATABASE = map(string.strip,self.USER_DATABASE)
            return True
        except IOError,e:
            logthis(self.cfg.list_name,e)
            return False

    def _connect(self):
        try:
            # Log-in in imap using SSL
            self.conn = imaplib.IMAP4_SSL(self.cfg.imapserver)
            self.conn.login(self.cfg.username,self.cfg.password)
            # create mail boxes
#            print self.conn.list()
            current_month = calendar.month_abbr[time.localtime().tm_mon]
            current_year = str(time.localtime().tm_year)
            store_box =  current_month + current_year
            if self.conn.select('OVERSIZE')[0] == 'NO': self.conn.create('OVERSIZE')
            if self.conn.select('INVALID')[0] == 'NO': self.conn.create('INVALID')
            if self.conn.select('CMD')[0] == 'NO': self.conn.create('CMD')
            if self.conn.select(store_box)[0] == 'NO': self.conn.create(store_box)
            # Select inbox and look for new messages
            if self.conn.select('INBOX')[0] != 'NO':
                return_code, data_range = self.conn.search(None,'ALL')
                self._retrieve(data_range)
            else:
                logthis(self.cfg.list_name,"inbox not found")
        except imaplib.IMAP4.error,e:
            logthis(self.cfg.list_name,e)
        except socket.gaierror,e:
            logthis(self.cfg.list_name,e)

    def _retrieve(self,data_range):
        print "Processing %d messages" % (len(data_range))
        for msg_id in data_range[0].split():
            self.mm = MailMessage(msg_id,self.conn.fetch(msg_id,'(RFC822)'))
            self.check_server_msg()
        # remove all messages marked to be removed
        self.conn.expunge()
        self.conn.logout()

    def check_server_msg(self):
        # Authorization based on True/False
        # Here should apply rules
        forward_flag = []
        forward_flag.append(self.is_allowed_user(self.mm.return_path))
        forward_flag.append(self.check_size())

        if forward_flag[0] == True:
            if forward_flag[1] == True:
                print "* Sending message from",self.mm.mail_from
                self._send(self.mm.mail_subject,self.mm.mail_from)
                self.conn.copy(self.mm.id,self.month_box)
                self.conn.store(self.mm.id, '+FLAGS', '\\Deleted')
            else:
                print "Return a message, complaining about max_size"
                self.conn.copy(self.mm.id,'OVERSIZE')
                self.conn.store(self.mm.id, '+FLAGS', '\\Deleted')
        else:
            print "Do not send message from",self.mm.mail_from
            self.conn.copy(self.mm.id,'INVALID')
            self.conn.store(self.mm.id, '+FLAGS', '\\Deleted')

    def check_size(self):
        maxsize = self.cfg.max_size + 1000000
        if int(self.mm.size) > maxsize:
            return False
        else:
            return True

    def is_allowed_user(self,return_path):
        for user in self.USER_DATABASE:
            if return_path == '':
                return False
            if user.replace('\n','') == return_path:
                return True
        return False

    def _send(self,mail_subject,mail_from):
        server = smtplib.SMTP(self.cfg.smtpserver,25)
        server.ehlo()
        server.starttls()
        server.ehlo()
        server.login(self.cfg.username,self.cfg.password)

        # Get message and change headers
        msg = self.mm.msg
        msg.replace_header('Subject',self.cfg.subject+" "+mail_subject)

        for user in self.USER_DATABASE:
            user = user.replace('\n','')
            #msg.replace_header('To',user)
            if user != '':
                print " - sending to",user
                server.sendmail(self.cfg.username,user,msg.as_string())
        server.quit()


class MailMessage:
    def __init__(self,msg_id,result):
        self.id = msg_id
        rt_cod, self.mail_data = result

        self._get_size()
        self._get_content()
        self._get_mail_object()
        self._get_headers()

    def _get_size(self):
        self.size = re.findall('{[0-9]*}',self.mail_data[0][0])[0][1:-1]

    def _get_content(self):
        self.msg_content = quopri.decodestring(self.mail_data[0][1])

    def _get_mail_object(self):
        self.msg = email.message_from_string(self.msg_content)

    def _get_headers(self):
        recv = ''
        for i in self.msg.items():
            if i[0] == 'Return-Path':
                return_path = i[1]
                self.return_path = return_path[1:-1]
            if i[0] == 'Subject':
                self.mail_subject = i[1]
            if i[0] == 'From':
                self.mail_from = i[1]
            if i[0] == 'Received':
                self.recv = recv + i[1] + "\n"

if __name__ == '__main__':
    config = Config()
    sections = config.sections()

    for section in sections:
        Baloo(section)