package es.tid.tedb;

import java.net.Inet4Address;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.jgrapht.graph.SimpleDirectedWeightedGraph;

import es.tid.of.DataPathID;
import es.tid.ospf.ospfv2.lsa.tlv.subtlv.complexFields.BitmapLabelSet;

/**
 * Traffic Engineering Database of a Domain.
 * 
 * 
 * @author ogondio, mcs, b.mvas
 *
 */
public class SimpleTEDB implements DomainTEDB{
	
	private Inet4Address domainID;
	
	private IT_Resources itResources;

	/**
	 * List of algorithms that will be notified when there are significant changes in the TED
	 */
	private ArrayList<TEDListener> registeredAlgorithms;
	/**
	 * List of algorithms SSON that will be notified when there are significant changes in the TED
	 */
	private ArrayList<SSONListener> registeredAlgorithmssson;
	/**
	 * Graph of the Network
	 */
	private SimpleDirectedWeightedGraph<Object,IntraDomainEdge> networkGraph;

	/**
	 * List of interdomain Links
	 */
	private LinkedList<InterDomainEdge> interDomainLinks = new LinkedList<InterDomainEdge>(); 

	/*
	 * List of Intradomain Edges
	 * Please, It's not the same as intraDomainLinks
	 * This has been created to support multiedges between two nodes
	 */
	private LinkedList<IntraDomainEdge> intraDomainEdges = new LinkedList<IntraDomainEdge>(); 


	/**
	 * Reachability information
	 */
	private ReachabilityEntry reachabilityEntry;
	/**
	 * Information about the labels in a WSON network.
	 */
	private WSONInformation WSONinfo=null;
	/**
	 * Information about the labels in a SSON network.
	 */
	private SSONInformation SSONinfo=null;

	private Lock TEDBlock;

	private Hashtable<Object , Node_Info> NodeTable;

	private boolean multidomain=false;//By default, the TED has only one domain
	Logger log;
	public SimpleTEDB(){
		log=LoggerFactory.getLogger("TEDBParser");		
		registeredAlgorithms= new ArrayList<TEDListener>();
		registeredAlgorithmssson= new ArrayList<SSONListener>();
		TEDBlock=new ReentrantLock();
		NodeTable = new Hashtable<Object, Node_Info>();
	}

	public SimpleDirectedWeightedGraph<Object,IntraDomainEdge> getDuplicatedNetworkGraph(){
		SimpleDirectedWeightedGraph<Object,IntraDomainEdge> graphCopy;
		TEDBlock.lock();
		try{
			graphCopy= (SimpleDirectedWeightedGraph<Object, IntraDomainEdge>) networkGraph.clone();
		} finally{
			TEDBlock.unlock();
		}
		return graphCopy;
	}
	public void createGraph(){
		networkGraph = new SimpleDirectedWeightedGraph<Object, IntraDomainEdge>(IntraDomainEdge.class);
		reachabilityEntry = new ReachabilityEntry();
	}

	public void initializeFromFile(String file){
		initializeFromFile(file, null, false,0,Integer.MAX_VALUE, false,false);
	}
	public void initializeFromFile(String file, String layer){
		initializeFromFile(file, layer, false,0,Integer.MAX_VALUE, false,false);
	}
	public void initializeFromFile(String file, String layer, boolean multidomain){
		initializeFromFile(file, layer, multidomain,0,Integer.MAX_VALUE, false,false);
	}
	public void initializeFromFile(String file, String layer, boolean multidomain, boolean isSSON){
		initializeFromFile(file, layer, multidomain,0,Integer.MAX_VALUE, isSSON,false);
	}
	public void initializeFromFile(String file, String layer, boolean multidomain,int lambdaIni, int lambdaEnd){
		initializeFromFile(file, layer, multidomain,0,Integer.MAX_VALUE, false,false);
	}
	public void initializeFromFile(String file, String layer, boolean multidomain, int lambdaIni, int lambdaEnd, boolean isSSON,boolean readOnlyInterDomainLinks){	
		initializeFromFile( file,  layer,  multidomain,  lambdaIni,  lambdaEnd,  isSSON, readOnlyInterDomainLinks, false);
	}

