from twisted.internet import protocol
from datetime import datetime

import buffer

API_PORT        = 34888
SERVER_HOST     = "10.0.0.5"

class ModuleInfo (object) :
    """
        Some info about a module
    """

    # module's name
    name = None

    # module's version, as a 16-bit integer
    version = None

    # list of valid event types (strings)
    event_types = None

    def __str__ (self) :
        return "Module %s:%d" % (self.name, self.version)
    
    def __repr__ (self) :
        return "<module %s:%d with events: %s>" % (self.name, self.version, ", ".join(self.event_types))

class Event (object) :
    # the ModuleInfo object
    module = None

    # the event type as a string
    type = None

    # event message as a string (under 255 bytes in length!)
    msg = None

    # timestamp as a datetime.datetime
    when = None

    def __init__ (self, module, type, msg) :
        assert type in module.event_types, "Invalid event-type %s for %r" % (type, self.module)
        
        self.module = module
        self.type = type
        self.msg = msg

        self.when = datetime.now()
    
    def __str__ (self) :
        return "[%s] %s" % (self.type, self.msg)
    
    def __repr__ (self) :
        return "%s @ %s" % (self.type, self.when)
        
class ServerProtocol (buffer.StreamProtocol, protocol.Protocol) :
    RECV_COMMANDS = [
        "module_init",
        "module_event"
    ]

    SEND_COMMANDS = [

    ]

    VALID_STATES = [
        "wait_init",
        "wait_event"
    ]
    
    # proto state
    state = None

    # module info
    module = None
    
    def _assert (self, condition, msg) :
        if not condition :
            self.transport.loseConnection()
            log.err("assert failed in APIProtocol for %s: %s" % (self.module, msg))
    
    def connectionMade (self) :
        log.msg("Client connected")

    def on_module_init (self, i) :
        self._assert(not self.module, "module_init with non-None self.module")

        m = self.module = api.ModuleInfo()
        
        m.name = i.readVarLen('B')
        m.version = i.readItem('H')

        m.event_types = buffer.readStringStream(i, 'B')
        m.addr = self.transport.getPeer()

        self.module_name = module_name

        log.msg("Got mod_init for %r" % m

        self.factory.nexus.registerModule(m, self)

    def on_module_event (self, i) :
        self._assert(self.module, "module_event with None self.module!")

        event_type = i.readEnum(self.module.event_types)
        event_msg = i.readVarLen('B')
        
        e = api.Event(self.module, event_type, event_msg)

        log.msg("Got mod_event of %r" % (e)

        self.factory.nexus.handleEvent(e)

    def logPrefix (self) :
        if self.module :
            return str(self.module)
        else :
            return super(APIProtocol, self).logPrefix()