/*
 * Copyright (c) 2007, 2011, Oracle  and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

package com.sun.javafx.tk.desktop;


import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.lang.reflect.Method;
import java.security.PrivilegedAction;
import java.util.Map;

import javafx.animation.Timeline;

import com.sun.javafx.tk.Toolkit;
import com.sun.scenario.DelayedRunnable;
import com.sun.scenario.Settings;
import com.sun.scenario.animation.AbstractMasterTimer;
import com.sun.scenario.animation.AnimationPulse;

/**
 * This class encapsulates the global static methods that manage scheduling and
 * actual running of animations against real wall clock time. It only deals in
 * absolute time values - all relative times that are specified in the
 * {@link Clip} and {@link Timeline} classes will need to be turned into
 * absolute times when the {@code Clip} and {@code Timeline} objects are
 * started.
 *
 * For now it is hidden until we have some use to expose it.
 */
public final class MasterTimer extends AbstractMasterTimer {

    // This PropertyChangeListener is added to Settings to listen for changes
    // to the nogap and fullspeed properties.
    private static PropertyChangeListener pcl = new PropertyChangeListener() {
        public void propertyChange(PropertyChangeEvent event) {
            if (event.getPropertyName().equals(NOGAPS_PROP)) {
                nogaps = Settings.getBoolean(NOGAPS_PROP);
            } else if (event.getPropertyName().equals(FULLSPEED_PROP)) {
                fullspeed = Settings.getBoolean(FULLSPEED_PROP);
            } else if (event.getPropertyName().equals(ADAPTIVE_PULSE_PROP)) {
                useAdaptivePulse = Settings.getBoolean(ADAPTIVE_PULSE_PROP);
            } else if (event.getPropertyName().equals(ANIMATION_MBEAN_ENABLED)) {
                AnimationPulse.getDefaultBean()
                  .setEnabled(Settings.getBoolean(ANIMATION_MBEAN_ENABLED));
            }
        }
    };

    /* Class to obtain AppContext-related reflection info */
    private static ReflectAppContext reflectInfo = null;
    private static class ReflectAppContext implements PrivilegedAction {
        Class clazz = null;
        Method getAppCtx = null;
        Method isDisposed = null;

        public Object run() {
            try {
                clazz = Class.forName("sun.awt.AppContext", true, null);
                getAppCtx = clazz.getDeclaredMethod("getAppContext",(Class[])null);
                isDisposed = clazz.getDeclaredMethod("isDisposed",(Class[])null);
            } catch (ClassNotFoundException e) {
            } catch (NoSuchMethodException e) {}
            return null;
        }
    }

    static {
        Settings.addPropertyChangeListener(NOGAPS_PROP, pcl);
        Settings.addPropertyChangeListener(ADAPTIVE_PULSE_PROP, pcl);
        Settings.addPropertyChangeListener(FULLSPEED_PROP, pcl);
        Settings.addPropertyChangeListener(ANIMATION_MBEAN_ENABLED, pcl);
    }

    /** Prevent external instantiation of MasterTimer */
    private MasterTimer() {
    }

    private static final Object MASTER_TIMER_KEY = new StringBuilder(
            "MasterTimerKey");

    public static synchronized MasterTimer getInstance() {
        Map<Object, Object> contextMap = Toolkit.getToolkit().getContextMap();
        MasterTimer instance = (MasterTimer) contextMap.get(MASTER_TIMER_KEY);
        if (instance == null) {
            instance = new MasterTimer();
            contextMap.put(MASTER_TIMER_KEY, instance);
            if (Settings.getBoolean(ANIMATION_MBEAN_ENABLED,
                                    enableAnimationMBean)) {
                AnimationPulse.getDefaultBean().setEnabled(true);
            }
        }
        return instance;
    }

    protected boolean shouldUseNanoTime() {
        boolean useNanoTimeTmp = false;
        try {
            System.nanoTime();
            useNanoTimeTmp = true;
        } catch (NoSuchMethodError e) {
        }
        return useNanoTimeTmp;
    }

    /*
     * Called to set the value of PULSE_DURATION or PULSE_DURATION_NS based on
     * the refresh rate of the primary screen (unless overridden by the
     * FRAMERATE_PROP Setting). If the refresh rate can not be determined the
     * default of 60hz is used.
     *
     * @param precision - precision in (1000 for ms or 1000000000 for ns)
     *
     * @return pulse duration value, either in ms or ns depending on the
     * parameter.
     */
    protected int getPulseDuration(int precision) {
        int retVal = precision / 60;
        // Allow Setting to override monitor refresh
        if (Settings.get(FRAMERATE_PROP) != null) {
            int overrideHz = Settings.getInt(FRAMERATE_PROP, 60);
            if (overrideHz > 0) {
                retVal = precision / overrideHz;
            }
        } else if (Settings.get(PULSE_PROP) != null) {
            int overrideHz = Settings.getInt(PULSE_PROP, 60);
            if (overrideHz > 0) {
                retVal = precision / overrideHz;
            }
        } else {
            // If not explicitly set in Settings, try to set based on
            // refresh rate of display
            int rate = Toolkit.getToolkit().getRefreshRate();
            if (rate > 0) {
                retVal = precision / rate;
            }
            // if unknown, use default
        }
        return retVal;
    }

    protected void postUpdateAnimationRunnable(DelayedRunnable animationRunnable) {
        Toolkit.getToolkit().setAnimationRunnable(animationRunnable);
    }

    /**
     * Process all runList and waitList entries that should be
     * active for the specified clock tick.
     *
     * @param now the absolute time of the current clock tick
     */
    static void timePulse(long now) {
        getInstance().timePulseImpl(now);
    }

    @Override
    protected void recordStart(long shiftMillis) {
        AnimationPulse.getDefaultBean().recordStart(shiftMillis);
    }

    @Override
    protected void recordEnd() {
        AnimationPulse.getDefaultBean().recordEnd();
    }

    @Override
    protected void recordAnimationEnd() {
        AnimationPulse.getDefaultBean().recordAnimationEnd();
    }
}
