package mvd.jester.simulator.dynamicforkjoin;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.Optional;
import java.util.Set;
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.model.SynchronousTask;
import mvd.jester.simulator.internals.JobContextInterface;
import mvd.jester.simulator.internals.ProcessorContext;
import mvd.jester.simulator.internals.TaskContextInterface;
import mvd.jester.simulator.internals.dynamicforkjoin.TaskContext;

/**
 * TestTaskContext
 */
public class TestTaskContext {
    @Test
    @DisplayName("Check if TaskContext accepts its notification correctly.")
    public void testAcceptNotification() {
        for (int run = 0; run < 100; ++run) {
            long numberOfJobs = ThreadLocalRandom.current().nextLong(1, 10);
            long numberOfSegments = ThreadLocalRandom.current().nextLong(3, 10);
            ArrayList<Segment> segments = new ArrayList<>();

            for (int i = 0; i < numberOfSegments; ++i) {
                long numJobs = i % 2 == 0 ? 1 : numberOfJobs;
                segments.add(new Segment(10, numJobs));
            }

            SynchronousTask t = new SynchronousTask(new LinkedHashSet<>(segments), 100, 8);
            TaskContext tc = new TaskContext(t, 1, 0);

            for (int i = 0; i < segments.size() - 1; ++i) {
                Segment s = segments.get(i);
            }


            Optional<TaskContextInterface> tci = tc.acceptNotification(0);

            assertTrue(tci.isPresent());
            assertTrue(tci.get().equals(tc));
        }
    }

    @Test
    @DisplayName("Check if the next job is returned correctly.")
    public void testGetNextJob() {
        for (int run = 0; run < 100; ++run) {
            long numberOfProcessors = ThreadLocalRandom.current().nextLong(2, 10);

            Set<Segment> segments = new LinkedHashSet<>();
            segments.add(new Segment(5, 1));
            segments.add(new Segment(10, 10));
            segments.add(new Segment(15, 1));
            SynchronousTask t = new SynchronousTask(segments, 100, 8);

            TaskContext tc = new TaskContext(t, numberOfProcessors, 0);

            Optional<JobContextInterface> job = tc.getNextJob();
            assertTrue(job.isPresent());
            job.get().setCurrentProcessor(new ProcessorContext(0));
            assertFalse(tc.getNextJob().isPresent());

            tc.acceptNotification(0);

            for (int i = 0; i < numberOfProcessors - 1; ++i) {
                job = tc.getNextJob();
                assertTrue(job.isPresent());
                job.get().setCurrentProcessor(new ProcessorContext(i));
            }

            job = tc.getNextJob();
            assertTrue(job.isPresent());
            job.get().setCurrentProcessor(new ProcessorContext(10));

            assertFalse(tc.getNextJob().isPresent());
            job.get().setCurrentProcessor(null);
            assertTrue(tc.getNextJob().isPresent());
            job.get().setCurrentProcessor(new ProcessorContext(10));
            assertFalse(tc.getNextJob().isPresent());

            for (int i = 0; i < 10; ++i) {
                tc.acceptNotification(0);
            }
            assertTrue(tc.getNextJob().isPresent());
        }
    }

}