package engine.util;

import java.util.HashMap;

public class ThreadSync {
    private static HashMap<Thread,Long> variableYieldTimeMap;
    private static HashMap<Thread,Long> lastTimeMap;

    static {
        variableYieldTimeMap = new HashMap<Thread,Long>();
        lastTimeMap = new HashMap<Thread,Long>();
    }

    /**
     * An accurate sync method that adapts automatically
     * to the system it runs on to provide reliable results.
     *
     * @param fps The desired frame rate, in frames per second
     */
    public static void sync(int fps) {
        Thread c = checkThread();
        long variableYieldTime = variableYieldTimeMap.get(c);
        long lastTime = lastTimeMap.get(c);

        if (fps <= 0) return;
        long overSleep = 0; // time the sync goes over by
        long sleepTime = 1000000000 / fps; // nanoseconds to sleep this frame

        try {
            while (true) {
                sleepTime = 1000000000 / fps;
                long yieldTime = Math.min(sleepTime, variableYieldTime + sleepTime % (1000*1000));

                long t = System.nanoTime() - lastTime;

                if (t < sleepTime - yieldTime) {
                    Thread.sleep(2);
                }
                else if (t < sleepTime) {
                    // burn the last few CPU cycles to ensure accuracy
                    Thread.yield();
                }
                else {
                    overSleep = t - sleepTime;
                    break; // exit while loop
                }
            }
        } catch (InterruptedException e) {}

        lastTimeMap.put(c, System.nanoTime() - Math.min(overSleep, sleepTime));

        // auto tune the time sync should yield
        if (overSleep > variableYieldTime) {
            // increase by 200 microseconds (1/5 a ms)
            variableYieldTimeMap.put(c, Math.min(variableYieldTime + 200*1000, sleepTime));
        }else if (overSleep < variableYieldTime - 200*1000) {
            // decrease by 2 microseconds
            variableYieldTimeMap.put(c, Math.max(variableYieldTime - 2*1000, 0));
        }
    }

    private static Thread checkThread() {
        Thread c = Thread.currentThread();
        if ( !variableYieldTimeMap.containsKey(c) )
            variableYieldTimeMap.put(c, (long) 0);
        if ( !lastTimeMap.containsKey(c) )
            lastTimeMap.put(c, (long) 0);

        return c;
    }

}