# -*- 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/>.

from anbieter import anbieter

from telnumber import telnumber, InvalidTel

import ConfigParser

import xmlrpclib

import logging

logger=logging.getLogger("sipgate")

class NoValidStatusCode(Exception):

     def __init__(self, value):

         self.value = value

     def __str__(self):

         return repr(self.value)

class sipgate(anbieter):

    """

        s. auch http://www.tuxad.com/sipgate.html

        und http://lists.sipgate.net/pipermail/sipgate-developers/2007-September/000016.html

    """

    section="sipgate"

    url="https://%s:%s@samurai.sipgate.net/RPC2"

    def __init__(self,user="",password=""):

        self.user=user

        self.password=password

    def read_basic_config(self,filenames):

        """Read basic options from the config file"""

        cp = ConfigParser.ConfigParser()

        cp.read(filenames)

        self.user=cp.get(self.section, 'user')

        self.password=cp.get(self.section, 'password')

    def sendSMS(self,sms,recipients):

        """send SMS with $sms to $recipients"""

        logger.debug('sipgate.sendSMS(%s,%s)'%(sms.getContent(),  str(recipients)))

        args={

                "TOS" : "text",

                "Content" : sms.getContent()

                }

        self.__send(args,recipients)

    def sendFAX(self,fax,recipients):

        """send the PDF file $fax  to $recipients"""

        logger.debug('sipgate.sendFAX(%s,%s)'%(fax,  str(recipients)))

        args={

                "TOS" : "fax",

                "Content" : xmlrpclib.Binary(fax.getAttachment(0)),

                }

        self.__send(args,recipients)

    def __connect(self):

        """connect to sipgate XMLRPC Server"""

        logger.debug("sipgate.__connect()-"+self.url%(self.user,"XXXXXXXX"))

        self.serv=xmlrpclib.ServerProxy(self.url%(self.user,self.password)) 

        self.samurai=self.serv.samurai

        args_identify = {

                "ClientName"    : "anbieter.py",

                "ClientVersion" : "V1.0",

                "ClientVendor"  : "Sandro Knauss"

                }

        self.__send_method(self.samurai.ClientIdentify, args_identify)

        return self.serv

    def __send_method(self, func, args=None):

        """execute $func and test weather if the func  ran successfully or not"""

        logger.debug("sipgate.__send_method(func,%s)"%( args))

        if args==None:

            xmlrpc_result = func()

        else:

            xmlrpc_result = func(args)

        if xmlrpc_result['StatusCode'] != 200:

            raise NoValidStatusCode("There was an error during identification to the server! %d %s"% (xmlrpc_result['StatusCode'], xmlrpc_result['StatusString']))

        logger.debug("sipgate.__send_method(..):ok"); 

        return xmlrpc_result

    def __send(self,args,recipients):

        """main sending method - sending the args to $recipients"""

        sended=[]

        serv=self.__connect()

        logger.debug('sipgate.__send(%s,%s)'%(args,  recipients))

        for recipient in recipients:

            try:

                tel = telnumber(recipient)

                if tel in sended:                                                                           #only send message once per recipient

                    continue

                sended.append(tel)

                args["RemoteUri"]="sip:%s%s@sipgate.net"%(tel.land,tel.number)

                self.__send_method(serv.samurai.SessionInitiate, args)

                self.updateStatus(arranged=recipient)

            except (InvalidTel, NoValidStatusCode):

                self.updateStatus(failed=recipient)

        self.__disconnect()

    def updateStatus(self, arranged=None, failed=None):

        """is a function that is called, if a new SMS/FAX was send

        -arranged is non None, if SMS/FAX was sended successfully

        -failed is non None, if SMS/FAX sending failed

        the content will be the recipent"""

        pass

    def BalanceGet(self):

        """get the balance of sipgate"""

        self.__connect()

        ret = self.__send_method(self.samurai.BalanceGet )

        self.__disconnect()

        return ret['CurrentBalance']

    def getNewMessages(self):

        """get new messages from inbox"""

        self.__connect()

        tmp = self.__send_method(self.samurai.UmSummaryGet)

        self.__disconnect()

        tmp=tmp['UmSummary']

        ret={}

        for entry in tmp:

            ret[entry['TOS']]={'read':entry["Read"],'unread':entry["Unread"]}

        return ret

    def getRecommendedInterval(self,methods):

        """how often you can call one $methods"""

        self.__connect()

        args = {"MethodList" : methods }

        tmp = self.__send_method(self.samurai.RecommendedIntervalGet, args)

        self. __disconnect()

        ret={}

        for entry in tmp['IntervalList']:

            ret[entry['MethodName']]=entry['RecommendedInterval']

        return ret

    def __disconnect(self):

        """disconnect xmlrpc client"""

        logger.debug('sipgate.__disconnect()')

        self.samurai=None

        self.serv=None

        self.xmlrpc=None