'''
Created on Apr 5, 2016
@author: Brett Paufler
Copyright Brett Paufler


Adds some preliminary Genetic Algorithm functionality to maze_tree
    subclass of maze_tree

4-26-16
    Stopped working on
    Being created in Conjunction with 
        maze_tree_dungeon

'''


from maze_tree import Node, Tree
from random import choice, shuffle
from maze import Maze

'''
class Room(Node):
    def __init__(self, room=None, links=None, data=None):
        Node.__init__(self, links=links, data=data)
        self.room = room
    
    def __repr__(self):
        text = '%s, room:%s' % (Node.__repr__(self), str(self.room))
        #print type(text)
        #text += ' room:' + 
        #print type(text), text
        return text
'''



class GeneticTree(Tree):
    '''A Genetic Algorithm subclass of Tree.'''
    
    #def __init__(self, name='Dungeon', room_names=None):
    #    nodes = [Room(room=room) for room in room_names]
    #    Tree.__init__(self, name=name, meta=None, nodes=nodes)

    def __repr__(self):
        return 'GeneticTree' + Tree.__repr__(self)[4:]


    def links_random(self, num=None, add=True):
        '''Adds a random links to Nodes in Tree.
        
        num = number of nodes to add links to
            each nodes is selected randomly
            or if none, adds one to each and every node
        
        add = True, adds a link
            = False, deletes link if present per node selection
        '''
        
        #Select Nodes in Tree to effect
        if num:
            node_list = [choice(self.nodes) for _ in range(num)]
        else:
            node_list = self.nodes[:]

        #Adding or deleting a link
        for node in node_list:
            if add:
                node.links.append(choice(self.nodes).num)
            else:
                if len(node.links) >= 1:
                    node.links.remove(choice(node.links))

    def all_node_nums(self):
        '''Returns a list of all node numbers in maze_tree.
        Not a list of nodes, but of node id_nums.'''
        
        return [node.num for node in self.nodes]
        
    
    def links_cycle(self):
        '''Randomly connects all nodes in head to tail fashion.
        So there is a complete graph cycle that connects all nodes.
        
        Does not overwrite existing.'''
        
        nodes = self.all_node_nums()
        shuffle(nodes)
        
        nodes =  nodes
        current = nodes[0]
        while nodes:
            next_node = nodes.pop()
            self.node_by_num(current).links.append(next_node)
            current = next_node
        #print nodes
    
    

if __name__ == '__main__':
    
    print 'nada'