package mvd.jester.simulator.internals.dynamicforkjoin;

import java.util.Optional;
import mvd.jester.simulator.EventPrinter;
import mvd.jester.simulator.internals.JobContextInterface;
import mvd.jester.simulator.internals.ProcessorContext;
import mvd.jester.simulator.internals.TaskContextInterface;

/**
 * Job
 * 
 * @param <Job>
 */
public class JobContext implements JobContextInterface {

    private final TaskContext taskContext;
    private final SegmentContext segmentContext;
    private final long wcet;
    private Optional<ProcessorContext> currentProcessor;
    private Optional<TaskletContext> currentTasklet;


    public JobContext(TaskContext taskContext, SegmentContext segmentContext) {
        this.currentProcessor = Optional.empty();
        this.currentTasklet = Optional.empty();
        this.taskContext = taskContext;
        this.segmentContext = segmentContext;
        this.wcet = segmentContext.getSegment().getWidth();
    }

    public Optional<TaskContextInterface> updateExecution(long time) {
        boolean jobIsIdle = true;
        if (currentTasklet.isPresent()) {
            jobIsIdle = currentTasklet.get().updateExecution(time);
        }

        if (jobIsIdle) {
            currentTasklet = segmentContext.getNextTasklet();
            Optional<TaskContextInterface> tc = taskContext.acceptNotification(time);

            if (currentTasklet.isPresent()) {
                EventPrinter.print("Time " + time + ": Job " + this + " started executing tasklet "
                        + currentTasklet.get() + " on Processor " + currentProcessor.get());
                currentTasklet.get().setCurrentJob(this);
            } else {
                if (currentProcessor.isPresent()) {
                    currentProcessor.get().setJob(null);
                }
                currentProcessor = Optional.empty();
                return tc;
            }
        }

        return Optional.empty();
    }

    public boolean checkExecutionTime() {
        if (currentTasklet.isPresent()) {
            return currentTasklet.get().checkExecutionTime();
        }
        return false;
    }

    /**
     * @return the wcet
     */
    public long getWcet() {
        return wcet;
    }

    /**
     * @param processor the currentProcessor to set
     */
    public void setCurrentProcessor(ProcessorContext processor) {
        this.currentProcessor = Optional.ofNullable(processor);
    }

    /**
     * @return the currentProcessor
     */
    public Optional<ProcessorContext> getCurrentProcessor() {
        return currentProcessor;
    }

    /**
     * @param currentTasklet the currentTasklet to set
     */
    public void setCurrentTasklet(TaskletContext currentTasklet) {
        this.currentTasklet = Optional.ofNullable(currentTasklet);
    }

    /**
     * @return the segmentContext
     */
    public SegmentContext getSegmentContext() {
        return segmentContext;
    }


    /**
     * @return the taskContext
     */
    public TaskContext getTaskContext() {
        return taskContext;
    }

    @Override
    public String toString() {
        return "(of task=" + taskContext + ")";
    }

    @Override
    public boolean prepareJob(long time) {
        if (!currentTasklet.isPresent()) {
            currentTasklet = segmentContext.getNextTasklet();
            if (currentTasklet.isPresent()) {
                currentTasklet.get().setCurrentJob(this);
                // EventPrinter.print("Time " + time + ": Job " + this + " started executing
                // tasklet"
                // + currentTasklet.get());
                return true;
            } else {
                return false;
            }
        }
        return true;
    }

}