# -*- coding: utf-8 -*-
#Copyright (C) 2009  Georg Bischoff

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


import urllib
from functools import partial
from decimal import Decimal
#import copy

from ..config import Option
from ..model.status import Status
from .provider import Provider, providers
from ..error import RejectRecipient, ExternalException

#import logging
#logger=logging.getLogger("smstrade")

statusCodes = {10 : "Empfaengernummer nicht korrekt.",
    20 : "Absenderkennung nicht korrekt.",
    30 : "Nachrichtentext nicht korrekt.",
    31 : "Messagetyp nicht korrekt.",
    40 : "SMS Route nicht korrekt.",
    50 : "Identifikation fehlgeschlagen.",
    60 : "nicht genuegend Guthaben.",
    70 : "Netz wird von Route nicht abgedeckt.",
    71 : "Feature nicht ueber diese Route moeglich.",
    80 : "Uebergabe an SMS-C fehlgeschlagen.",
    90 : "Versand nicht moeglich.",
    100 : "SMS wurde versendet.",
    }


class SmstradeException(ExternalException):
    def __init__(self,status):
        ExternalException.__init__(self)
        self.status = status
        self.str_=str(status)
    
    def __str__(self):
        return "%s\n%s"%(ExternalException.__str__(self),self.str_)


class StatusCode:
     def __init__(self,code, exID=None, costs=Decimal("0.0"), count=0):
        self.code = code
        
        self.exID = exID
        self.costs = Decimal(costs)
        self.count = int(count)
     
     def __str__(self):
        if self.code in statusCodes.keys():
            return "%i: %s"%(self.code, statusCodes[self.code])
        
        return "%i: unknown statuscode."%self.code

     def __int__(self):
        return self.code

class Smstrade(Provider):
    """
    s. auch http://kundencenter.smstrade.de/sites/smstrade.de.kundencenter/__pdf/SMS-Gateway_HTTP_API_v2.pdf
    """
    params= {"debug":("boolean",False),
            "concat_sms":('boolean',False),
            "message_id":('boolean',False),
            "count":('boolean',False),
            "cost":('boolean',False),
           }
    def __init__(self, name):       
        self.url = "https://gateway.smstrade.de"
        Provider.__init__(self, name, {"sms":["basic","economy","gold","direct"]})
        self.options.update({
            "key":Option(lambda x,y:x,long="smstrade Gateway Key https://login.smstrade.de/index.php?gateway", must=True)
            })
        self.order.append("key")

    def send(self, route, recipient, sms):
        """send SMS with $sms to $recipients"""
        #logger.debug('smstrade.sendSMS(%s,%s)'%(sms,  recipient))

        route = unicode(route)

        if recipient.land != '49' and route == "basic":
            raise RejectRecipient(recipient)
        
        to ='00'+recipient.land+recipient.number
        
        s = self.__send(route, to, sms)	
        if int(s) in (100,):
            return Status(self,route, exID=s.exID, costs=s.costs, count=s.count)
        elif int(s) in (70,71,):
            raise RejectRecipient(recipient, status=s)
        else:
            raise SmstradeException(s)

    def __send(self, route, to, sms):
        """ This function is the main part of the request to the sms service.    
        The function has to return a unicode formated string that will represent the answer of the sms service
        to the request."""
        #logger.debug('smstrade._send(%s,%s,%s)'%( route, to, sms))
        parameters= {"key": self.key,
                "route": route,
                "to": to,
                "message": sms.content,
                "charset":"utf-8", 
                "debug": self.testmode,
                "message_id":True,
                "count":True,
                "cost":True,
                }
        
        doubleChar="€[]{}|\\^~"    #these charactar need two GSM Chars

        if sms.from_ is not None:
            parameters["from"] = sms.from_
       
        length=len(sms.content)
        for s in doubleChar:
            length += sms.content.count(s)
        parameters["concat_sms"] = True if length > 160 else False

        ps={}
        for p in parameters:
            if p in self.params.keys():
                if self.params[p][0] == "boolean":
                    if parameters[p] != self.params[p][1]:
                        ps[p]=int(bool(parameters[p]))
            else:
                ps[p] = parameters[p]

        params = urllib.urlencode(ps)
        #dp=copy.deepcopy(ps)
        #dp["key"]="<KEY>"
        #print 'smstrade._send-parameters:%s\n\t->%s'%(str(dp), urllib.urlencode(dp))
        
        response = urllib.urlopen(self.url, params)
        data = response.readlines()
        if len(data) == 1:
            return StatusCode(int(data[0]))
        return StatusCode(int(data[0]),exID=data[1],costs=data[2],count=data[3])

    def getSendFunc(self, typ, route):
        Provider.getSendFunc(self, typ, route)
        return partial(self.send,route)

providers["smstrade"]=Smstrade