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.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.AdditionalMatchers.not;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Optional;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import mvd.jester.model.Segment;
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;;

/**
 * TestJobContext
 */
public class TestJobContext {

    @Test
    @DisplayName("Check if the job is prepared correctly.")
    public void testPrepareJob() {
        TaskContext tc = mock(TaskContext.class);
        TaskletContext tlc = mock(TaskletContext.class);
        SegmentContext sc = mock(SegmentContext.class);
        Segment s = mock(Segment.class);
        when(sc.getSegment()).thenReturn(s);
        when(s.getJobWcet()).thenReturn((long) 20);
        when(sc.getNextTasklet()).thenReturn(Optional.of(tlc))
                .thenReturn(Optional.ofNullable(null));


        JobContext jc = new JobContext(tc, sc);

        assertTrue(jc.prepareJob(0));
        assertTrue(jc.prepareJob(1));
        jc.setCurrentTasklet(null);
        assertFalse(jc.prepareJob(2));
    }

    @Test
    @DisplayName("Check if the execution time is checked correctly.")
    void testCheckExecutionTime() {
        TaskContext tc = mock(TaskContext.class);
        TaskletContext tlc = mock(TaskletContext.class);
        SegmentContext sc = mock(SegmentContext.class);
        Segment s = mock(Segment.class);
        when(sc.getSegment()).thenReturn(s);
        when(s.getJobWcet()).thenReturn((long) 20);
        when(tlc.checkExecutionTime()).thenReturn(true, false);

        JobContext jc = new JobContext(tc, sc);

        assertFalse(jc.checkExecutionTime());
        jc.setCurrentTasklet(tlc);
        assertTrue(jc.checkExecutionTime());
        assertFalse(jc.checkExecutionTime());
    }

    @Test
    @DisplayName("Check if the execution is updated correctly.")
    void checkUpdateExecution() {
        TaskContext tc = mock(TaskContext.class);
        TaskletContext tlc = mock(TaskletContext.class);
        SegmentContext sc = mock(SegmentContext.class);
        Segment s = mock(Segment.class);
        ProcessorContext pc = mock(ProcessorContext.class);
        when(sc.getSegment()).thenReturn(s);
        when(sc.getNextTasklet()).thenReturn(Optional.ofNullable(tlc))
                .thenReturn(Optional.ofNullable(null));
        when(s.getJobWcet()).thenReturn((long) 20);
        when(tlc.checkExecutionTime()).thenReturn(true, false);
        when(tlc.updateExecution(not(eq(0)))).thenReturn(true);
        when(tlc.updateExecution(0)).thenReturn(false);
        when(tc.acceptNotification(not(eq(1)))).thenReturn(Optional.ofNullable(null));
        when(tc.acceptNotification(1)).thenReturn(Optional.ofNullable(tc));

        JobContext jc = new JobContext(tc, sc);
        jc.setCurrentProcessor(pc);

        assertFalse(jc.updateExecution(0).isPresent());
        assertFalse(jc.updateExecution(0).isPresent());

        jc.setCurrentTasklet(tlc);
        assertTrue(jc.updateExecution(1).isPresent());

        verify(tlc, times(2)).updateExecution(anyLong());
        verify(tc, times(2)).acceptNotification(anyLong());
        verify(sc, times(2)).getNextTasklet();
    }
}