package me.km.scheduler;

import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import me.hammerle.code.ISnuviScheduler;
import me.km.api.Module;
import net.minecraft.util.text.TextFormatting;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

@SideOnly(Side.SERVER)
public class SnuviScheduler extends Module implements ISnuviScheduler
{
    private boolean checker;
    private int counter;
    private final LinkedList<SnuviTask> addQueue;
    private final LinkedList<Integer> removeQueue;
    private final HashMap<Integer, SnuviTask> tasks;
    
    public SnuviScheduler(String mname, String prefix, TextFormatting color)
    {
        super(mname, prefix, color);
        counter = 0;
        tasks = new HashMap<>();
        addQueue = new LinkedList<>();
        removeQueue = new LinkedList<>();
    }
    
    public void cancelTask(int id)
    {
        removeQueue.add(id);
    }
    
    public int scheduleRepeatingTask(Runnable r, long ticks, long rtimer)
    {
        counter++;
        addQueue.add(new SnuviTask(counter, r, ticks, rtimer));
        return counter;
    }
    
    @Override
    public int scheduleTask(Runnable r, long delay)
    { 
        return scheduleRepeatingTask(r, delay, 0);
    }
    
    @Override
    public int scheduleTask(Runnable r)
    { 
        return scheduleTask(r, 0);
    }
    
    public void tick()
    {
        try
        {
            if(!removeQueue.isEmpty())
            {
                removeQueue.forEach(i -> tasks.remove(i));
                removeQueue.clear();
            }
            if(!addQueue.isEmpty())
            {
                addQueue.forEach(task -> tasks.put(task.getId(), task));
                addQueue.clear();
            }
            checker = false;
            long l = System.currentTimeMillis();
            tasks.values().removeIf(task -> 
            {
                if(checker)
                {
                    return false;
                }
                if(System.currentTimeMillis() - l > 25)
                {
                    checker = true;
                    this.sendWarningToConsole("Der Scheduler ist länger als 25 ms gelaufen.");
                    return false;
                }
                return task.tick();
            });
        }
        catch(ConcurrentModificationException ex)
        {
            this.sendWarningToConsole(ex.toString());
        }
    }
    
    public static void scheduleAsyncTask(Runnable r)
    {
        scheduleAsyncTask(r, 1);
    }
    
    public static void scheduleAsyncTask(Runnable r, long ticks)
    {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();  
        executor.schedule(r, ticks * 50, TimeUnit.MILLISECONDS);
        executor.shutdown();
    }
}