package models.dataFlowModel;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import models.DirectedGraph;
import models.dataConstraintModel.ResourcePath;

public class DataFlowGraph extends DirectedGraph {
	protected Set<ResourceNode> rootResourceNodes = null;
	protected Set<ChannelNode> rootChannelNodes = null;
	protected Map<DataTransferChannel, ChannelNode> channelNodeMap = null;
	protected Map<ResourcePath, ResourceNode> resourceNodeMap = null;
	
	public DataFlowGraph() {
		super();
		rootResourceNodes = new HashSet<>();
		rootChannelNodes = new HashSet<>();
		channelNodeMap = new HashMap<>();
		resourceNodeMap = new HashMap<>();
	}
	
	public ResourceNode addResourceNode(ResourceNode parent, 			
										DataTransferChannel outSideChannel, 
										ResourcePath outSideResource) {
		ResourceNode node = resourceNodeMap.get(outSideResource);
		if (node != null) return node;
		node = new ResourceNode(parent, outSideChannel, outSideResource);
		addNode(node);
		if (parent == null) {
			rootResourceNodes.add(node);
		} else {
			parent.addChild(node);
		}
		resourceNodeMap.put(outSideResource, node);
		return node;
	}
	
	public ResourceNode addResourceNode(ResourceNode parent, 			
										Map<DataTransferChannel, ResourcePath> inSide, 
										Map.Entry<DataTransferChannel, ResourcePath> outSide) {
		ResourceNode node = resourceNodeMap.get(outSide.getValue());
		if (node != null) return node;
		node = new ResourceNode(parent, inSide, outSide);
		addNode(node);
		if (parent == null) {
			rootResourceNodes.add(node);
		} else {
			parent.addChild(node);
		}
		resourceNodeMap.put(outSide.getValue(), node);
		return node;
	}
		
	public ChannelNode addChannelNode(ChannelNode parent, DataTransferChannel ch) {
		ChannelNode node = channelNodeMap.get(ch);
		if (node != null) return node;
		node = new ChannelNode(parent, ch);
		addNode(node);
		if (parent == null) {
			rootChannelNodes.add(node);
		} else {
			parent.addChild(node);
		}
		channelNodeMap.put(ch, node);
		return node;
	}
	
	public ResourceNode getResourceNode(ResourcePath outSide) {
		return resourceNodeMap.get(outSide);
	}
	
	public ChannelNode getChannelNode(DataTransferChannel channel) {
		return channelNodeMap.get(channel);
	}
	
	public Collection<ResourceNode> getResourceNodes() {
		return resourceNodeMap.values();
	}
	
	public Collection<ChannelNode> getChannelNodes() {
		return channelNodeMap.values();
	}

	public Set<ResourceNode> getRootResourceNodes() {
		return rootResourceNodes;
	}

	public Set<ChannelNode> getRootChannelNodes() {
		return rootChannelNodes;
	}

	public DataFlowEdge addEdge(ResourceNode srcNode, ChannelNode dstNode) {
		DataFlowEdge edge =new DataFlowEdge(srcNode, dstNode);
		addEdge(edge);
		return edge;
	}

	public DataFlowEdge addEdge(ChannelNode srcNode, ResourceNode dstNode) {
		DataFlowEdge edge = new DataFlowEdge(srcNode, dstNode);
		addEdge(edge);
		return edge;
	}
}