# -*- coding: utf-8 -*-
#Copyright (C) 2009  Sandro Knauß <bugs@sandroknauss.de>

#This program is free software; you can redistribute it and/or modify it under the terms
#of the GNU General Public License as published by the Free Software Foundation;
#either version 3 of the License, or any later version.
#This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
#without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#See the GNU General Public License for more details.

#You should have received a copy of the GNU General Public License
#along with this program; if not, see <http://www.gnu.org/licenses/>.

# Server code

from xmlrpc import SecureUserDBXMLRPCServer,UserDB
import time, os, md5
from user import User, Admin
import content
import anbieter
import ConfigParser

class MyUserDB(UserDB):
    def __init__(self, userlist,jobqueue):
        UserDB.__init__(self, None,userlist,jobqueue)
        
    def createUser(self, user):
        self.userlist[self.createHash(user)]=user["class"](self.jobqueue)

class Job(object):
    '''
    Basic class for all jobs
    '''   
    def __init__(self,provider,name):
        self.provider=provider
        self.name=name
        self.status = "init"
        self.dStatus={"good":[], "failed":[]}

    def start(self):
        self.status = "started"
        
    def stop(self):
        self.status = "stopped"
        
    def getStatus(self,detailed):
        if detailed and self.status == "started" or self.status == "sended":
            return self.status, self.dStatus
        return self.status, {}
    
    def getName(self):
        return self.name
        
    def getProvider(self):
        return self.provider
        
    def addGood(self, good):
        if type(good) == list:
            self.dStatus['good']=self.dStatus['good']+good
        else:
            self.dStatus['good'].append(good)
    
    def addFailed(self, failed):
        if type(failed) == list:
            self.dStatus['failed']=self.dStatus['failed']+failed
        else:
            self.dStatus['failed'].append(failed)

class MessageJob(Job):
    '''
    A specialized class for smsjobs
    '''
    def __init__(self,provider,name, message,recipients):
        self.message=message
        self.recipients=recipients
        Job.__init__(self,provider, name)
        
    def stop(self):
        pass
        
    def start(self):
        Job.start(self)
        self.provider.setJob(self)
        self.message.sendto(self.provider, self.recipients)
        self.status="sended"

    def getMessage(self):
        return self.message
        
    def getRecipients(self):
        return self.recipients
 

class MySipgate(anbieter.sipgate):
    
    def __init__(self,user="",password="" ):
        anbieter.sipgate.__init__(self, user, password)
    
    def setJob(self, job):
        self.job=job
    
    def updateStatus(self, arranged=None, failed=None):
        if arranged:
            self.job.addGood(arranged)
        
        if failed:
            self.job.addFailed(failed)
            
class MySMTP(anbieter.SMTP):
    
    def __init__(self,config_filename=None,section="smtp"):
        anbieter.SMTP.__init__(self,config_filename,section)
    
    def setJob(self, job):
        self.job=job
    
    def updateStatus(self, arranged=None, failed=None):
        if arranged:
            self.job.addGood(arranged)
        
        if failed:
            self.job.addFailed(failed)
    

class Jobs:
    '''
    Providing an list of jobs; each new job gets a hash id
    '''
    def __init__(self,manager, queue,provider):
        self.jobs={}
        self.manager=manager
        self.queue=queue
        self.provider=provider
        

    def __getitem__(self,key):
        return self.jobs[key]

    def __registerJob__(self, job):
        id = self._createID()
        self.jobs[id]=job
        self.queue.put(job)
        return id

    def newSMS(self,message,recipients):
        '''
        creates a new SMS
        '''
        job=self.manager.MessageJob(self.provider["sms"],message, content.SMS(message),recipients)
        return self.__registerJob__(job)

    def newFAX(self,subject, fax,recipients):
        '''
        creates a new Fax
        '''
        job=self.manager.MessageJob(self.provider["fax"],subject, content.FAX(subject, fax),recipients)
        return self.__registerJob__(job)

    def newMail(self,subject, body,recipients):
        '''
        creates a new Mail
        '''
        job=self.manager.MessageJob(self.provider["mail"],subject, content.Mail(subject, body),recipients)
        return self.__registerJob__(job) 

    def _createID(self):
        '''
        creats a random hash id
        '''
        while True:
            m = md5.new()
            m.update(str(time.time()))
            m.update(os.urandom(10))
            if not self.jobs.has_key(m.hexdigest):
                self.jobs[m.hexdigest()]=None
                break
        return m.hexdigest()

def start(userlist):
    from multiprocessing import Queue
    from multiprocessing.managers import BaseManager
    
    class MyManager(BaseManager):
        pass
    
    MyManager.register('MessageJob', MessageJob) 
    manager = MyManager()
    manager.start()
    
    
    #anbieter erzeugen und konfigurieren

    sip=MySipgate()
    sip.read_basic_config("iro.conf")
    
    localhost=MySMTP()
    localhost.read_basic_config("iro.conf")
    
    #Benutzerdatenbank erstellen
    queue = Queue()
    provider={"sms":sip, "fax":sip, "mail":localhost}
    jobqueue=Jobs(manager,  queue, provider)
    userdb=MyUserDB(userlist,jobqueue)

    #working thread erstellen
    from worker import Worker
    worker=Worker(queue)
    worker.start()

    #Server starten
    cp = ConfigParser.ConfigParser()
    cp.read(["iro.conf"])
    cert=cp.get('server', 'cert')
    key=cp.get('server', 'key')
    server = SecureUserDBXMLRPCServer(addr=("localhost", 8000), 
                                      userdb=userdb,
                                      certificate=cert,privatekey=key)
    server.relam="xmlrpc"
    
    print "Server started..."
    server.serve_forever()
    
    worker.terminate()

if __name__ == '__main__':
    userlist=[{"name":"test","password":"test",  "class":User},
	      {"name":"test2","password":"test2", "class": Admin}]
    start(userlist)