	public void initializeFromFile(String file, String layer, boolean multidomain, int lambdaIni, int lambdaEnd, boolean isSSON,boolean readOnlyInterDomainLinks, boolean isWLAN){
		domainID=FileTEDBUpdater.getDomainIDfromSimpleDomain(file);
		if (readOnlyInterDomainLinks){
			log.info("Read Only Inter Domain Links");
			networkGraph = new SimpleDirectedWeightedGraph<Object, IntraDomainEdge>(IntraDomainEdge.class);
			if (!multidomain){
				interDomainLinks = FileTEDBUpdater.readInterDomainLinks(file);	
			}
			reachabilityEntry = new ReachabilityEntry();
			if (!multidomain){
				FileTEDBUpdater.getDomainReachabilityFromFile(file,reachabilityEntry);
			}
			if((isSSON==true)&(!isWLAN)){
				SSONinfo = FileTEDBUpdater.getSSONInformation(file);
			}else if (isWLAN)
			{

			}
			else
			{
				WSONinfo = FileTEDBUpdater.getWSONInformation(file);
			}
		}else{
			if((isSSON==true)&&(!isWLAN)){
				networkGraph=FileTEDBUpdater.readNetwork(file,layer, multidomain,lambdaIni,lambdaEnd, isSSON);
				SSONinfo = FileTEDBUpdater.getSSONInformation(file);
			}
			else if (isWLAN)
			{
				networkGraph=FileTEDBUpdater.readNetwork(file,layer, multidomain,lambdaIni,lambdaEnd, isSSON);
			}
			else{
				networkGraph=FileTEDBUpdater.readNetwork(file,layer, multidomain,lambdaIni,lambdaEnd);
				WSONinfo = FileTEDBUpdater.getWSONInformation(file);
			}
			//		if (lambdaEnd!=Integer.MAX_VALUE){
			//			notifyAlgorithms( lambdaIni, lambdaEnd);
			//		}
			Iterator<Object> itervertex=networkGraph.vertexSet().iterator();

			/** Se podrian sacar a una funcion externa ambos 'while'
			 *  Rellenar info table
			 *  Rellenar info edge
			 *  Preguntar a Oscar
			 */
			while (itervertex.hasNext()) {
				Object address = itervertex.next();
				Node_Info ni = new Node_Info();
				if (address instanceof Inet4Address){
					ni.setIpv4AddressLocalNode((Inet4Address)address);
					ni.setIpv4Address((Inet4Address)address);//de momento asumimos que aprendemos ospf					
				} else if (address instanceof DataPathID) {
					ni.setDataPathLocalNode((DataPathID)address); 
				}
				ni.setLearntFrom("Fom XML");
				ni.setAs_number(domainID);
				NodeTable.put(address, ni);	
			}

			Iterator<IntraDomainEdge> iteredge=networkGraph.edgeSet().iterator();
			while (iteredge.hasNext()) {
				IntraDomainEdge id =  (IntraDomainEdge) iteredge.next();
				try{
					Inet4Address ipSource = (Inet4Address) (id.getSource());
					Inet4Address ipDest = (Inet4Address) (id.getTarget());
					id.setLearntFrom("From XML");
					Node_Info origin = new Node_Info();
					Node_Info destination = new Node_Info();
					origin.setIpv4AddressLocalNode(ipSource);
					origin.setAs_number(domainID);
					origin.setLearntFrom("FromXML");
					destination.setIpv4AddressLocalNode(ipDest);
					destination.setAs_number(domainID);
					destination.setLearntFrom("FromXML");
					id.setLocal_Node_Info(origin);
					id.setRemote_Node_Info(destination);
					NodeTable.get(ipSource).setSID(id.getSrc_sid());
					NodeTable.get(ipDest).setSID(id.getDst_sid());
				}catch (Exception e1){
					DataPathID dpSource = (DataPathID) (id.getSource());
					DataPathID dpDest = (DataPathID) (id.getTarget());
					id.setLearntFrom("From XML");
					Node_Info origin = new Node_Info();
					Node_Info destination = new Node_Info();
					origin.setDataPathLocalNode(dpSource);
					origin.setAs_number(domainID);
					origin.setLearntFrom("FromXML");
					destination.setDataPathLocalNode(dpDest);
					destination.setAs_number(domainID);
					destination.setLearntFrom("FromXML");
					id.setLocal_Node_Info(origin);
					id.setRemote_Node_Info(destination);
					//NodeTableDataPath.get(dpSource).setSID(id.getSrc_sid());
					//NodeTableDataPath.get(dpDest).setSID(id.getDst_sid());
				}

			}
		}


		if (!multidomain){
			interDomainLinks = FileTEDBUpdater.readInterDomainLinks(file);	
		}
		else {
			interDomainLinks = new LinkedList<InterDomainEdge>();	
		}
		reachabilityEntry = new ReachabilityEntry();
		if (!multidomain){
			FileTEDBUpdater.getDomainReachabilityFromFile(file,reachabilityEntry);
		}

		Iterator<InterDomainEdge> edgeIt = interDomainLinks.iterator();
		while (edgeIt.hasNext()) {
			InterDomainEdge id =  (InterDomainEdge) edgeIt.next();
			try {
				Inet4Address ipSource = (Inet4Address) (id.src_router_id);
				Inet4Address ipDest = (Inet4Address) (id.dst_router_id);
				id.setLearntFrom("From XML");
				Node_Info origin = new Node_Info();
				Node_Info destination = new Node_Info();
				origin.setIpv4AddressLocalNode(ipSource);
				origin.setAs_number(domainID);
				origin.setLearntFrom("FromXML");
				destination.setIpv4AddressLocalNode(ipDest);
				destination.setAs_number((Inet4Address) id.domain_dst_router);
				destination.setLearntFrom("FromXML");
				id.setLocal_Node_Info(origin);
				id.setRemote_Node_Info(destination);
			} catch (Exception e) {
				DataPathID dpSource = (DataPathID) (id.src_router_id);
				DataPathID dpDest = (DataPathID) (id.dst_router_id);
				id.setLearntFrom("From XML");
				Node_Info origin = new Node_Info();
				Node_Info destination = new Node_Info();
				origin.setDataPathLocalNode(dpSource);
				origin.setAs_number(domainID);
				origin.setLearntFrom("FromXML");
				destination.setDataPathLocalNode(dpDest);
				destination.setAs_number((Inet4Address) id.domain_dst_router);
				destination.setLearntFrom("FromXML");
				id.setLocal_Node_Info(origin);
				id.setRemote_Node_Info(destination);
			}
		}

	}	

