package schedframe;

import gridsim.GridSim;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import schedframe.exceptions.ResourceException;
import schedframe.resources.ResourceHistoryItem;
import schedframe.resources.computing.ComputingResource;
import schedframe.scheduling.Scheduler;

public class SimulatedEnvironment {

	protected static Scheduler scheduler;
	protected static List<ComputingResource> computingResources;
	protected List<Initializable> toInit;
	protected Set<String> compResLayers;
	protected static List<ResourceHistoryItem> compResHistory = new ArrayList<ResourceHistoryItem>();
	
	public SimulatedEnvironment(Scheduler logicalStructure, List<ComputingResource> compResources){
		scheduler = logicalStructure;
		computingResources = compResources;
	}

	public Scheduler getScheduler() {
		return scheduler;
	}

	public List<ComputingResource> getComputingResources() {
		return computingResources;
	}

	public static ComputingResource getComputingResourceByName(String resourceName) throws ResourceException {
		ComputingResource resourceWithName = null;
		for (int i = 0; i < computingResources.size() && resourceWithName == null; i++) {
			ComputingResource resource = computingResources.get(i);
			if (resource.getFullName().equals(resourceName))
				resourceWithName = resource;
			else
				resourceWithName = resource.getDescendantByName(resourceName);
		}
		return resourceWithName;
	}

	private static Scheduler getSchedulerByName(String schedulerName) {
		Scheduler schedulerWithName = null;

		if (scheduler.getName().compareTo(schedulerName) == 0)
			schedulerWithName = scheduler;
		else if (scheduler.getChildren() != null) {
			LinkedList<Scheduler> toExamine = new LinkedList<Scheduler>();
			toExamine.push(scheduler);

			while (!toExamine.isEmpty() && schedulerWithName != null) {
				Scheduler scheduler = toExamine.pop();
				List<Scheduler> schedulers = scheduler.getChildren();

				int numberOfSched = schedulers.size();
				for (int i = 0; i < numberOfSched; i++) {
					Scheduler schedulerChild = schedulers.get(i);
					if(scheduler.getName().equals(schedulerName)){
						schedulerWithName = schedulerChild;
						break;
					} else
						toExamine.addLast(schedulerChild);
				}
			}
		}
		return schedulerWithName;
	}
	
	public static Scheduler getScheduler(String resName){
		if(GridSim.getEntityId(resName) != -1){
			return getSchedulerByName(resName);
		}
		ComputingResource resourceWithName = null;
		try {
			resourceWithName = getComputingResourceByName(resName);
		} catch (ResourceException e) {
		}
		/*for(int i = 0 ; i < computingResources.size() && resourceWithName == null; i++){
			ComputingResource resource = computingResources.get(i);
			if(resource.getName().equals(resName))
				resourceWithName = resource;
			else
				try {
					resourceWithName = resource.getDescendantByName(resName);
				} catch (ResourceException e) {
					return null;
				}
		}*/
		if(resourceWithName == null)
			return null;
		List<ComputingResource> children = resourceWithName.getChildren();
		Set<Scheduler> childrenSchedulers = new HashSet<Scheduler>();
		if(children.isEmpty())
			return null;
		for(ComputingResource child: children) {
			childrenSchedulers.add(child.getScheduler());
		}	

		Set<Scheduler> tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
		while(childrenSchedulers.size() > 1){
			childrenSchedulers = new HashSet<Scheduler>();
			for(Scheduler s: tempChildrenSchedulers){
				childrenSchedulers.add(s.getParent());
			}
			tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
		}
		Iterator<Scheduler> it = childrenSchedulers.iterator();
		Scheduler potentialScheduler = it.next();
		if(potentialScheduler.getCompResources().containsAll(children))
			return potentialScheduler;
		return null;
	}
	
	public static ComputingResource getCommonComputingResourceParent(List<ComputingResource> compResources){
		if(compResources.size() == 0)
			return null;
		Set<ComputingResource> candidates = new HashSet<ComputingResource>(compResources);
		while(candidates.size() > 1){
			Set<ComputingResource> parents = new HashSet<ComputingResource>();
			Iterator<ComputingResource> it = candidates.iterator();
			while(it.hasNext()){
				ComputingResource compRes = it.next();
				if(compRes.getParent() != null){
					parents.add(compRes.getParent());
				}
				it.remove();
			}
			candidates.addAll(parents);
		}
		return candidates.toArray(new ComputingResource[0])[0];
	}

	public void setInitList(List<Initializable> toI) {
		toInit = toI;
	}

	public List<Initializable> getToInit() {
		return toInit;
	}

	public Set<String> getComputingResourceLayers() {
		return compResLayers;
	}

	public void setCompResLayers(Set<String> compResLayers) {
		this.compResLayers = compResLayers;
	}

	public static void traceResource(long timestamp, String resourceName, String operation, String paramter){
		ResourceHistoryItem rhc = new ResourceHistoryItem(timestamp, resourceName, operation, paramter);
		compResHistory.add(rhc);
	}

	public static List<ResourceHistoryItem> getCompResHistory() {
		return compResHistory;
	}
}