package example.localplugin;

import gridsim.Gridlet;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import schedframe.events.scheduling.SchedulingEvent;
import schedframe.resources.ResourceStatus;
import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.ComputingNode;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Processor;
import schedframe.resources.units.Memory;
import schedframe.resources.units.ProcessingElements;
import schedframe.resources.units.ResourceUnit;
import schedframe.resources.units.ResourceUnitName;
import schedframe.resources.units.StandardResourceUnitName;
import schedframe.scheduling.manager.resources.ClusterResourceManager;
import schedframe.scheduling.manager.resources.ResourceManager;
import schedframe.scheduling.manager.tasks.JobRegistry;
import schedframe.scheduling.plan.SchedulingPlanInterface;
import schedframe.scheduling.plan.impl.SchedulingPlan;
import schedframe.scheduling.plugin.grid.ModuleList;
import schedframe.scheduling.queue.TaskQueue;
import schedframe.scheduling.queue.TaskQueueList;
import schedframe.scheduling.tasks.TaskInterface;
import schedframe.scheduling.tasks.WorkloadUnit;

public class FCFSClusterLocalPlugin extends BaseLocalSchedulingPlugin {

	public SchedulingPlanInterface<?> schedule(SchedulingEvent event, TaskQueueList queues, JobRegistry jobRegistry,
			ResourceManager resManager, ModuleList modules) {

		ClusterResourceManager resourceManager = (ClusterResourceManager) resManager;
		SchedulingPlan plan = new SchedulingPlan();
		// chose the events types to serve.
		// Different actions for different events are possible.
		switch (event.getType()) {
		case START_TASK_EXECUTION:
		case TASK_FINISHED:
		//case TIMER:
			// our tasks are placed only in first queue (see BaseLocalPlugin.placeJobsInQueues() method)
			TaskQueue q = queues.get(0);
			// check all tasks in queue

			for (int i = 0; i < q.size(); i++) {
				WorkloadUnit<?> job = q.get(i);
				TaskInterface<?> task = (TaskInterface<?>) job;
				// if status of the tasks in READY
				if (task.getStatus() == Gridlet.READY) {
					
					/****************3 ways to schedule task****************/
					
					/****************1. Choosing particular resources to perform execution****************/
					Map<ResourceUnitName, ResourceUnit> choosenResources = chooseResourcesForExecution2(resourceManager, task);
					if (choosenResources != null) {
						addToSchedulingPlan(plan, task, choosenResources);
					}
					
					/****************2. Choosing resource scheduler/provider to submit task.  If the given resource doesn't contains/isn't 
					a scheduler, random resources from the given resource will be chosen in order to perform execution****************/
					/*String provName = chooseProviderForExecution(resourceManager);
					if (provName != null) {
						addToSchedulingPlan(plan, task, provName);
					}*/

					/****************3. Scheduler will choose random resources to perform execution****************/
					//addToSchedulingPlan(plan, task);
				}
			}

			break;
		}
		return plan;
	}

	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
			ClusterResourceManager resourceManager, TaskInterface<?> task) {

		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();

		int cpuRequest;
		try {
			cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
		} catch (NoSuchFieldException e) {
			cpuRequest = 1;
		}

		if (cpuRequest != 0) {
			List<ComputingResource> choosenResources = null;
			List<Processor> processors = null;
			processors = resourceManager.getProcessors();
			if (processors.size() < cpuRequest) {
				// log.warn("Task requires more cpus than is availiable in this resource.");
				return null;
			}

			choosenResources = new ArrayList<ComputingResource>();

			for (int i = 0; i < processors.size() && cpuRequest > 0; i++) {
				if (processors.get(i).getStatus() == ResourceStatus.FREE) {
					choosenResources.add(processors.get(i));
					cpuRequest--;
				}
			}
			if (cpuRequest > 0) {
				// log.info("Task " + task.getJobId() + "_" + task.getId() +
				// " requires more cpus than is availiable in this moment.");
				return null;
			}

			ProcessingElements result = new ProcessingElements(processors.get(0).getParent().getName());
			result.addAll(choosenResources);
			map.put(StandardResourceUnitName.PE, result);

		}
		int memoryRequest;
		try {
			memoryRequest = Double.valueOf(task.getMemoryRequest()).intValue();
		} catch (NoSuchFieldException e) {
			memoryRequest = 0;
		}
		if (memoryRequest != 0) {
			List<ComputingNode> nodes = resourceManager.getComputingNodes();

			Memory memory = null;
			for (ComputingNode node : nodes) {
				try{
					if (node.getFreeMemory() >= memoryRequest) {		
						memory = new Memory(node.getMemory(), memoryRequest, memoryRequest);
					}		
				} catch(NoSuchFieldException e){
					memory = null;
				}
			}
			if(memory != null)
				map.put(StandardResourceUnitName.MEMORY, memory);
			else return null;
		}

		return map;
	}


	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution2(
			ClusterResourceManager resourceManager, TaskInterface<?> task) {

		Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
		List<ComputingNode> nodes = resourceManager.getComputingNodes();
		for (ComputingNode node : nodes) {
			int cpuRequest;
			try {
				cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
			} catch (NoSuchFieldException e) {
				cpuRequest = 1;
			}

			if (cpuRequest != 0) {

				List<Processor> processors = node.getProcessors();
				if (processors.size() < cpuRequest) {
					continue;
				}

				List<ComputingResource> choosenResources = new ArrayList<ComputingResource>();				
				for (int i = 0; i < processors.size() && cpuRequest > 0; i++) {
					if (processors.get(i).getStatus() == ResourceStatus.FREE) {
						choosenResources.add(processors.get(i));
						cpuRequest--;
					}
				}
				if (cpuRequest > 0) {
					continue;
				}

				ProcessingElements result = new ProcessingElements(processors.get(0).getParent().getName());
				result.addAll(choosenResources);
				map.put(StandardResourceUnitName.PE, result);
				
				int memoryRequest;
				try {
					memoryRequest = Double.valueOf(task.getMemoryRequest()).intValue();
				} catch (NoSuchFieldException e) {
					memoryRequest = 0;
				}
				if (memoryRequest != 0) {

					Memory memory = null;
					try{
						if (node.getFreeMemory() >= memoryRequest) {		
							memory = new Memory(node.getMemory(), memoryRequest, memoryRequest);
						}		
					} catch(NoSuchFieldException e){
						continue;
					}
					if(memory == null)
						continue;
					else {
						map.put(StandardResourceUnitName.MEMORY, memory);
						return map;
					}
				}
			}
		}
	
		return null;
	}

	@SuppressWarnings("unchecked")
	private String chooseProviderForExecution(ResourceManager unitsManager) {
		List<ComputingResource> processingElements;
		Properties properties = new Properties();
		properties.setProperty("type", StandardResourceType.ComputingNode.toString());
		// properties.setProperty("status", ResourceStatus.FREE.toString());
		processingElements = (List<ComputingResource>) unitsManager.filterResources(properties);
		return processingElements.get(0).getName();
	}

	public String getName() {
		return getClass().getName();
	}

}