	public void notifyAlgorithms( int lambdaIni,int lambdaEnd){	
		LinkedList<Object>  ipListScr = new  LinkedList<Object> ();
		LinkedList<Object>  ipListDst = new  LinkedList<Object> ();
		Set<IntraDomainEdge> it =this.networkGraph.edgeSet();
		int numLabels=0;
		for (IntraDomainEdge edge:it){	
			numLabels=edge.TE_info.getAvailableLabels().getLabelSet().getNumLabels();
			for (int i=0;i<lambdaIni;i++){		
				ipListScr.add(edge.getSource());
				ipListDst.add(edge.getTarget());
				for (int j=0;j<registeredAlgorithms.size();++j){
					registeredAlgorithms.get(j).notifyWavelengthReservation(ipListScr, ipListDst, i);
				}
				for (int j=0;j<registeredAlgorithmssson.size();++j){
					registeredAlgorithmssson.get(j).notifyWavelengthReservation(ipListScr, ipListDst, i);
				}
				this.notifyWavelengthReservation(ipListScr,ipListDst,i,false);
				ipListScr.remove();
				ipListDst.remove();
			}

			for (int i=lambdaEnd;i<numLabels;i++){				
				ipListScr.add(edge.getSource());
				ipListDst.add(edge.getTarget());
				for (int j=0;j<registeredAlgorithms.size();++j){
					registeredAlgorithms.get(j).notifyWavelengthReservation(ipListScr, ipListDst, i);
				}
				for (int j=0;j<registeredAlgorithmssson.size();++j){
					registeredAlgorithmssson.get(j).notifyWavelengthReservation(ipListScr, ipListDst, i);
				}
				this.notifyWavelengthReservation(ipListScr,ipListDst,i,false);
				ipListScr.remove();
				ipListDst.remove();
			}
		}
	}
	public boolean belongsToDomain(Object addr){
		int i;
		byte[] addrbytes=((Inet4Address)addr).getAddress();
		//log.info("Entramos en belong to domain: "+ reachabilityEntry.getMask());
		//UtilsFunctions.printByte(reachabilityEntry.getMask(), "Entramos en belong to domain: ", log);
		for (i=0;i<4;++i){
			addrbytes[i]=(byte) (addrbytes[i]&(reachabilityEntry.getMask())[i]);
		}
		//UtilsFunctions.printByte(addrbytes, "addrbytes", log);
		//UtilsFunctions.printByte(reachabilityEntry.getAggregatedIPRange().getAddress(), "reachabilityEntry.getAggregatedIPRange", log);
		//log.info("addrbytes "+addrbytes+" reachabilityEntry.getAggregatedIPRange().getAddress()"+reachabilityEntry.getAggregatedIPRange().getAddress());
		log.info("Belongs to domain retunrs: "+Arrays.equals(addrbytes,reachabilityEntry.getAggregatedIPRange().getAddress()));
		return Arrays.equals(addrbytes,reachabilityEntry.getAggregatedIPRange().getAddress());

	}


