package mvd.jester;

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import org.jgrapht.experimental.dag.DirectedAcyclicGraph;
import org.jgrapht.graph.DefaultEdge;
import mvd.jester.model.DagTask;
import mvd.jester.model.Subtask;
import mvd.jester.model.SystemManager;
import mvd.jester.model.SystemManager.DagTaskBuilder;
import mvd.jester.priority.RateMonotonic;
import mvd.jester.simulator.GlobalScheduler;
import mvd.jester.simulator.exceptions.SchedulingException;
import mvd.jester.simulator.model.ExtendedSubtaskContext;
import mvd.jester.simulator.model.JobContext;
import mvd.jester.tests.AbstractTest;
import mvd.jester.tests.FonsecaNelis;
import mvd.jester.tests.MelaniButtazzo;
import mvd.jester.tests.SchmidMottok;
import mvd.jester.tests.TypeFunction.KownStructure;
import mvd.jester.tests.TypeFunction.UnkownStructure;


/**
 * Hello world!
 *
 */
public class App {

    private static DirectedAcyclicGraph<Subtask, DefaultEdge> createJobDag(long time) {
        DirectedAcyclicGraph<Subtask, DefaultEdge> jobDag =
                new DirectedAcyclicGraph<>(DefaultEdge.class);
        Subtask source = new Subtask(time);
        Subtask pathA = new Subtask(10);
        Subtask pathB = new Subtask(15);
        Subtask pathC = new Subtask(20);
        Subtask pathD = new Subtask(25);
        Subtask sink = new Subtask(time);
        Subtask source2 = new Subtask(time);
        Subtask a = new Subtask(30);
        Subtask sink2 = new Subtask(35);

        try {
            jobDag.addVertex(source);
            jobDag.addVertex(pathA);
            jobDag.addVertex(pathB);
            jobDag.addVertex(pathC);
            jobDag.addVertex(pathD);
            jobDag.addVertex(sink);
            jobDag.addDagEdge(source, pathA);
            jobDag.addDagEdge(source, pathB);
            jobDag.addDagEdge(source, pathC);
            jobDag.addDagEdge(source, pathD);
            jobDag.addDagEdge(pathA, sink);
            jobDag.addDagEdge(pathB, sink);
            jobDag.addDagEdge(pathC, sink);
            jobDag.addDagEdge(pathD, sink);
            jobDag.addDagEdge(sink, source2);
            jobDag.addDagEdge(source2, a);
            jobDag.addDagEdge(source2, sink2);
            jobDag.addDagEdge(a, sink2);
        } catch (Exception e) {
            // TODO: handle exception
        }

        return jobDag;
    }

    public static void main(String[] args) {

        GlobalScheduler scheduler = new GlobalScheduler(new RateMonotonic(), 4);
        DagTaskBuilder builder = new DagTaskBuilder().setNumberOfProcessors(4);
        Set<DagTask> taskset = builder.generateTaskSet(3);
        try {
            scheduler.schedule(taskset, 10000);
        } catch (SchedulingException e) {
            int brk = 0;
        }
        scheduler.schedule(taskset, 10000);

        // DagTask t1 = new DagTask(createJobDag(15), 200, 3);
        // DagTask t2 = new DagTask(createJobDag(10), 300, 3);
        // DagTask t3 = new DagTask(createJobDag(5), 350, 3);

        // LinkedHashSet<DagTask> tasks = new LinkedHashSet<>();
        // tasks.add(t1);
        // tasks.add(t2);
        // tasks.add(t3);
        // scheduler.schedule(tasks, 10000);

        // {
        // SystemManager manager = new SystemManager(8);
        // DagTaskBuilder builder = new DagTaskBuilder();
        // TestEnvironment te = new TestEnvironment();

        // List<AbstractTest<DagTask>> tests =
        // te.registerTests(Arrays.asList(new SchmidMottok(new UnkownStructure(), manager),
        // new SchmidMottok(new KownStructure(), manager),
        // new MelaniButtazzo(manager), new FonsecaNelis(manager)));

        // te.varyUtilization(builder, tests, 8, 500);
        // }
        // {
        // SystemManager manager = new SystemManager(8);
        // DagTaskBuilder builder = new DagTaskBuilder();
        // TestEnvironment te = new TestEnvironment();

        // List<AbstractTest<DagTask>> tests =
        // te.registerTests(Arrays.asList(new SchmidMottok(new UnkownStructure(), manager),
        // new SchmidMottok(new KownStructure(), manager),
        // new MelaniButtazzo(manager), new FonsecaNelis(manager)));

        // te.varyNumberOfProcessors(builder, tests, manager, 500);
        // }
        // {
        // SystemManager manager = new SystemManager(8);
        // DagTaskBuilder builder = new DagTaskBuilder();
        // TestEnvironment te = new TestEnvironment();

        // List<AbstractTest<DagTask>> tests =
        // te.registerTests(Arrays.asList(new SchmidMottok(new UnkownStructure(), manager),
        // new SchmidMottok(new KownStructure(), manager),
        // new MelaniButtazzo(manager), new FonsecaNelis(manager)));

        // te.varyNumberOfTasks(builder, tests, 8, 500);
        // }
        // {
        // SystemManager manager = new SystemManager(8);
        // DagTaskBuilder builder = new DagTaskBuilder();
        // TestEnvironment te = new TestEnvironment();

        // List<AbstractTest<DagTask>> tests =
        // te.registerTests(Arrays.asList(new SchmidMottok(manager),
        // new MelaniButtazzo(manager), new FonsecaNelis(manager)));

        // te.measureExecutionTimes(builder, tests, manager, 500);
        // }
    }
}