# -*- 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, NotSupportedFeature

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 MySmstrade(anbieter.smstrade):

    def __init__(self ):

        anbieter.smstrade.__init__(self )

    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")

    smstrade=MySmstrade()

    smstrade.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)