package test;

import gridsim.GridSimCore;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;

import schedframe.ResourceController;
import schedframe.events.ResourceEventCommand;
import schedframe.events.scheduling.EventReason;
import schedframe.exceptions.ModuleException;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.profiles.energy.EnergyEvent;
import schedframe.resources.computing.profiles.energy.EnergyEventType;
import schedframe.scheduling.Scheduler;
import schedframe.scheduling.plugin.grid.Module;
import schedframe.scheduling.plugin.grid.ModuleType;

public class EventManager extends GridSimCore implements Module{

	protected ResourceController resourceController;
	
	public EventManager(String name) throws Exception {
		super(name, 1);
	}

	public void send(String entityName, double delay, int tag, Object data){
		super.send(entityName, delay, tag, data);
	}
	
	public void send(int destId, double delay, int tag){
		super.send(destId, delay, tag);
	}
	
	public void send(int destId, double delay, int tag, Object data){
		super.send(destId, delay, tag, data);
	}
	
	public void init(Properties properties) throws ModuleException {
	}

	public void sendToAllSchedulers(double delay, int tag, Object data){
		List<Scheduler> allSchedulers =  new ArrayList<Scheduler>();
		if (resourceController.getScheduler().getChildren() != null) {
			LinkedList<Scheduler> toExamine = new LinkedList<Scheduler>();
			toExamine.push(resourceController.getScheduler());
			allSchedulers.add(resourceController.getScheduler());

			while (!toExamine.isEmpty()) {
				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);
					toExamine.addLast(schedulerChild);
					allSchedulers.add(schedulerChild);
				}
			}
		}
		
		for(Scheduler scheduler: allSchedulers){
			super.send(scheduler.get_id(), delay, tag, data);
		}
	}
	
	public void sendToAllResources(double delay, int tag, Object data){
		List<ComputingResource> allComputingResources = new ArrayList<ComputingResource>();

		if (resourceController.getComputingResources() != null) {
			LinkedList<ComputingResource> toExamine = new LinkedList<ComputingResource>();
			for(ComputingResource compRes: resourceController.getComputingResources()){
				toExamine.push(compRes);
				allComputingResources.add(compRes);
			}

			while (!toExamine.isEmpty()) {
				ComputingResource resource = toExamine.pop();
				List<ComputingResource> resources = resource.getChildren();
				int numberOfRes = resources.size();
				for (int i = 0; i < numberOfRes; i++) {
					ComputingResource resourceChild = resources.get(i);
					toExamine.addLast(resourceChild);
					allComputingResources.add(resourceChild);
				}
			}
		}
		
		ResourceEventCommand rec;
		EnergyEvent event;
		for(ComputingResource compRes: allComputingResources){
			rec = new ResourceEventCommand(compRes);
			event = new EnergyEvent(EnergyEventType.AIRFLOW_STATE_CHANGED, "Resource controller");
			event.setReason(EventReason.SIM_INIT);
			rec.execute(event);
			//super.send(scheduler.get_id(), delay, tag, data);
		}

	}
	
	public void sendTo(List<String> ids){
		
	}
	
	public void dispose() throws ModuleException {
	}

	public ModuleType getType() {
		return ModuleType.EVENT_MANAGER;
	}

}