package mvd.jester.simulator.schmidmottok;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import mvd.jester.model.Segment;
import mvd.jester.simulator.internals.JobContextInterface;
import mvd.jester.simulator.internals.ProcessorContext;
import mvd.jester.simulator.internals.schmidmottok.JobContext;
import mvd.jester.simulator.internals.schmidmottok.SegmentContext;
import mvd.jester.simulator.internals.schmidmottok.TaskContext;
import mvd.jester.simulator.internals.schmidmottok.TaskletContext;

/**
 * TestSegmentContext
 */
public class TestSegmentContext {

    @Test
    @DisplayName("Check if segment returns the jobs correctly.")
    void testGetNextJob() {
        for (int run = 0; run < 100; ++run) {
            long numberOfJobs = ThreadLocalRandom.current().nextLong(1, 10);
            long jobWcet = ThreadLocalRandom.current().nextLong(20, 50);

            Segment s = mock(Segment.class);
            when(s.getNumberOfJobs()).thenReturn(numberOfJobs);
            when(s.getJobWcet()).thenReturn(jobWcet);
            when(s.getNumberOfTasklets()).thenReturn(jobWcet);
            when(s.getTaskletWcet()).thenReturn(numberOfJobs);
            TaskContext tc = mock(TaskContext.class);

            SegmentContext sc = new SegmentContext(tc, s, 4);
            Optional<JobContextInterface> job = Optional.empty();

            when(tc.acceptNotification(jobWcet - 1)).thenReturn(Optional.empty());

            long numJobs = numberOfJobs > 4 ? 4 : numberOfJobs;
            for (int i = 0; i < numJobs; ++i) {
                job = sc.getNextJob();
                assertTrue(job.isPresent());
                job.get().setCurrentProcessor(new ProcessorContext(i));
            }

            assertFalse(sc.getNextJob().isPresent());

            sc = new SegmentContext(tc, s, 4);

            job = sc.getNextJob();
            assertTrue(job.isPresent());
            job.get().setCurrentProcessor(new ProcessorContext(0));
            for (int i = 0; i < jobWcet * numberOfJobs; ++i) {
                job.get().updateExecution(i);
            }

            assertFalse(sc.getNextJob().isPresent());
        }
    }

    @Test
    @DisplayName("Check if SegmentContext returns the correct amount of tasklets.")
    void testGetNextTasklet() {
        for (int run = 0; run < 100; ++run) {
            long numberOfJobs = ThreadLocalRandom.current().nextLong(1, 10);
            long jobWcet = ThreadLocalRandom.current().nextLong(20, 50);

            Segment s = mock(Segment.class);
            when(s.getNumberOfJobs()).thenReturn(numberOfJobs);
            when(s.getJobWcet()).thenReturn(jobWcet);
            when(s.getNumberOfTasklets()).thenReturn(jobWcet);
            when(s.getTaskletWcet()).thenReturn(numberOfJobs);
            TaskContext tc = mock(TaskContext.class);
            when(tc.acceptNotification(jobWcet - 1)).thenReturn(Optional.empty());

            SegmentContext sc = new SegmentContext(tc, s, 4);

            for (int i = 0; i < jobWcet; ++i) {

                Optional<TaskletContext> tci = sc.getNextTasklet();
                assertTrue(tci.isPresent());
                tci.get().setCurrentJob(new JobContext(tc, sc));
            }

            assertFalse(sc.getNextTasklet().isPresent());

            sc = new SegmentContext(tc, s, 4);

            for (int i = 0; i < jobWcet; ++i) {
                Optional<TaskletContext> tasklet = sc.getNextTasklet();
                assertTrue(tasklet.isPresent());
                tasklet.get().setCurrentJob(new JobContext(tc, sc));
                for (int j = 0; j < numberOfJobs; ++j) {
                    tasklet.get().updateExecution(j);
                }
            }

            assertFalse(sc.getNextTasklet().isPresent());
        }
    }

}