package mvd.jester.model;

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
import mvd.jester.priority.PriorityManager;
import mvd.jester.priority.RateMonotonic;

/**
 * TaskSet
 */
public class SystemSetup {
    private SortedTaskSet tasks;
    private final long numberOfProcessors;

    public SystemSetup(SortedTaskSet tasks, long numberOfProcessors) {
        this.tasks = tasks;
        this.numberOfProcessors = numberOfProcessors;
    }

    /**
     * @return the tasks
     */
    public SortedTaskSet getTasks() {
        return tasks;
    }

    public void setTasks(SortedTaskSet tasks) {
        this.tasks = tasks;
    }

    /**
     * @return the numberOfProcessors
     */
    public long getNumberOfProcessors() {
        return numberOfProcessors;
    }

    public double getUtilization() {
        double utilization = 0;
        for (Task t : tasks) {
            utilization += (double) t.getMaximumWcet() / t.getPeriod();
        }

        return utilization;
    }

    public static class Builder {
        private long numberOfProcessors = 4;
        private long minPeriod = 100;
        private long maxPeriod = 1000;
        private long minNumberOfSegments = 3;
        private long maxNumberOfSegments = 7;
        private long minNumberOfJobs = 2;
        private long maxNumberOfJobs = 3 * numberOfProcessors / 2;
        private long minWcet = 1;
        private long ratio = randomTaskRatio();
        private PriorityManager priorityManager = new RateMonotonic();

        public Builder() {

        }

        private long randomTaskPeriod() {
            return ThreadLocalRandom.current().nextLong(minPeriod, maxPeriod);
        }

        private long randomTaskRatio() {
            return ThreadLocalRandom.current().nextLong(0, 100);
        }

        private long randomNumberOfSegments() {
            return ThreadLocalRandom.current().nextLong(minNumberOfSegments, maxNumberOfSegments);
        }

        private long randomNumberOfJobs() {
            this.maxNumberOfJobs = 3 * this.numberOfProcessors / 2;
            return ThreadLocalRandom.current().nextLong(minNumberOfJobs, maxNumberOfJobs);
        }

        private long randomWcet(long period, long numberOfSegments) {
            long maxWcet = period / numberOfSegments;

            return ThreadLocalRandom.current().nextLong(minWcet, maxWcet);
        }

        private Task generateTask() {
            boolean serial = randomTaskRatio() > this.ratio;
            long period = randomTaskPeriod();
            long numberOfSegments = 1;
            Set<Segment> segments = new LinkedHashSet<Segment>();
            if (!serial) {
                numberOfSegments = randomNumberOfSegments();
            } else {
                numberOfSegments = 1;
            }
            long parallelNumberOfJobs = serial ? 1 : randomNumberOfJobs();
            for (int i = 0; i < numberOfSegments; ++i) {
                long numberOfJobs = 1;
                if (i % 2 == 1) {
                    numberOfJobs = parallelNumberOfJobs;
                }
                long wcet = randomWcet(period, numberOfSegments);
                segments.add(new Segment(wcet, numberOfJobs));
            }
            return new Task(period, segments);
        }

        private SortedTaskSet generateTaskSet() {
            SortedTaskSet taskSet = new SortedTaskSet(priorityManager);

            for (int i = 0; i < 4; ++i) {
                Task task = generateTask();
                taskSet.add(task);
            }

            return taskSet;
        }

        public SystemSetup build() {
            this.ratio = randomTaskRatio();
            SortedTaskSet taskSet = generateTaskSet();
            return new SystemSetup(taskSet, numberOfProcessors);
        }

        public void rebuild(SystemSetup systemSetup) {
            this.ratio = randomTaskRatio();
            systemSetup.tasks = generateTaskSet();
        }

        public void addTask(SystemSetup systemSetup) {
            systemSetup.tasks.add(generateTask());
        }

        public Builder setNumberOfProcessors(long numberOfProcessors) {
            this.numberOfProcessors = numberOfProcessors;

            return this;
        }

        public Builder setNumberOfSegments(long minNumberOfSegments, long maxNumberOfSegments) {
            this.minNumberOfSegments = minNumberOfSegments;
            this.maxNumberOfSegments = maxNumberOfSegments;

            return this;
        }

        public Builder setPeriods(long minPeriod, long maxPeriod) {
            this.minPeriod = minPeriod;
            this.maxPeriod = maxPeriod;

            return this;
        }

        public Builder setPriorityManager(PriorityManager priorityManager) {
            this.priorityManager = priorityManager;
            return this;
        }

        /**
         * @param maxNumberOfJobs the maxNumberOfJobs to set
         */
        public Builder setNumberOfJobs(long minNumberOfJobs, long maxNumberOfJobs) {
            this.minNumberOfJobs = minNumberOfJobs;
            this.maxNumberOfJobs = maxNumberOfJobs;
            return this;
        }

    }

}