	public LinkedList<IntraDomainEdge> getIntraDomainEdges() {
		return intraDomainEdges;
	}

	public void setIntraDomainEdges(LinkedList<IntraDomainEdge> intraDomainEdges) {
		this.intraDomainEdges = intraDomainEdges;
	}

	public ReachabilityEntry getReachabilityEntry() {
		return reachabilityEntry;
	}

	public void setReachabilityEntry(ReachabilityEntry reachabilityEntry) {
		this.reachabilityEntry = reachabilityEntry;
	}

	public SimpleDirectedWeightedGraph<Object, IntraDomainEdge> getNetworkGraph() {
		return networkGraph;
	}

	public void setNetworkGraph(
			SimpleDirectedWeightedGraph<Object, IntraDomainEdge> networkGraph) {
		this.networkGraph = networkGraph;
	}

	public LinkedList<InterDomainEdge> getInterDomainLinks() {
		return interDomainLinks;
	}
	public void setInterDomainLinks(LinkedList<InterDomainEdge> interDomainLinks) {
		this.interDomainLinks = interDomainLinks;
	}
	
	/**
	 * Return true if scr and dst are linked by an InterDomainLink
	 * @param src Source 
	 * @param dst Destination
	 * @return  true if scr and dst are linked by an InterDomainLink
	 */
	public InterDomainEdge getInterdomainLink(Object src, Object dst){

		int size = interDomainLinks.size();
		InterDomainEdge edge= new InterDomainEdge(src,dst);
		for (int i=0;i<size;i++){    		
			//por pantalla  
			InterDomainEdge edge_i = interDomainLinks.get(i);
			if (edge_i.equals(edge)){
				return edge_i;
			}
		}
		return null;
	}

