import org.broken.cheststorage.ChestStorage;
import org.broken.cheststorage.util.effects.SpawnCustomEffects;
import org.broken.cheststorage.util.effects.heavyLoad;
import org.bukkit.Bukkit;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.TimeUnit;

public class HeavyTasks extends BukkitRunnable {

    private static int taskIDNumber = -1;

    private int amount = 0;
    private static final int MAX_MS_PER_TICK = 5;

    public HeavyTasks() {
        //workloadDeque = Queues.newArrayDeque();
        taskIDNumber = runTaskTimer(ChestStorage.getInstance(), 0L, 5L).getTaskId();
    }

    public void start() {
        if (Bukkit.getScheduler().isCurrentlyRunning(taskIDNumber) || Bukkit.getScheduler().isQueued(taskIDNumber))
            Bukkit.getScheduler().cancelTask(taskIDNumber);
        new HeavyTasks();
    }

    private static final Queue<heavyLoad> workloadDeque = new ConcurrentLinkedDeque<>();

    private static final Map<Object, queueCheck> map = new HashMap<>();

    private heavyLoad firstReschudleElement;

    public void addLoad(heavyLoad task) {
        workloadDeque.add(task);
        //test.add(task);
        //System.out.println("testings of " + workloadDeque);
    }

    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
    public boolean isContainsMaxAmountInQueue(Object object) {
        return map.containsKey(object) && map.get(object).getTask().size() <= 5;
    }

    public void setMaxAmountEachEntityCanQueue(Object object, long howLongTimeBeforeRemove, heavyLoad task) {
        LinkedList<heavyLoad> addData = new LinkedList<>();

        if (map.containsKey(object)) {
            LinkedList<heavyLoad> data = map.get(object).getTask();
            addData.addAll(data);
        }
        addData.add(task);

        map.put(object, queueCheck.of(howLongTimeBeforeRemove, addData));
    }

    private boolean cumputeTasks(heavyLoad task) {
        if (task != null) {
            if (task.reschedule()) {
                addLoad(task);

                if (firstReschudleElement == null) {
                    firstReschudleElement = task;
                } else {
                    return firstReschudleElement != task;
                }
            }

        } else
            this.amount = 0;
        return true;
    }

    private boolean delayTasks(heavyLoad task, int amount) {
        if (task != null)
            return task.computeWithDelay(amount);
        return false;
    }

    private long maxMSPerTick(heavyLoad task) {
        if (task != null) {
            return task.getMilliPerTick();
        }
        return 4;
    }

    @Override
    public void run() {
        long stoptime = System.currentTimeMillis() + MAX_MS_PER_TICK;
        long stoptimeNew = System.currentTimeMillis();

        //while ((!workloadDeque.isEmpty() && System.currentTimeMillis() <= stoptime)) {
        heavyLoad tasks = workloadDeque.poll();
        if (cumputeTasks(tasks)) {
            if (delayTasks(tasks, amount)) {
                if (!(System.currentTimeMillis() <= stoptime)) return;

                if (tasks instanceof SpawnCustomEffects) tasks.compute();
                if (delayTasks(tasks, amount)) {
                    workloadDeque.forEach(task -> {
                        if (!(System.currentTimeMillis() <= stoptimeNew + maxMSPerTick(task))) return;
                        if (!(task instanceof SpawnCustomEffects))
                            task.compute();


                    });


                }
            }
        }
        if (amount % 20 * 3 == 0) {
            System.out.println("remove from map ");
            for (Map.Entry<Object, queueCheck> entetys : map.entrySet()) {

                if (TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()) >= entetys.getValue().getAddedtime())
                    map.remove(entetys.getKey());
            }
        }
        amount++;

    }

    public static class queueCheck {

        private long addedtime;
        private LinkedList<heavyLoad> task;

        public queueCheck() {
        }

        public queueCheck(long addedtime, LinkedList<heavyLoad> task) {
            this.addedtime = addedtime;
            this.task = task;
        }

        public static queueCheck of(long addedtime, LinkedList<heavyLoad> task) {
            queueCheck data = new queueCheck();
            data.addedtime = addedtime;
            data.task = task;

            return data;
        }

        public long getAddedtime() {
            return addedtime;
        }

        public LinkedList<heavyLoad> getTask() {
            return task;
        }
    }
}