############################################################################
# Joshua R. Boverhof, LBNL
# See LBNLCopyright for copyright notice!
###########################################################################
import time

# twisted & related imports
from zope.interface import classProvides, implements, Interface
from twisted.web import client
from twisted.internet import defer
from twisted.internet import reactor
from twisted.python import log
from twisted.python.failure import Failure

from ZSI.parse import ParsedSoap
from ZSI.writer import SoapWriter
from ZSI.fault import FaultFromFaultMessage
from ZSI.wstools.Namespaces import WSA

from WSresource import HandlerChainInterface, CheckInputArgs


# 
# Stability: Unstable
# 

class HTTPPageGetter(client.HTTPPageGetter):
    def handleStatus_500(self):
        """potentially a SOAP:Fault.
        """
        log.err('HTTP Error 500')
    def handleStatus_404(self):
        """client error, not found
        """
        log.err('HTTP Error 404')


client.HTTPClientFactory.protocol = HTTPPageGetter


def getPage(url, contextFactory=None, *args, **kwargs):
    """Download a web page as a string.

    Download a page. Return a deferred, which will callback with a
    page (as a string) or errback with a description of the error.

    See HTTPClientFactory to see what extra args can be passed.
    """
    scheme, host, port, path = client._parse(url)
    factory = client.HTTPClientFactory(url, *args, **kwargs)
    if scheme == 'https':
        if contextFactory is None:
            raise RuntimeError, 'must provide a contextFactory'
        conn = reactor.connectSSL(host, port, factory, contextFactory)
    else:
        conn = reactor.connectTCP(host, port, factory)

    return factory


class ClientDataHandler:
    """
    class variables:
        readerClass -- factory class to create reader for ParsedSoap instances.
        writerClass -- ElementProxy implementation to use for SoapWriter 
            instances.
    """
    classProvides(HandlerChainInterface)
    readerClass = None
    writerClass = None

    @classmethod
    def processResponse(cls, soapdata, **kw):
        """called by deferred, returns pyobj representing reply.
        Parameters and Key Words:
          soapdata -- SOAP Data
          replytype -- reply type of response
        """
        if len(soapdata) == 0:
            raise TypeError('Received empty response')

#        log.msg("_" * 33, time.ctime(time.time()), 
#                  "RESPONSE: \n%s" %soapdata, debug=True)

        ps = ParsedSoap(soapdata, readerclass=cls.readerClass)
        if ps.IsAFault() is True:
            log.msg('Received SOAP:Fault', debug=True)
            raise FaultFromFaultMessage(ps)

        return ps

    @classmethod
    def processRequest(cls, obj, nsdict={}, header=True, 
                       **kw):
        tc = None
        if kw.has_key('requesttypecode'):
            tc = kw['requesttypecode']
        elif kw.has_key('requestclass'):
            tc = kw['requestclass'].typecode
        else:
            tc = getattr(obj.__class__, 'typecode', None)

        sw = SoapWriter(nsdict=nsdict, header=header,
                        outputclass=cls.writerClass)
        sw.serialize(obj, tc)
        return sw
    
    
class WSAddressHandler:
    """Minimal WS-Address handler.  Most of the logic is in
    the ZSI.address.Address class.
    
    class variables:
        uri -- default WSA Addressing URI
    """
    implements(HandlerChainInterface)
    uri = WSA.ADDRESS
    
    def processResponse(self, ps, wsaction=None, soapaction=None, **kw):
        addr = self.address 
        addr.parse(ps)
        action = addr.getAction()
        if not action:
            raise WSActionException('No WS-Action specified in Request')

        if not soapaction:
            return ps
    
        soapaction = soapaction.strip('\'"')
        if soapaction and soapaction != wsaction:
            raise WSActionException(\
                'SOAP Action("%s") must match WS-Action("%s") if specified.'%(
                    soapaction, wsaction)
            )

        return ps

    def processRequest(self, sw, wsaction=None, url=None, endPointReference=None, **kw):
        from ZSI.address import Address
        if sw is None:
            self.address = None
            return
        
        if not sw.header:
            raise RuntimeError, 'expecting SOAP:Header'
        
        self.address = addr = Address(url, wsAddressURI=self.uri)
        addr.setRequest(endPointReference, wsaction)
        addr.serialize(sw, typed=False)
        
        return sw


