package example.localplugin;

import gridsim.Gridlet;
import gridsim.gssim.ResourceHistoryItem;
import gridsim.gssim.SubmittedTask;

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

import schedframe.resources.PowerState;
import schedframe.scheduling.TaskInterface;
import schedframe.scheduling.events.SchedulingEvent;
import schedframe.scheduling.events.TaskFinishedEvent;
import schedframe.scheduling.plugin.grid.ModuleList;
import schedframe.scheduling.utils.ResourceParameterName;
import test.rewolucja.GSSIMJobInterface;
import test.rewolucja.energy.profile.PStateType;
import test.rewolucja.resources.ProcessingElements;
import test.rewolucja.resources.ResourceStatus;
import test.rewolucja.resources.ResourceType;
import test.rewolucja.resources.manager.implementation.ClusterResourceManager;
import test.rewolucja.resources.manager.interfaces.ResourceManagerInterface;
import test.rewolucja.resources.physical.base.ComputingResource;
import test.rewolucja.resources.physical.implementation.ComputingNode;
import test.rewolucja.resources.physical.implementation.Processor;
import test.rewolucja.scheduling.JobRegistryInterface;
import test.rewolucja.scheduling.UsedResourceList;
import test.rewolucja.scheduling.plan.SchedulingPlanInterfaceNew;
import test.rewolucja.scheduling.plan.SchedulingPlanNew;
import test.rewolucja.scheduling.queue.Queue;
import test.rewolucja.scheduling.queue.QueueList;

public class FCFSPreferedRandomClusterLocalPlugin extends BaseLocalPlugin {

	private Random rand;
	private boolean init = true;
	
	int scenario = 3;
	String prefered = null;
	
	public FCFSPreferedRandomClusterLocalPlugin() {
		rand = new Random(5);
	}

	public SchedulingPlanInterfaceNew schedule(SchedulingEvent event, QueueList queues, JobRegistryInterface jobRegistry,
			 ResourceManagerInterface resManager, ModuleList modules) {
		
		ClusterResourceManager resourceManager = (ClusterResourceManager) resManager;
		
		if( init)
		{
			List<Processor> cpus = resourceManager.getProcessors();
			
			for( Processor cpu : cpus)
				cpu.getPowerInterface().setPState( PStateType.P0);
			
			init = false;
		}
		

		
		SchedulingPlanNew plan = new SchedulingPlanNew();
		// chose the events types to serve.
		// Different actions for different events are possible.
		switch (event.getType()) {
		case TASK_FINISHED:
			if( scenario == 2)
			{	
				TaskFinishedEvent finEvent = (TaskFinishedEvent) event;
				SubmittedTask subTask = jobRegistry.getSubmittedTask(finEvent.getJobId(), finEvent.getTaskId());
				UsedResourceList<ResourceHistoryItem> usedResourcesList = subTask.getUsedResources();
				ProcessingElements pes = (ProcessingElements)usedResourcesList.getLast().getResourceUnits().get(ResourceParameterName.PROCESSINGELEMENTS);
				
				for( ComputingResource cr : pes)
				{
					((Processor)cr).getPowerInterface().setPowerState( PowerState.OFF);
				}
			}
			
		case START_TASK_EXECUTION:
			// our tasks are placed only in first queue (see
			// BaseLocalPlugin.placeJobsInQueues() method)
			Queue q = queues.get(0);
			// check all tasks in queue

			for (int i = 0; i < q.size(); i++) {
				GSSIMJobInterface<?> job = q.get(i);
				TaskInterface<?> task = (TaskInterface<?>) job;
				// if status of the tasks in READY
				if (task.getStatus() == Gridlet.READY) {
					
					ComputingNode node = chooseRandomProvider(resourceManager, ResourceStatus.FREE, task);
					
					if (node != null) {
						List<Processor> cpus = chooseProcessorsForExecution(node, ResourceStatus.FREE, task);
						
						int type = Integer.parseInt( task.getJobId()) % 4;
						String model = cpus.get(0).getComputingNode().getCategory().getName();
						//System.out.println(type + " -> " + model);
						
						addToSchedulingPlan(plan, task, cpus);
					}
					else
					{
						switch( scenario)
						{
						case 0: break;
						case 1: break;
						case 2:
							node = chooseRandomProvider(resourceManager, ResourceStatus.UNAVAILABLE, task);
							if( node != null)
							{	
								List<Processor> cpus = chooseProcessorsForExecution(node, ResourceStatus.UNAVAILABLE, task);
								for( Processor cpu: cpus)
									cpu.getPowerInterface().setPowerState( PowerState.ON);
								
								i--;
							}
							break;
						}
					}
				}
			}
			
			switch( scenario)
			{
				case 0: break;
				case 1: 
				
					for( Processor cpu : resourceManager.getProcessors())
					{
						switch( cpu.getStatus())
						{
							case FREE: cpu.getPowerInterface().setPState( PStateType.P3); break;
							case PENDING: cpu.getPowerInterface().setPState( PStateType.P0); break;
						}
						
					}
					break;
				
				case 2:
					for( Processor cpu : resourceManager.getProcessors())
					{
						switch( cpu.getStatus())
						{
							case FREE: cpu.getPowerInterface().setPowerState( PowerState.OFF); break;
						}	
					}
					break;
				
				default: break;
			}
			
			break;
		}
		return plan;
	}

