class DVRouting(object):

    def __init__(self, list_of_nodes):
        self.list_of_nodes = list_of_nodes
        self.dvlist = [ [ None for x in range(len(self.list_of_nodes)) ] for y in range(len(self.list_of_nodes)) ]
        for x in range(len(self.list_of_nodes)):
            self.dvlist[x][x] = 0

    def manufacturer(self):
        helper = self.list_of_nodes
        for i in self.list_of_nodes:
            for k in i:
                if i[k] <= 0:
                    raise Exception('weight can\'t be negative ')
                if i[k] == 0:
                    raise Exception('weight can\'t be zero')
        for i, v in enumerate(helper):
            for k in v:
                helper_dict = self.list_of_nodes[k]
                for key in helper_dict:
                    if key == i:
                        if v[k] != helper_dict[key]:
                            raise Exception('weight can\'t be negative ')

        return

    def weight(self, x, y):
        if x == y:
            return 0
        if x > (len(self.list_of_nodes) - 1) or y > (len(self.list_of_nodes) - 1):
            return None
        if isinstance(self.list_of_nodes[x], dict) and isinstance(self.list_of_nodes[y], dict):
            node_x = self.list_of_nodes[x]
            node_y = self.list_of_nodes[y]
            if x not in node_y or y not in node_x:
                return None
            if node_x[y] == node_y[x]:
                return node_x[y]
            else:
                return None
        else:
            return None

    def set(self,x, y, w):

        try:
            node_x = self.list_of_nodes[x]
            node_y = self.list_of_nodes[y]
        except TypeError:
            raise Exception('Node don\'t exist')
        if w is None:
            node_y.pop(x)
            node_x.pop(y)
        if x < 0 or y < 0 or w < 0:
            raise Exception('Negative Value')
        if x == y:
            raise Exception('W is not 0')
        else:
            node_x[y] = w
            node_y[x] = w
            self.list_of_nodes[x] = node_x
            self.list_of_nodes[y] = node_y
        return self.list_of_nodes

    def add(self):
        new_node = {}
        self.list_of_nodes.append(new_node)
        return self.list_of_nodes.index(new_node)

    def remove(self, x):
        if 0 <= x < len(self.list_of_nodes) - 1:
            for node in self.list_of_nodes:
                if x in node:
                    node.pop(x)
            self.list_of_nodes[x] = {}
            return
        else:
            return

    def setdv(self, dvlist):
        return dvlist

    def getdv(self, x):
        if self.list_of_nodes[x] not in self.list_of_nodes:
            return None
        else:
            dvlist = None
            node_x = self.list_of_nodes[x]
            for k in node_x:
                dvlist.append(node_x[k])
            return dvlist

    def step(self):
        if self.isstable():
            return True
        else:
            return False

    def isstable(self):
        for i in self.dvlist:
            if None not in i:
                return True
            else:
                return False

    def compute(self):
        counter = 0
        while not self.isstable():
            self.step()
            counter += 1
        return counter

    def route(self, x, y):
        while self.isstable() == False:
            # do steps
            # then compute
            return None