from twisted.words.xish import domish, xmlstream
from twisted.internet import protocol
from twisted.words.xish import domish, utility
from twisted.internet import reactor
from twisted.python import log
import sys
log.startLogging(sys.stdout)
##class TlenAuthenticator(xmlstream.ConnectAuthenticator):
##	def __init__(self, jid, password):
##		xmlstream.ConnectAuthenticator.__init__(self, jid.host)
##		self.jid = jid
##		self.password = password
##		
##	def associateWithStream(self, xs):
##		xs.version = (0, 0)
##		xmlstream.ConnectAuthenticator.associateWithStream(self, xs)
##	
##		inits = [(TlenAuthInitializer, True)]
##		for initClass, required in inits:
##			init = initClass(xs)
##			init.required = required
##			xs.initializers.append(init)
STREAM_CONNECTED_EVENT = intern("//event/stream/connected")
STREAM_START_EVENT = intern("//event/stream/start")
STREAM_END_EVENT = intern("//event/stream/end")
STREAM_ERROR_EVENT = intern("//event/stream/error")
class TlenStream(xmlstream.XmlStream):
	def _initializeStream(self):
		""" Sets up XML Parser. """
		self.stream = domish.elementStream()
		self.stream.DocumentStartEvent = self.onDocumentStart
		self.stream.ElementEvent = self.onElement
		self.stream.DocumentEndEvent = self.onDocumentEnd
		s = domish.Element((None, 's'))
		s['v'] = '8'
		s['t'] = '06000106'
		self.send(s.toXml(closeElement=0))
##		print s.toXml(closeElement=0)
 
	def dataReceived(self, data):
 
		try:
			if self.rawDataInFn: self.rawDataInFn(data)
			self.stream.parse(data)
		except domish.ParserError:
			print 'hmm?'
			self.dispatch(self, STREAM_ERROR_EVENT)
			self.transport.loseConnection()
		print data
	def onElement(self, element):
		xmlstream.XmlStream.onElement(self, element)
		print element
	def onDocumentStart(self, rootelem):
		print 'start', rootelem
		self.dispatch(self, STREAM_START_EVENT)  
 
class TlenStreamFactory(protocol.ReconnectingClientFactory):
    """ Factory for XmlStream protocol objects as a reconnection client.
 
    This factory generates XmlStream objects when a connection has been
    established. To make sure certain event observers are set up before
    incoming data is processed, you can set up bootstrap event observers using
    C{addBootstrap}.
    """
    protocol = TlenStream
    def __init__(self):
        self.bootstraps = []
 
    def buildProtocol(self, addr):
        """ Create an instance of XmlStream.
 
        The returned instance will have bootstrap event observers registered
        and will proceed to handle input on an incoming connection.
        """
        self.resetDelay()
        xs = TlenStream()
        xs.factory = self
        for event, fn in self.bootstraps: xs.addObserver(event, fn)
        return xs
 
    def addBootstrap(self, event, fn):
        """ Add a bootstrap event handler. """
        self.bootstraps.append((event, fn))
 
    def removeBootstrap(self, event, fn):
        """ Remove a bootstrap event handler. """
        self.bootstraps.remove((event, fn))
 
def lg(el):
	print 'all>',el
def err(el):
	print 'err>', el
factory = TlenStreamFactory()
factory.addBootstrap('/*', lg)
factory.addBootstrap(STREAM_ERROR_EVENT, err)
 
reactor.connectTCP('s1.tlen.pl', 443, factory)
reactor.run()