	public String printTopology(){
		String topoString;
		Set<Object> vetexSet= networkGraph.vertexSet();
		Iterator <Object> vertexIterator=vetexSet.iterator();
		topoString="Nodes: \r\n";
		while (vertexIterator.hasNext()){
			Object vertex= vertexIterator.next();
			topoString=topoString+"\t"+vertex.toString()+"\r\n";
		}
		topoString=topoString+"Node Information Table::: \r\n"+NodeTable.toString()+"\r\n";
		Set<IntraDomainEdge> edgeSet= networkGraph.edgeSet();
		if (edgeSet != null){
			Iterator <IntraDomainEdge> edgeIterator=edgeSet.iterator();
			topoString=topoString+"Intradomain Link list: \r\n";
			while (edgeIterator.hasNext()){
				IntraDomainEdge edge= edgeIterator.next();
				topoString=topoString+"\t"+edge.toString()+"\n";
			}
		}
		if (interDomainLinks != null)
			topoString=topoString+printInterDomainLinks();
		return topoString;
	}

	public String printInterDomainLinks(){
		String topoString="";

		int size = interDomainLinks.size();
		log.info("Size of InterDomainLinks: "+size);
		topoString="Interdomain Link list: \r\n";
		for (int i=0;i<size;i++){
			//por pantalla  
			InterDomainEdge edge = interDomainLinks.get(i);
			topoString=topoString+"\t"+edge.toString()+"\r\n";
		}
		return topoString;
	}

	@Override
	public boolean isITtedb() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void notifyWavelengthReservationWLAN(LinkedList<Object> sourceVertexList,LinkedList<Object> targetVertexList,LinkedList<Integer> wlans, boolean bidirectional) 
	{
		TEDBlock.lock();
		try {
			for (int i=0;i<sourceVertexList.size();++i){		
				IntraDomainEdge edge=networkGraph.getEdge(sourceVertexList.get(i), targetVertexList.get(i));
				edge.getTE_info().setWavelengthReserved(wlans.get(i));
				log.info("Reservo: "+sourceVertexList.get(i).toString() + "-"+ targetVertexList.get(i).toString() +" wavelength: "+wlans.get(i)+" bidirectional"+bidirectional);
				if (bidirectional == true){
					edge=networkGraph.getEdge(targetVertexList.get(i), sourceVertexList.get(i));
					edge.getTE_info().setWavelengthReserved(wlans.get(i));
					//log.info(""+edge.toString());
				}
			}
		}finally{
			TEDBlock.unlock();
		}
		for (int i=0;i<registeredAlgorithms.size();++i){
			registeredAlgorithms.get(i).notifyWavelengthReservation(sourceVertexList, targetVertexList, wlans.get(i));
			if (bidirectional == true){
				registeredAlgorithms.get(i).notifyWavelengthReservation(targetVertexList, sourceVertexList, wlans.get(i));
			}
		}

	}

	@Override
	public void notifyWavelengthReservation(LinkedList<Object> sourceVertexList, LinkedList<Object> targetVertexList, int wavelength, boolean bidirectional){
		TEDBlock.lock();
		try {
			for (int i=0;i<sourceVertexList.size();++i){		
				IntraDomainEdge edge=networkGraph.getEdge(sourceVertexList.get(i), targetVertexList.get(i));
				edge.getTE_info().setWavelengthReserved(wavelength);
				log.info("Reservo: "+sourceVertexList.get(i).toString() + "-"+ targetVertexList.get(i).toString() +" wavelength: "+wavelength+" bidirectional"+bidirectional);
				if (bidirectional == true){
					edge=networkGraph.getEdge(targetVertexList.get(i), sourceVertexList.get(i));
					edge.getTE_info().setWavelengthReserved(wavelength);
					//log.info(""+edge.toString());
				}
			}
		}finally{
			TEDBlock.unlock();
		}
		for (int i=0;i<registeredAlgorithms.size();++i){
			registeredAlgorithms.get(i).notifyWavelengthReservation(sourceVertexList, targetVertexList, wavelength);
			if (bidirectional == true){
				registeredAlgorithms.get(i).notifyWavelengthReservation(targetVertexList, sourceVertexList, wavelength);
			}
		}
	}

