package mvd.jester.model;

import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
import com.google.common.math.DoubleMath;
import org.jgrapht.experimental.dag.DirectedAcyclicGraph;
import org.jgrapht.graph.DefaultEdge;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import mvd.jester.model.SystemManager.DagTaskBuilder;


public class TestSystemSetup {

    private static final int NUMBER_OF_RUNS = 1000;

    @Test
    @DisplayName("Check if randomly generated task parameters lie within the specified ranges.")
    public void testRandomTaskSetGeneration() {
        for (int i = 0; i < NUMBER_OF_RUNS; ++i) {
            long numberOfProcessors = ThreadLocalRandom.current().nextLong(2, 8);
            SystemManager.SynchronousTaskBuilder systemSetupBuilder =
                    new SystemManager.SynchronousTaskBuilder()//
                            .setNumberOfSegments(1, 7)//
                            .setNumberOfJobs(2, 10)//
                            .setPeriods(100, 1000, 1000)//
                            .setNumberOfProcessors(numberOfProcessors);

            Set<SynchronousTask> taskSet = systemSetupBuilder.generateTaskSet();

            // assertTrue(systemSetup.getNumberOfProcessors() == numberOfProcessors);

            for (SynchronousTask t : taskSet) {
                assertTrue(t.getPeriod() >= 100);
                assertTrue(t.getPeriod() <= 1000);
                assertTrue(t.getDeadline() == t.getPeriod());

                long maxJobWcet = t.getPeriod() / t.getWorkloadDistribution().size();

                for (Segment s : t.getWorkloadDistribution()) {
                    assertTrue(s.getJobWcet() >= 1);
                    assertTrue(s.getJobWcet() <= maxJobWcet);
                    assertTrue(s.getNumberOfJobs() >= 1);
                    assertTrue(s.getNumberOfJobs() <= 10);
                }

                assertTrue(t.getWorkloadDistribution().size() >= 1);
                assertTrue(t.getWorkloadDistribution().size() <= 7);

            }

            assertTrue(systemSetupBuilder.addTask(taskSet));
        }
    }

    @Test
    @DisplayName("Check Getters and Setters.")
    void testGettersAndSetters() {
        // @SuppressWarnings("unchecked")
        // Set<SynchronousTask> t1 = mock(Set.class);

        // @SuppressWarnings("unchecked")
        // Set<SynchronousTask> t2 = mock(Set.class);

        // SystemManager<SynchronousTask> systemSetup = new SystemManager<>(t1, 2);

        // systemSetup.setTasks(t2);
        // assertTrue(systemSetup.getTasks() == t2);
    }

    @Test
    @DisplayName("Check if DagTaskBuilder works correctly")
    void testDagTaskBuilder() {
        for (int i = 0; i < 100; ++i) {
            DagTaskBuilder builder = new DagTaskBuilder();
            DagTask task = builder.generateTask();
            DirectedAcyclicGraph<Job, DefaultEdge> jobDag = task.getJobDag();

            assertTrue(task.getCriticalPath() <= task.getPeriod());
            assertTrue(task.getPeriod() <= (long) (task.getWorkload() / builder.getBeta()));

            for (Job j : jobDag) {
                assertTrue(1 <= j.getWcet() && j.getWcet() <= 100);
                assertTrue(j.getRelativeCompletionTime() <= task.getCriticalPath());
                if (jobDag.outDegreeOf(j) == 0) {
                    assertTrue(j.getRelativeCompletionTime() == task.getCriticalPath());
                }
            }
            for (DefaultEdge e : jobDag.edgeSet()) {
                Job source = jobDag.getEdgeSource(e);
                Job target = jobDag.getEdgeTarget(e);
                assertTrue(source.getRelativeCompletionTime() < target.getRelativeCompletionTime());
            }
        }

    }


    @Test
    @DisplayName("Check if utilization works correctly.")
    void testUtil() {
        for (int i = 0; i < 10; ++i) {
            for (double d = 0.25; d < 4; d += 0.25) {
                DagTaskBuilder builder = new DagTaskBuilder();
                Set<DagTask> taskSet = builder.generateTaskSet(d);
                double taskSetUtil = 0;
                for (DagTask t : taskSet) {
                    taskSetUtil += t.getUtilization();
                }

                assertTrue(DoubleMath.fuzzyEquals(taskSetUtil, d, 0.1));
            }
        }
    }

    @Test
    @DisplayName("Check if UUnifast Algorithm works correctly.")
    void testUUnifast() {
        for (int i = 1; i <= 100; ++i) {
            long numberOfTasks = ThreadLocalRandom.current().nextLong(1, 20);
            double utilization = ThreadLocalRandom.current().nextDouble(0.25, 8);
            DagTaskBuilder builder = new DagTaskBuilder();
            Set<DagTask> taskSet = builder.generateUUnifastTaskSet(numberOfTasks, utilization);

            double taskSetUtil = 0;
            for (DagTask t : taskSet) {
                taskSetUtil += t.getUtilization();
            }

            assertTrue(taskSet.size() == numberOfTasks);
            assertTrue(DoubleMath.fuzzyEquals(taskSetUtil, utilization, 0.1));
        }
    }

}