from pymote.algorithm import NodeAlgorithm
from pymote.message import Message
import random

class Saturation(NodeAlgorithm):
    #required_params = {}
    default_params = {'neighborsKey': 'Neighbors', 'numNeighboursKey': 'numNeighbours', 'eccentrityKey': 'eccentrity', 'parentKey': 'parent'}

    def initializer(self):
        ini_nodes = []
        isInitiator = False

        for node in self.network.nodes():
            node.memory[self.neighborsKey] = node.memory['neighborsTree']
            node.memory[self.eccentrityKey] = 0

            node.memory[self.numNeighboursKey] = len(node.memory[self.neighborsKey])
            node.status = 'AVAILABLE'

            print "INITIATORS: "
            isInitiator = random.choice([True, False])
            if isInitiator:
                ini_nodes.append(node)
                print str(node)

        for ini_node in ini_nodes:
            self.network.outbox.insert(0, Message(header=NodeAlgorithm.INI,
                                                  destination=ini_node))

    def available(self, node, message):

        if message.header == NodeAlgorithm.INI:
            status = 'ACTIVE'
            destination_nodes = list(node.memory[self.neighborsKey])
            header = 'Activate'
            node.send(Message(destination=destination_nodes,
                              header=header,
                              data="Activate"))

            if len(destination_nodes) == 1:
                status = 'PROCESSING'
                header = 'Message'
                data = node.memory[self.eccentrityKey]
                #zapisi parenta
                node.send(Message(destination=destination_nodes,
                              header=header,
                              data=data))
            else:
                status = 'ACTIVE'

        elif (message.header == 'Activate'):
            header = 'Activate'
            destination_nodes = list(node.memory[self.neighborsKey])
            destination_nodes.remove(message.source)
            node.send(Message(destination=destination_nodes,
                              header=header,
                              data="Activate"))

            destination_nodes = list(node.memory[self.neighborsKey])
            if len(destination_nodes) == 1:
                status = 'PROCESSING'
                header = 'Message'
                data = node.memory[self.eccentrityKey]+1
                #zapisi parenta
                node.send(Message(destination=destination_nodes,
                              header=header,
                              data=data))
            else:
                status = 'ACTIVE'

        node.status = status

    def active(self, node, message):
        status = 'ACTIVE'

        if (message.header == 'Message'):
            if (message.data+1 > node.memory[self.eccentrityKey]):
                node.memory[self.eccentrityKey] = message.data+1
                print "ECCENTRITY: " + str(node) + str(message.source) + "+1"

            destination_nodes = list(node.memory[self.neighborsKey])
            destination_nodes.remove(message.source)
            node.memory[self.neighborsKey] = destination_nodes

            if len(destination_nodes) == 1:
                status = 'PROCESSING'
                header = 'Message'
                data = node.memory[self.eccentrityKey]
                #zapisi parenta
                node.send(Message(destination=destination_nodes,
                              header=header,
                              data=data))

        node.status = status

    def processing(self, node, message):
        status = 'PROCESSING'
        if (message.header == 'Message'):
            status = 'SATURATED'
            node.memory[self.parentKey] = message.source
            if (message.data+1 > node.memory[self.eccentrityKey]):
                node.memory[self.eccentrityKey] = message.data+1

        elif (message.header == 'Distance'):
            node.memory[self.parentKey] = message.source
            if (message.data+1 > node.memory[self.eccentrityKey]):
                node.memory[self.eccentrityKey] = message.data+1
            destination_nodes = list(node.memory[self.neighborsKey])
            destination_nodes.remove(node.memory[self.parentKey])
            if (destination_nodes):
                header = 'Distance'
                data = node.memory[self.eccentrityKey]
                node.send(Message(destination=destination_nodes,
                                  header=header,
                                  data=data))

        node.status = status


    def saturated(self, node, message):
        print "#####################"
        destination_nodes = list(node.memory[self.neighborsKey])
        destination_nodes.remove(node.memory[self.parentKey])
        if(destination_nodes):
            header = 'Distance'
            data = node.memory[self.eccentrityKey]
            node.send(Message(destination=destination_nodes,
                              header=header,
                              data=data))

        node.status = 'DONE'


    def done():
        pass


    STATUS = {
        'ACTIVE': active,
        'AVAILABLE': available,
        'PROCESSING': processing,
        'SATURATED': saturated,
        'DONE': done
    }