	public void notifyWavelengthReservationSSON(LinkedList<Object> sourceVertexList, LinkedList<Object> targetVertexList, int wavelength, boolean bidirectional, int m){
		TEDBlock.lock();
		try {
			for (int j=0;j<2*m;j++){
				for (int i=0;i<sourceVertexList.size();++i){		
					IntraDomainEdge edge=networkGraph.getEdge(sourceVertexList.get(i), targetVertexList.get(i));
					//log.info("sourceVertexList.size()"+sourceVertexList.size());
					edge.getTE_info().setWavelengthReserved(wavelength-m+j);
					//log.info("Reserving in TEDB: "+edge.toString());
					if (bidirectional == true){
						edge=networkGraph.getEdge(targetVertexList.get(i), sourceVertexList.get(i));
						edge.getTE_info().setWavelengthReserved(wavelength-m+j);
						//log.info("Reserving in TEDB: "+edge.toString());
					}
				}
			}
		}finally{
			TEDBlock.unlock();
		}
		for (int i=0;i<registeredAlgorithmssson.size();++i){
			(registeredAlgorithmssson.get(i)).notifyWavelengthReservationSSON(sourceVertexList, targetVertexList, wavelength, m);
			if (bidirectional == true){
				(registeredAlgorithmssson.get(i)).notifyWavelengthReservationSSON(targetVertexList, sourceVertexList, wavelength, m);
			}
		}
	}

	@Override
	public void notifyWavelengthEndReservationSSON(LinkedList<Object> sourceVertexList, LinkedList<Object> targetVertexList, int wavelength, boolean bidirectional, int m){
		// TODO Auto-generated method stub
		//Delete the resource reservation
		TEDBlock.lock();
		try {
			for (int j=0;j<2*m;j++){
				for (int i=0;i<sourceVertexList.size();++i){
					//			SimpleDirectedWeightedGraph<Object,FiberLinkEdge> graph= ted.getNetworkGraph();
					IntraDomainEdge edge=networkGraph.getEdge(sourceVertexList.get(i),targetVertexList.get(i) );
					edge.getTE_info().setWavelengthUnReserved(wavelength-m+j);
					//log.info("Derreserving in TEDB: "+edge.toString());
					if (bidirectional == true)
					{
						edge=networkGraph.getEdge(targetVertexList.get(i), sourceVertexList.get(i));
						edge.getTE_info().setWavelengthUnReserved(wavelength-m+j);
						//log.info("Derreserving in TEDB: "+edge.toString());
					}
				}
			}
		}finally{
			TEDBlock.unlock();
		}
		for (int i=0;i<registeredAlgorithmssson.size();++i){
			(registeredAlgorithmssson.get(i)).notifyWavelengthEndReservationSSON(sourceVertexList, targetVertexList, wavelength, m);
			if (bidirectional == true){
				(registeredAlgorithmssson.get(i)).notifyWavelengthEndReservationSSON(targetVertexList, sourceVertexList, wavelength, m);
			}
		}
		//FIXME:TEMPORAL!!!!!!
		//requestDispatcher.moveRetryQueueToComputingRequestQueue();
		//Call request dispatcher to pass requests to queue?
	}

