import networks as nx

G=nx.Graph()#Original graph
color=nx.get_edge_attributes(G,'color')#Original graph color dictionary
#color[(vertex1,vertex2)]

Module = nx.Graph(ModuleType="0")
#MD.add_node(Module)
#Module.graph
#{'ModuleType': '0'}
#Module.graph['ModuleType']='1'

def Insert(Module, NewNode, ModuleType):
	if ModuleType == 0:#Complete
		if Agree(NewNode,Module):
			Module.add_node(NewNode)
			for node in Module.nodes():
				Module.add_edge(node, NewNode)
			#MD=Module
		elif SameColor(NewNode,Module):#NewNode does not distinguish the elements of the module
			NewModule = nx.Graph(ModuleType="0")#ModuleType = Complete
			NewModule.add_node(NewNode)
			NewModule.add_node(Module)
			Nodes = Module.nodes()
			NewModule.add_edge(Module,NewNode,,color[(Nodes[0],NewNode)])
			#MD=NewModule
		else:#NewNode distinguishes the elements of the module
			if len(SomeAgreeColors)=!0:#Some edges have internalcolor
				NewModuleSameEdges = nx.Graph()#ModuleType = Complete
				NewModuleSameEdges.add_nodes(SomeAgreeColors)
				NewModuleSameEdges.add_edges()
				Module.remove_nodes_from(SomeAgreeColors)
				#Module.remove_edges_from()
				m = Insert(Module,NewNode,0)#0 Module is complete
				NewModule = nx.Graph()#ModuleType = Complete
				NewModule.add_node(NewModuleSameEdges)
				NewModule.add_node(m)
				NewModule.add_edge(m,NewModuleSameEdges,color[(SameAgreeColors[0],NewNode)])
				#MD=NewModule
			else:
				Module.add_node(NewNode)
				CND=ColorsNotDefined(Node,Module)
				for node in Module.nodes():
					if node not in CND[1]:
						Module.add_edge(node,NewNode,color[(node,NewNode)])
					else:
						FindColor(NewNode,node)#****lista de nodos con su respectivo color hacia NewNode*****
	else: #Primitive
		if SameColor(NewNode,Module):
			NewModule = nx.Graph(ModuleType="0")#ModuleType = Complete
			NewModule.add_node(NewNode)
			NewModule.add_node(Module)
			Nodes = Module.nodes()
			NewModule.add_edge(Module,NewNode,,color[(Nodes[0],NewNode)])
			#MD=NewModule
		else:
			CND=ColorsNotDefined(NewNode,Module)
			if  not CND[0]:#All color nodes are defined
				MW = ModuleWith(NewNode,Module)
				if MW[0]:#Hace clan con uno
					Module.remove_node(MW[1])
					m = Insert(MW[1],NewNode,)#tipo de MW[1]
					Module.add_node(m)
					for node in Module.nodes():
						Module.add_edge(node,m,color[(node,NewNode)])
				else:#no hay nodo con el que haga clan
					Module.add_node(NewNode)
					for node in Module.nodes():
						Module.add_edge(node,NewNode,color[(node,NewNode)])
			else:
				if len(CND[1])==1:
					MW = ModuleWith(NewNode,CND[1])
					if MW[0]:#Hace clan con este
						Module.remove_node(MW[1])#tipo de MW[1]
						m = Insert(MW[1],NewNode,)
						Module.add_node(m)
						for node in Module.nodes():
							Module.add_edge(node,m,color[(node,NewNode)])
					else:#Sino es clan con el no definido, no es clan de ninguno.
						Module.add_node(NewNode)
						for node in Module.nodes():
							if node not in MW[1] :
								Module.add_edge(node,NewNode,color[(node,NewNode)])
							else:
								FindColor(NewNode,node)#lista de nodos con su respectivo color hacia NewNode
				else:
					Module.add_node(NewNode)
					for node in Module.nodes():
						if node not in CND[1]:
							Module.add_edge(node,NewNode,color[(node,NewNode)])
						else:
							FindColor(NewNode,node)#lista de nodos con su respectivo color hacia NewNode



def Agree(Node,Module): #el nuevo nodo no distingue a los elementos de Module y comparten color con Module, incluye el tener un solo nodo, y dos
	AreAgree = False
	Nodes = Module.nodes()
	if len(Nodes)<2:
		AreAgree = True
	elif SameColor(Node, Module) and color[(Node,Nodes[0])] == color[(Nodes[0],Nodes[1])]:
		AreAgree True
	return AreAgree

def SameColor(Node, Module): #el nuevo nodo no distingue a los elementos de Module
	Nodes= Module.nodes()
	InitialColor=color[(Node,Nodes[0])]
	SColor=True
	i=0
	while i< len(Nodes) and SColor:
		if InitialColor!= color[(Nodes[i],Node)]:
			 SColor=False
		else:
			i+=1
	return SColor

def ModuleWith(Node,Module): #SomeNode puede ser un modulo
	Nodes=Module.nodes()
	i=0
	ModuleFound= False

	while not ModuleFound and i<len(Module):
		ActNode = Nodes[i]
		same=True
		j=0
		while same==True and j <len(Nodes):
			if i!=j:
				if color[(Nodes[j],Nodes[i])]==color[(Nodes[j],Node)]:
					j+=1
				else:
					same = False
			else:
				j+=1
		if same==False:
			i+=1
		elif j == len(Nodes):
			ModuleFound=True
	return ModuleFound, Nodes[i] #True/False,SomeNode

def SomeAgreeColors(NewNode,Module):
	NodesWithAgreeColors=[]
	return NodesWithAgreeColors

def ColorsNotDefined(NewNode,Module): #True if there are colors not defined, False if there are not, Also returns a list of nodes that have not edge defined color
	NotSeen=[]
	if NewNode:
		return True,NotSeen
	else:

		return False,NotSeen

def ReturnColors(NewNode,SubModule):