package schedframe.scheduling.tasks;

import gridsim.GridSim;
import gridsim.Gridlet;
import gridsim.ResGridlet;
import gssim.schedframe.scheduling.ExecTask;
import gssim.schedframe.scheduling.Executable;

import java.util.List;

import org.apache.commons.lang.ArrayUtils;
import org.joda.time.DateTime;
import org.joda.time.DateTimeUtilsExt;
import org.joda.time.ReadableDuration;

import schedframe.resources.computing.ComputingResource;
import schedframe.resources.units.ProcessingElements;
import schedframe.resources.units.StandardResourceUnitName;
import schedframe.scheduling.ResourceHistoryItem;
import schedframe.scheduling.UsedResourceList;
import schedframe.scheduling.WorkloadUnitHandler;
import schedframe.scheduling.manager.tasks.JobRegistryImpl;
import schedframe.scheduling.tasks.requirements.ResourceParameterName;

/**
 * 
 * @author Marcin Krystek
 *
 */
public class SubmittedTask extends ResGridlet implements ExecTask{

	protected Executable task;
	protected int estimatedDuration;
	protected UsedResourceList<ResourceHistoryItem> usedResources;
	//protected List<String> visitedResources;
	
	public SubmittedTask(Executable exec) {
		super(exec);
		task = exec;
		this.usedResources = new UsedResourceList<ResourceHistoryItem>();
		if(exec.requireReservation())
			this.reservID_ = Integer.valueOf(exec.getReservationId());
		//this.visitedResources = new ArrayList<String>();
	}

	public double getCpuCntRequest() throws NoSuchFieldException {
		return task.getCpuCntRequest();
	}

	public DateTime getExecutionEndTime() throws NoSuchFieldException {
		return task.getExecutionEndTime();
	}

	public DateTime getExecutionStartTime() throws NoSuchFieldException {
		return task.getExecutionStartTime();
	}

	public ReadableDuration getExpectedDuration() throws NoSuchFieldException {
		return task.getExpectedDuration();
	}

	public int getEstimatedDuration(){
		return this.estimatedDuration;
	}
	
	public void setEstimatedDuration(int value){
		this.estimatedDuration = value;
	}
	
	public String getId() {
		return task.getId();
	}

	public String getJobId() {
		return task.getJobId();
	}

	public long getLength() {
		return task.getLength();
	}

	public double getMemoryRequest() throws NoSuchFieldException {
		return task.getMemoryRequest();
	}

	public double getParameterDoubleValue(ResourceParameterName parameterName)
			throws NoSuchFieldException, IllegalArgumentException {
		return task.getParameterDoubleValue(parameterName);
	}

	public String getParameterStringValue(ResourceParameterName parameterName)
			throws NoSuchFieldException, IllegalArgumentException {
		return task.getParameterStringValue(parameterName);
	}

	public List<AbstractProcessesGroup> getProcessesGroups() {
		throw new RuntimeException("Not implemented");
	}
	
	public List<AbstractProcesses> getProcesses(){
		throw new RuntimeException("Not implemented");
	}
	
	public List<AbstractProcesses> getProcesses(AbstractProcessesGroup processGroup){
		throw new RuntimeException("Not implemented");
	}

	public int getStatus() {
		return task.getStatus();
	}

	public DateTime getSubmissionTimeToBroker() {
		return task.getSubmissionTimeToBroker();
	}

	public String getUserDn() {
		return task.getUserDn();
	}

	public void setLength(long length) {
		throw new RuntimeException("Task length should not be changed here.");
	}

	public void setStatus(int status) throws Exception {
		task.setStatus(status);
	}

	public org.qcg.broker.schemas.resreqs.Task getDescription() {
		return (org.qcg.broker.schemas.resreqs.Task) task.getDescription();
	}

	public String getDocument() throws Exception {
		return task.getDocument();
	}
	
	public boolean expectSpecificResource(ResourceParameterName resourceName){
		return task.expectSpecificResource(resourceName);
	}
	
	public Object getExpectedSpecificResource(ResourceParameterName resourceName){
		return task.getExpectedSpecificResource(resourceName);
	}

	public long getWorkloadLogWaitTime() {
		return task.getWorkloadLogWaitTime();
	}
	
	public void addUsedResources(ResourceHistoryItem usedResources){
		this.usedResources.add(usedResources);
	}
	
	//public List<Map<ResourceParameterName, ResourceUnit>> getUsedResources(){
	public UsedResourceList<ResourceHistoryItem> getUsedResources(){
		return this.usedResources;
	}
	
	public boolean setGridletStatus(int status)
    {
        // gets Gridlet's previous status
        int prevStatus = gridlet_.getGridletStatus();

        // if the status of a Gridlet is the same as last time, then ignore
        if (prevStatus == status) {
            return false;
        }

        boolean success = true;
        try
        {
            double clock = GridSim.clock();   // gets the current clock
            long sec = DateTimeUtilsExt.currentTimeMillis() / 1000; // time in seconds 
            clock = Long.valueOf(sec).doubleValue();
            
            // sets Gridlet's current status
            gridlet_.setGridletStatus(status);

            // if a previous Gridlet status is INEXEC
            if (prevStatus == Gridlet.INEXEC)
            {
                // and current status is either CANCELED, PAUSED or SUCCESS
                if (status == Gridlet.CANCELED || status == Gridlet.PAUSED ||
                    status == Gridlet.SUCCESS)
                {
                    // then update the Gridlet completion time
                    totalCompletionTime_ += (clock - startExecTime_);
                    index_ = 0;
                    return true;
                }
            }

            if (prevStatus == Gridlet.RESUMED && status == Gridlet.SUCCESS)
            {
                // then update the Gridlet completion time
                totalCompletionTime_ += (clock - startExecTime_);
                return true;
            }

            // if a Gridlet is now in execution
            if (status == Gridlet.INEXEC ||
                (prevStatus == Gridlet.PAUSED && status == Gridlet.RESUMED) )
            {
            	
                startExecTime_ = clock;
                gridlet_.setExecStartTime(startExecTime_);
        		ProcessingElements pes = (ProcessingElements) getUsedResources().getLast().getResourceUnits().get(StandardResourceUnitName.PE);
        		for (ComputingResource resource : pes) {

        			visitResource(resource.getName());
        			ComputingResource parent = resource.getParent();

					List<String> visitedResource = getVisitedResources();
        			while (parent != null && !ArrayUtils.contains(visitedResource.toArray(new String[visitedResource.size()]), parent.getName())) {
        				visitResource(parent.getName());
        				parent = parent.getParent();
        			}
        		}
            }
        }
        catch(Exception e) {
            success = false;
        }

        return success;
    }
	
	
	protected void init() {
		super.init();
		double time =  DateTimeUtilsExt.getDateTimeAt(arrivalTime_).getMillis() / 1000;
		this.gridlet_.setSubmissionTime(time);
	 }


	@Override
	public boolean isFinished() {
		// TODO Auto-generated method stub
		return false;
	}
	
	/*public void addToResPath(String resName){
		task.addToResPath(resName);
	}
	
	public String getResPath(){
		return task.getResPath();
	}*/
	
	public void visitResource(String resName){
		task.visitResource(resName);
	}
	
	public List<String> getVisitedResources(){
		return task.getVisitedResources();
	}
	
	public boolean isRegistered() {
		return task.isRegistered();
	}

	public void register(JobRegistryImpl jobRegistry) {
		task.register(jobRegistry);
		//jobRegistry.addTask(this);
	}
	
	@Override
	public void accept(WorkloadUnitHandler wuh) {
		wuh.handleSubmittedTask(this);
	}
}