	@Override
	public void notifyWavelengthEndReservation(LinkedList<Object> sourceVertexList, LinkedList<Object> targetVertexList, int wavelength, boolean bidirectional){
		// TODO Auto-generated method stub
		//Delete the resource reservation
		TEDBlock.lock();
		try {
			for (int i=0;i<sourceVertexList.size();++i){
				//			SimpleDirectedWeightedGraph<Object,FiberLinkEdge> graph= ted.getNetworkGraph();
				IntraDomainEdge edge=networkGraph.getEdge(sourceVertexList.get(i),targetVertexList.get(i) );
				edge.getTE_info().setWavelengthUnReserved(wavelength);
				//log.info(""+edge.toString());
				if (bidirectional == true)
				{
					edge=networkGraph.getEdge(targetVertexList.get(i), sourceVertexList.get(i));
					edge.getTE_info().setWavelengthUnReserved(wavelength);
					//log.info(""+edge.toString());
				}
			}
		}finally{
			TEDBlock.unlock();
		}
		for (int i=0;i<registeredAlgorithms.size();++i){
			registeredAlgorithms.get(i).notifyWavelengthEndReservation(sourceVertexList, targetVertexList, wavelength);
			if (bidirectional == true){
				registeredAlgorithms.get(i).notifyWavelengthEndReservation(targetVertexList, sourceVertexList, wavelength);
			}
		}
		//FIXME:TEMPORAL!!!!!!
		//requestDispatcher.moveRetryQueueToComputingRequestQueue();
		//Call request dispatcher to pass requests to queue?
	}

	@Override
	public boolean containsVertex(Object vertex) {
		return networkGraph.containsVertex(vertex);
	}

	public Hashtable<Object, Node_Info> getNodeTable() {
		return NodeTable;
	}

	public void setNodeTable(Hashtable<Object, Node_Info> nodeTable) {
		NodeTable = nodeTable;
	}

	public boolean isMultidomain() {
		return multidomain;
	}

	public void setMultidomain(boolean multidomain) {
		this.multidomain = multidomain;
	}

	public void registerSSON (SSONListener algo){
		registeredAlgorithmssson.add(algo);		
	}

	public void register (TEDListener algo){
		registeredAlgorithms.add(algo);		
	}

	@Override
	public void notifyWavelengthChange(Object localInterfaceIPAddress, Object remoteInterfaceIPAddress,	BitmapLabelSet previousBitmapLabelSet, BitmapLabelSet newBitmapLabelSet) {
		for (int i=0;i<registeredAlgorithms.size();++i){
			registeredAlgorithms.get(i).notifyWavelengthStatusChange(localInterfaceIPAddress, remoteInterfaceIPAddress, previousBitmapLabelSet, newBitmapLabelSet);
		}
		if (registeredAlgorithms.isEmpty()){
			for (int i=0;i<registeredAlgorithmssson.size();++i){
				registeredAlgorithmssson.get(i).notifyWavelengthStatusChange(localInterfaceIPAddress, remoteInterfaceIPAddress, previousBitmapLabelSet, newBitmapLabelSet);
			}
		}
	}

	@Override
	public void notifyNewVertex(Object vertex) {
		for (int i=0;i<registeredAlgorithms.size();++i){
			registeredAlgorithms.get(i).notifyNewVertex(vertex);
		}	
		for (int i=0;i<registeredAlgorithmssson.size();++i){
			registeredAlgorithmssson.get(i).notifyNewVertex(vertex);
		}	
	}

	@Override
	public void notifyNewEdge(Object source, Object destination) {
		for (int i=0;i<registeredAlgorithms.size();++i){
			registeredAlgorithms.get(i).notifyNewEdge(source,destination);
		}
		for (int i=0;i<registeredAlgorithmssson.size();++i){
			registeredAlgorithmssson.get(i).notifyNewEdge(source,destination);
		}	
	}

	@Override
	public WSONInformation getWSONinfo() {
		return WSONinfo;
	}

	@Override
	public SSONInformation getSSONinfo() {
		return SSONinfo;
	}

