"""Adapted from Pyro Project"""

from socket import *
import threading, struct, sys

class Listener:
    """A class for talking to ports on Aibo, use with ListenerThread below"""
    def __init__(self, port, host, protocol = "TCP"):
        self.port = port
        self.host = host
        self.protocol = protocol
        self.runConnect()
        #self.s.settimeout(0.1)

    def runConnect(self):
        print >> sys.stderr, "[",self.port,"] connecting ...",
        try:
            if self.protocol == "UDP":
                self.s = socket(AF_INET, SOCK_DGRAM) # udp socket
            elif self.protocol == "TCP":
                self.s = socket(AF_INET, SOCK_STREAM) # tcp socket
            done = 0
            while not done:
                try:
                    self.s.connect((self.host,self.port)) # connect to server
                    done = 1
                except KeyboardInterrupt:
                    print >> sys.stderr, "aborted!"
                    return
                except:
                    print >> sys.stderr, ".",
            print >> sys.stderr, "connected!"
        except IOError, e:
            print e

    def readUntil(self, stop = "\n"):
        retval = ""
        ch = self.s.recvfrom(1)[0]
        while ch != stop:
            retval += struct.unpack('c', ch)[0]
            ch = self.s.recvfrom(1)[0]
        return retval

    def read(self, bytes = 4, format = 'l', all=False):
        data = ""
        for i in range(bytes):
            data += self.s.recvfrom(1)[0]
        if all:
            return struct.unpack(format, data)
        else:
            return struct.unpack(format, data)[0]

    def write(self, message):
        retval = self.s.send(message)
        return retval

class ListenerThread(threading.Thread):
    """A thread class for the listener, collects data quickly in its own thread"""
    def __init__(self, listener, callback):
        self.listener = listener
        self.callback = callback
        self._stopevent = threading.Event()
        self._sleepperiod = 0.001
        threading.Thread.__init__(self, name="ListenerThread")

    def run(self):
        """overload of threading.thread.run(), main control loop"""
        while not self._stopevent.isSet():
            self.callback(self.listener)
            self._stopevent.wait(self._sleepperiod)

    def join(self,timeout=None):
        """Stop the thread"""
        self._stopevent.set()
        threading.Thread.join(self, timeout)