from . import LowLevelMessages
from .Thing import Thing

class IMessage:
    id = 0x00

    ## Serialize the message into the given buffer
    #
    ## @returns: the length of the message
    def Serialize(buffer):
        return 0
    
    def SendTo(self, participant):
        buffer_size = self.Serialize([participant.buffer])
        if buffer_size == 0:
            return False
        return participant.SendBuffer(buffer_size)
    
    def Publish(self, participant):
        bufferSize = self.Serialize([participant.buffer])
        if bufferSize == 0:
            return False
        return participant.PublishBuffer(bufferSize)

class InvestigateMsg():
    id = 0x81
    length = 3

    def __init__(self, buffer):
        self.network_id = buffer[1]
        self.thing_id = buffer[2]

class PoseMsg(IMessage):
    id = 0x10
    length = 4

    def __init__(self, network_id, thing):
        self.network_id = network_id
        self.thing = thing

    def Serialize(self, buffer_ref):
        if (self.network_id is None) or (self.thing is None):
            return 0
        
        buffer: bytearray = buffer_ref[0]
        buffer[0:PoseMsg.length] = [
            PoseMsg.id,
            self.network_id,
            self.thing.id,
            self.thing.pose_updated
        ]
        ix = [4]
        if self.thing.pose_updated & Thing.Position:
            LowLevelMessages.SendSpherical(buffer, ix, self.thing.position)
        if self.thing.pose_updated & Thing.Orientation:
            LowLevelMessages.SendQuat32(buffer, ix, self.thing.orientation)
        if self.thing.pose_updated & Thing.LinearVelocity:
            LowLevelMessages.SendSpherical(buffer, ix, self.thing.linearVelocity)
        if self.thing.pose_updated & Thing.AngularVelocity:
            LowLevelMessages.SendSpherical(buffer, ix, self.thing.angularVelocity)
        return ix[0]