	@Override
	public void clearAllReservations() {
		if (WSONinfo!=null){
			TEDBlock.lock();
			try{	
				Set<IntraDomainEdge> edgeSet= networkGraph.edgeSet();
				Iterator <IntraDomainEdge> edgeIterator=edgeSet.iterator();
				while (edgeIterator.hasNext()){
					IntraDomainEdge edge= edgeIterator.next();
					edge.TE_info.setAllWavelengtshUnReserved();
				}
			}finally{
				TEDBlock.unlock();
			}
			for (int i=0;i<registeredAlgorithms.size();++i){
				registeredAlgorithms.get(i).notifyTEDBFullUpdate();
			}	
		}
	}

	public Lock getTEDBlock() {
		return TEDBlock;
	}

	public void setTEDBlock(Lock tEDBlock) {
		TEDBlock = tEDBlock;
	}

	@Override
	public void notifyNewEdgeIP(Object source, Object destination,
			TE_Information informationTEDB) {
		// TODO Auto-generated method stub
	}

	public void setWSONinfo(WSONInformation wSONinfo) {
		WSONinfo = wSONinfo;
	}

	public void setSSONinfo(SSONInformation sSONinfo) {
		SSONinfo = sSONinfo;
	}

	
	public String printBaseTopology(){
		String topoString;
		Set<Object> vetexSet= networkGraph.vertexSet();
		Iterator <Object> vertexIterator=vetexSet.iterator();
		topoString="NodesFEO: \r\n";
		while (vertexIterator.hasNext()){
			Object vertex= vertexIterator.next();
			topoString=topoString+"\t"+vertex.toString()+"\r\n";
		}
		topoString=topoString+"Intradomain Link list: \r\n";
		Set<IntraDomainEdge> edgeSet= networkGraph.edgeSet();
		Iterator <IntraDomainEdge> edgeIterator=edgeSet.iterator();
		while (edgeIterator.hasNext()){
			IntraDomainEdge edge= edgeIterator.next();
			topoString=topoString+"\t"+edge.toString()+"\r\n";
		}		
		return topoString;
	}

	@Override
	public Inet4Address getDomainID() {
		// TODO Auto-generated method stub
		return domainID;
	}

	public void setDomainID(Inet4Address domainID) {
		this.domainID = domainID;
	}

	@Override
	public Set<IntraDomainEdge> getIntraDomainLinks() {
		return this.getNetworkGraph().edgeSet();
	}
	
	public Set<Object> getIntraDomainLinksvertexSet() {
		return this.getNetworkGraph().vertexSet();
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((domainID == null) ? 0 : domainID.hashCode());
		result = prime * result + ((intraDomainEdges == null) ? 0 : intraDomainEdges.hashCode());
		result = prime * result + ((networkGraph == null) ? 0 : networkGraph.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		SimpleTEDB other = (SimpleTEDB) obj;
		if (intraDomainEdges == null) {
			if (other.intraDomainEdges != null)
				return false;
		} else if (!intraDomainEdges.equals(other.intraDomainEdges))
			return false;
		if (networkGraph == null) {
			if (other.networkGraph != null)
				return false;
		}
		for(Object v : networkGraph.vertexSet()){
			if(!other.networkGraph.containsVertex(v))
				return false;
		}
		
		for(IntraDomainEdge e :networkGraph.edgeSet()){
			boolean flagEqual=false;
			for(IntraDomainEdge otherE : other.networkGraph.edgeSet()){
				if(e.toString().equals(otherE.toString()))flagEqual=true;
			}
			if(flagEqual==false)return false; //edge not present in other
		}
		for(IntraDomainEdge e :other.networkGraph.edgeSet()){
			boolean flagEqual=false;
			for(IntraDomainEdge otherE : networkGraph.edgeSet()){
				if(e.toString().equals(otherE.toString()))flagEqual=true;
			}
			if(flagEqual==false)return false; //edge not present in other
		}
		return true;
	}

	public IT_Resources getItResources() {
		return itResources;
	}

	public void setItResources(IT_Resources itResources) {
		this.itResources = itResources;
	}
	
	
}