	private List<ComputingNode> findSuitableNodes(String model, int cpuRequest, ResourceStatus status, List<ComputingNode> nodes){
		List<ComputingNode> avNodes = new ArrayList<ComputingNode>();
		for(ComputingNode node: nodes)
		{
			if( (model == null || node.getCategory().getName().equals(model)))
			{	
				@SuppressWarnings("unchecked")
				List<Processor> cpus = (List<Processor>)node.getDescendantsByTypeAndStatus( ResourceType.CPU, status);
				
				if( cpus.size() >= cpuRequest)
					avNodes.add(node);
			}
		}
		return avNodes;
	}
	
	private int getCpuRequest( TaskInterface<?> task)
	{
		int cpuRequest;
		
		try {
			cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
		} catch (NoSuchFieldException e) {
			cpuRequest = 1;
		}
		
		return cpuRequest;
	}
	
	private ComputingNode chooseRandomProvider(ClusterResourceManager resourceManager, ResourceStatus status, TaskInterface<?> task) {
		
		String preferedNode = null;
		
		int cpuRequest = getCpuRequest(task);
		
		List<ComputingNode> nodes = null;
		
		switch( scenario)
		{
			case 3:
				int type = Integer.parseInt( task.getJobId()) % 4;
				switch( type)
				{
					case 0: preferedNode = "B"; break;
					default: preferedNode = "A"; break;
				}
				break;
			default:
				preferedNode = prefered;
				break;
				
		}
		
		nodes = findSuitableNodes(preferedNode, cpuRequest, status, resourceManager.getComputingNodes());
		switch( nodes.size())
		{
			case 0: break;
			case 1: return nodes.get(0);
			default:
				int nodeIdx = rand.nextInt(nodes.size());
				ComputingNode node = nodes.get(nodeIdx);		
				return node;
		}
		
		
		if( preferedNode != null)
		{	
			nodes = findSuitableNodes( getUnprefered(preferedNode), cpuRequest, status, resourceManager.getComputingNodes());
			switch( nodes.size())
			{
				case 0: break;
				case 1: return nodes.get(0);
				default: 
					int nodeIdx = rand.nextInt(nodes.size());
					ComputingNode node = nodes.get(nodeIdx);		
					return node;
			}
		}
			
		return null;
	}
	
	public String getName() {
		return getClass().getName();
	}

	public void init(Properties properties) {
		// no extra initialization is expected.
	}
	
	private List<Processor> chooseProcessorsForExecution( 
			ComputingNode node, ResourceStatus status, TaskInterface<?> task) {
		
		int cpuRequest = getCpuRequest(task);

		List<Processor> cpus = (List<Processor>)node.getDescendantsByTypeAndStatus( ResourceType.CPU, status);
		
		return cpus.subList(0, cpuRequest);
	}
	
	private String getUnprefered( String preferedNode)
	{
		if( preferedNode.equals("A"))
			return "B";
		
		if( preferedNode.equals("B"))
			return "A";
		
		return null;
	}

}