class DefaultClientHandlerChain:

    @CheckInputArgs(HandlerChainInterface)
    def __init__(self, *handlers):
        self.handlers = handlers
        self.debug = len(log.theLogPublisher.observers) > 0
        self.flow = None
        
    @staticmethod
    def parseResponse(ps, replytype):
        return ps.Parse(replytype)
        
    def processResponse(self, arg, replytype, **kw):
        """
        Parameters:
            arg -- deferred 
            replytype -- typecode
        """
        if self.debug:
            log.msg('--->PROCESS REQUEST\n%s' %arg, debug=1)

        for h in self.handlers:
            arg.addCallback(h.processResponse, **kw)
            
        arg.addCallback(self.parseResponse, replytype)
            
    def processRequest(self, arg, **kw):
        """
        Parameters:
            arg -- XML Soap data string
        """
        if self.debug:
            log.msg('===>PROCESS RESPONSE: %s' %str(arg), debug=1)

        if arg is None:
            return

        for h in self.handlers:
            arg = h.processRequest(arg, **kw)
            
        s = str(arg)
        if self.debug:
            log.msg(s, debug=1)

        return s


class DefaultClientHandlerChainFactory:
    protocol = DefaultClientHandlerChain
    
    @classmethod
    def newInstance(cls):
        return cls.protocol(ClientDataHandler)
        

class WSAddressClientHandlerChainFactory:
    protocol = DefaultClientHandlerChain
    
    @classmethod
    def newInstance(cls):
        return cls.protocol(ClientDataHandler, 
            WSAddressHandler())


class Binding:
    """Object that represents a binding (connection) to a SOAP server.
    """
    agent='ZSI.twisted client'
    factory = DefaultClientHandlerChainFactory
    defer = False

    def __init__(self, url=None, nsdict=None, contextFactory=None, 
                 tracefile=None, **kw):
        """Initialize.
        Keyword arguments include:
            url -- URL of resource, POST is path 
            nsdict -- namespace entries to add
            contextFactory -- security contexts
            tracefile -- file to dump packet traces
        """
        self.url = url
        self.nsdict = nsdict or {}
        self.contextFactory = contextFactory
        self.http_headers  = {'content-type': 'text/xml',}
        self.trace = tracefile

    def addHTTPHeader(self, key, value):
        self.http_headers[key] = value
   
    def getHTTPHeaders(self):
        return self.http_headers
        
    def Send(self, url, opname, pyobj, nsdict={}, soapaction=None, chain=None, 
             **kw):
        """Returns a ProcessingChain which needs to be passed to Receive if 
        Send is being called consecutively.
        """
        url = url or self.url
        cookies = None
        if chain is not None:
            cookies = chain.flow.cookies
        
        d = {}
        d.update(self.nsdict)
        d.update(nsdict)
         
        if soapaction is not None:
            self.addHTTPHeader('SOAPAction', soapaction)
        
        chain = self.factory.newInstance()
        soapdata = chain.processRequest(pyobj, nsdict=nsdict, 
                                        soapaction=soapaction, **kw)
            
        if self.trace:
            print >>self.trace, "_" * 33, time.ctime(time.time()), "REQUEST:"
            print >>self.trace, soapdata

        f = getPage(str(url), contextFactory=self.contextFactory, 
                    postdata=soapdata, agent=self.agent, 
                    method='POST', headers=self.getHTTPHeaders(), 
                    cookies=cookies)
        
        if isinstance(f, Failure):
            return f
        
        chain.flow = f
        self.chain = chain
        return chain
            
    def Receive(self, replytype, chain=None, **kw):
        """This method allows code to act in a synchronous manner, it waits to 
        return until the deferred fires but it doesn't prevent other queued 
        calls from being executed.  Send must be called first, which sets up 
        the chain/factory.  
        
        WARNING: If defer is set to True, must either call Receive
        immediately after Send (ie. no intervening Sends) or pass
        chain in as a paramter.
        
        Parameters:
            replytype -- TypeCode
        KeyWord Parameters:
            chain -- processing chain, optional
            
        """        
        chain = chain or self.chain
        d = chain.flow.deferred
        if self.trace:
            def trace(soapdata):
                print >>self.trace, "_" * 33, time.ctime(time.time()), "RESPONSE:"
                print >>self.trace, soapdata
                return soapdata
            
            d.addCallback(trace)
            
        chain.processResponse(d, replytype, **kw)
        if self.defer:
            return d

        failure = []
        append = failure.append
        def errback(result):
            """Used with Response method to suppress 'Unhandled error in 
            Deferred' messages by adding an errback.
            """
            append(result)
            return None
        
        d.addErrback(errback)

        # spin reactor
        while not d.called:
            reactor.runUntilCurrent()
            t2 = reactor.timeout()
            t = reactor.running and t2
            reactor.doIteration(t)

        pyobj = d.result
        if len(failure):
            failure[0].raiseException()
        
        return pyobj

def trace():
        if trace:
            print >>trace, "_" * 33, time.ctime(time.time()), "RESPONSE:"
            for i in (self.reply_code, self.reply_msg,):
                print >>trace, str(i)
            print >>trace, "-------"
            print >>trace, str(self.reply_headers)
            print >>trace, self.data