/*
 * Copyright 2009 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */
package akka.util.internal;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Iterator;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import akka.dispatch.sysmsg.SystemMessage;
import akka.util.Helpers;
import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
import akka.event.LoggingAdapter;
import akka.util.Unsafe;

/**
 * A {@link Timer} optimized for approximated I/O timeout scheduling.
 *
 * <h3>Tick Duration</h3>
 *
 * As described with 'approximated', this timer does not execute the scheduled
 * {@link TimerTask} on time.  {@link HashedWheelTimer}, on every tick, will
 * check if there are any {@link TimerTask}s behind the schedule and execute
 * them.
 * <p>
 * You can increase or decrease the accuracy of the execution timing by
 * specifying smaller or larger tick duration in the constructor.  In most
 * network applications, I/O timeout does not need to be accurate.  Therefore,
 * the default tick duration is 100 milliseconds and you will not need to try
 * different configurations in most cases.
 *
 * <h3>Ticks per Wheel (Wheel Size)</h3>
 *
 * {@link HashedWheelTimer} maintains a data structure called 'wheel'.
 * To put simply, a wheel is a hash table of {@link TimerTask}s whose hash
 * function is 'dead line of the task'.  The default number of ticks per wheel
 * (i.e. the size of the wheel) is 512.  You could specify a larger value
 * if you are going to schedule a lot of timeouts.
 *
 * <h3>Do not create many instances.</h3>
 *
 * {@link HashedWheelTimer} creates a new thread whenever it is instantiated and
 * started.  Therefore, you should make sure to create only one instance and
 * share it across your application.  One of the common mistakes, that makes
 * your application unresponsive, is to create a new instance in
 * {@link ChannelPipelineFactory}, which results in the creation of a new thread
 * for every connection.
 *
 * <h3>Implementation Details</h3>
 *
 * {@link HashedWheelTimer} is based on
 * <a href="http://cseweb.ucsd.edu/users/varghese/">George Varghese</a> and
 * Tony Lauck's paper,
 * <a href="http://cseweb.ucsd.edu/users/varghese/PAPERS/twheel.ps.Z">'Hashed
 * and Hierarchical Timing Wheels: data structures to efficiently implement a
 * timer facility'</a>.  More comprehensive slides are located
 * <a href="http://www.cse.wustl.edu/~cdgill/courses/cs6874/TimingWheels.ppt">here</a>.
 *
 * @author <a href="http://www.jboss.org/netty/">The Netty Project</a>
 * @author <a href="http://gleamynode.net/">Trustin Lee</a>
 * @version $Rev: 2297 $, $Date: 2010-06-07 10:50:02 +0900 (Mon, 07 Jun 2010) $
 *
 * The original implementation has been slightly altered to fit the specific requirements of Akka.
 * 
 * Specifically: it is required to throw an IllegalStateException if a job 
 * cannot be queued. If no such exception is thrown, the job must be executed
 * (or returned upon stop()).
 */
@Deprecated
public class HashedWheelTimer implements Timer {
    private final Worker worker = new Worker();
    final Thread workerThread;
    boolean shutdown = false;
    final long tickDuration;
    final Set<HashedWheelTimeout>[] wheel;
    final int mask;
    final ReadWriteLock lock = new ReentrantReadWriteLock();
    volatile int wheelCursor;
    private LoggingAdapter logger;

    /**
     * Creates a new timer.
     *
     * @param threadFactory  a {@link java.util.concurrent.ThreadFactory} that creates a
     *                       background {@link Thread} which is dedicated to
     *                       {@link TimerTask} execution.
     * @param duration       the duration between ticks
     * @param ticksPerWheel  the size of the wheel
     */
    public HashedWheelTimer(
            LoggingAdapter logger,
            ThreadFactory threadFactory,
            Duration duration,
            int ticksPerWheel) {

        if (threadFactory == null) {
            throw new NullPointerException("threadFactory");
        }
        if (duration == null) {
            throw new NullPointerException("duration");
        }
        if (duration.toNanos() <= 0) {
            throw new IllegalArgumentException("duration must be greater than 0 ns: " + duration.toNanos());
        }
        if (ticksPerWheel <= 0) {
            throw new IllegalArgumentException("ticksPerWheel must be greater than 0: " + ticksPerWheel);
        }

        this.logger = logger;

        // Normalize ticksPerWheel to power of two and initialize the wheel.
        wheel = createWheel(ticksPerWheel);
        mask = wheel.length - 1;

        // Convert to standardized tickDuration
        this.tickDuration = duration.toNanos();

        // Prevent overflow.
        if (tickDuration == Long.MAX_VALUE || tickDuration >= Long.MAX_VALUE / wheel.length) {
            throw new IllegalArgumentException("tickDuration is too long: " + tickDuration +  ' ' + duration.unit());
        }

        workerThread = threadFactory.newThread(worker);
    }

    @SuppressWarnings("unchecked")
    private static Set<HashedWheelTimeout>[] createWheel(final int ticksPerWheel) {
        if (ticksPerWheel <= 0) {
            throw new IllegalArgumentException("ticksPerWheel must be greater than 0: " + ticksPerWheel);
        }
        if (ticksPerWheel > 1073741824) {
            throw new IllegalArgumentException("ticksPerWheel may not be greater than 2^30: " + ticksPerWheel);
        }

        final Set<HashedWheelTimeout>[] wheel = new Set[normalizeTicksPerWheel(ticksPerWheel)];
        for (int i = 0; i < wheel.length; i ++) {
            wheel[i] = Collections.newSetFromMap(new ConcurrentHashMap<HashedWheelTimeout, Boolean>(16, 0.95f, 4));
        }
        return wheel;
    }

    private static int normalizeTicksPerWheel(int ticksPerWheel) {
        int normalizedTicksPerWheel = 1;
        while (normalizedTicksPerWheel < ticksPerWheel) {
            normalizedTicksPerWheel <<= 1;
        }
        return normalizedTicksPerWheel;
    }

    /**
     * Starts the background thread explicitly.  The background thread will
     * start automatically on demand even if you did not call this method.
     *
     * @throws IllegalStateException if this timer has been
     *                               {@linkplain #stop() stopped} already
     */
    public synchronized void start() {
        lock.readLock().lock();
        try {
            if (shutdown) {
                throw new IllegalStateException("cannot be started once stopped");
            }

            if (!workerThread.isAlive()) {
                workerThread.start();
            }
        } finally {
            lock.readLock().unlock();
        }
    }

    public synchronized Set<Timeout> stop() {
        if (Thread.currentThread() == workerThread) {
            throw new IllegalStateException(
                    HashedWheelTimer.class.getSimpleName() +
                    ".stop() cannot be called from " +
                    TimerTask.class.getSimpleName());
        }

        lock.writeLock().lock();
        try {
            if (shutdown) {
                return Collections.emptySet();
            } else {
                shutdown = true;
            }
        } finally {
            lock.writeLock().unlock();
        }

        boolean interrupted = false;
        while (workerThread.isAlive()) {
            workerThread.interrupt();
            try {
                workerThread.join(100);
            } catch (InterruptedException e) {
                interrupted = true;
            }
        }

        if (interrupted) {
            Thread.currentThread().interrupt();
        }

        Set<Timeout> unprocessedTimeouts = new HashSet<Timeout>();
        for (Set<HashedWheelTimeout> bucket: wheel) {
            unprocessedTimeouts.addAll(bucket);
            bucket.clear();
        }

        return Collections.unmodifiableSet(unprocessedTimeouts);
    }
    
    public HashedWheelTimeout createTimeout(TimerTask task, long time) {
        return new HashedWheelTimeout(this, task, time);
    }

    public Timeout newTimeout(TimerTask task, FiniteDuration delay) {
        final long currentTime = System.nanoTime();

        if (task == null) {
            throw new NullPointerException("task");
        }
        if (delay == null) {
            throw new NullPointerException("delay");
        }

        if (!workerThread.isAlive()) {
            start();
        }

        HashedWheelTimeout timeout = createTimeout(task, currentTime + delay.toNanos());
        scheduleTimeout(timeout, delay.toNanos());
        return timeout;
    }

    void scheduleTimeout(HashedWheelTimeout timeout, long delay) {
        // Prepare the required parameters to schedule the timeout object.
        long relativeIndex = (delay + tickDuration - 1) / tickDuration;
        // if the previous line had an overflow going on, then we’ll just schedule this timeout
        // one tick early; that shouldn’t matter since we’re talking 270 years here
        if (relativeIndex < 0) relativeIndex = delay / tickDuration;
        if (relativeIndex == 0) relativeIndex = 1;
        // if an integral number of wheel rotations, schedule one tick earlier
        if ((relativeIndex & mask) == 0) relativeIndex--;
        final long remainingRounds = relativeIndex / wheel.length;

        // Add the timeout to the wheel.
        lock.readLock().lock();
        try {
            if (shutdown) throw new IllegalStateException("cannot enqueue after shutdown");
            final int stopIndex = (int) ((wheelCursor + relativeIndex) & mask);
            timeout.stopIndex = stopIndex;
            timeout.remainingRounds = remainingRounds;
            wheel[stopIndex].add(timeout);
        } finally {
            lock.readLock().unlock();
        }
    }

    private final class Worker implements Runnable {

        private long startTime;
        private long tick;

        Worker() {
            super();
        }
        
        private boolean shutdown() {
            lock.readLock().lock();
            try {
                return shutdown;
            } finally {
                lock.readLock().unlock();
            }
        }

        public void run() {
            startTime = System.nanoTime();
            tick = 1;

            while (!shutdown()) {
                final long deadline = waitForNextTick();
                if (deadline > Long.MIN_VALUE)
                    notifyExpiredTimeouts(fetchExpiredTimeouts(deadline));
            }
        }

        private ArrayList<HashedWheelTimeout> fetchExpiredTimeouts(long deadline) {

            // Find the expired timeouts and decrease the round counter
            // if necessary.  Note that we don't send the notification
            // immediately to make sure the listeners are called without
            // an exclusive lock.
            lock.writeLock().lock();
            try {
                final int newWheelCursor = wheelCursor = wheelCursor + 1 & mask;
                return fetchExpiredTimeouts(wheel[newWheelCursor], deadline);
            } finally {
                lock.writeLock().unlock();
            }
        }

        private ArrayList<HashedWheelTimeout> fetchExpiredTimeouts(final Iterable<HashedWheelTimeout> it, final long deadline) {
            final ArrayList<HashedWheelTimeout> expiredTimeouts = new ArrayList<HashedWheelTimeout>();
            List<HashedWheelTimeout> slipped = null;
            Iterator<HashedWheelTimeout> i = it.iterator();
            while (i.hasNext()) {
                HashedWheelTimeout timeout = i.next();
                if (timeout.remainingRounds <= 0) {
                    i.remove();
                    if (timeout.deadline - deadline <= 0) {
                        expiredTimeouts.add(timeout);
                    } else {
                        // Handle the case where the timeout is put into a wrong
                        // place, usually one tick earlier.  For now, just add
                        // it to a temporary list - we will reschedule it in a
                        // separate loop.
                        if (slipped == null)
                            slipped = new ArrayList<HashedWheelTimeout>();

                        slipped.add(timeout);
                    }
                } else {
                    timeout.remainingRounds -= 1;
                }
            }

            // Reschedule the slipped timeouts.
            if (slipped != null) {
                for (HashedWheelTimeout timeout: slipped) {
                    scheduleTimeout(timeout, timeout.deadline - deadline);
                }
            }
            return expiredTimeouts;
        }

        private void notifyExpiredTimeouts(ArrayList<HashedWheelTimeout> expiredTimeouts) {
            // Notify the expired timeouts.
            for (int i = expiredTimeouts.size() - 1; i >= 0; i --) {
                expiredTimeouts.get(i).expire();
            }

            // Clean up the temporary list.
            expiredTimeouts.clear();
        }

        /**
         * calculate goal nanoTime from startTime and current tick number,
         * then wait until that goal has been reached.
         * 
         * @return Long.MIN_VALUE if received a shutdown request, current time otherwise (with Long.MIN_VALUE changed by +1)
         */
        private long waitForNextTick() {
            long deadline = startTime + tickDuration * tick;

            for (;;) {
                final long currentTime = System.nanoTime();

                long sleepTimeMs = (deadline - currentTime + 999999) / 1000000;

                if (sleepTimeMs <= 0) {
                    tick += 1;
                    if (currentTime == Long.MIN_VALUE) return -Long.MAX_VALUE;
                    else return currentTime;
                }

                // Check if we run on windows, as if thats the case we will need
                // to round the sleepTime as workaround for a bug that only affect
                // the JVM if it runs on windows.
                //
                // See https://github.com/netty/netty/issues/356
                if (Helpers.isWindows()) {
                  sleepTimeMs = (sleepTimeMs / 10) * 10;
                }
                
                try {
                    Thread.sleep(sleepTimeMs);
                } catch (InterruptedException e) {
                    if (shutdown()) {
                        return Long.MIN_VALUE;
                    }
                }
            }
        }
    }

    private static final class HashedWheelTimeout implements Timeout {
        private static final long _stateOffset;

        static {
            try {
              _stateOffset = Unsafe.instance.objectFieldOffset(HashedWheelTimeout.class.getDeclaredField("_state"));
            } catch(Throwable t){
                throw new ExceptionInInitializerError(t);
            }
        }

        private static final int ST_INIT = 0;
        private static final int ST_CANCELLED = 1;
        private static final int ST_EXPIRED = 2;

        private final HashedWheelTimer parent;
        private final TimerTask task;
        final long deadline;
        volatile int stopIndex;
        volatile long remainingRounds;
        @SuppressWarnings("unused")
        private volatile int _state = ST_INIT;

        HashedWheelTimeout(HashedWheelTimer parent, TimerTask task, long deadline) {
            this.parent = parent;
            this.task = task;
            this.deadline = deadline;
        }

        public Timer getTimer() {
            return parent;
        }

        public TimerTask getTask() {
            return task;
        }

        private final int state() {
            return Unsafe.instance.getIntVolatile(this, _stateOffset);
        }
        private final boolean updateState(int old, int future) {
            return Unsafe.instance.compareAndSwapInt(this, _stateOffset, old, future);
        }

        public boolean cancel() {
            if (updateState(ST_INIT, ST_CANCELLED)) {
              parent.wheel[stopIndex].remove(this);
              return true;
            } else return false;
        }

        public boolean isCancelled() {
            return state() == ST_CANCELLED;
        }

        public boolean isExpired() {
            return state() != ST_INIT;
        }

        public void expire() {
            if (updateState(ST_INIT, ST_EXPIRED)) {
                try {
                    task.run(this);
                } catch (Throwable t) {
                    parent.logger.warning(
                            "An exception was thrown by " +
                            TimerTask.class.getSimpleName() + ".", t);
                }
            }
        }

        @Override public final int hashCode() {
            return System.identityHashCode(this);
        }

        @Override public final boolean equals(final Object that) {
            return this == that;
        }

        @Override
        public String toString() {
            final long currentTime = System.nanoTime();
            final long remaining = deadline - currentTime;

            StringBuilder buf = new StringBuilder(192);
            buf.append("HashedWheelTimeout");
            buf.append('(');

            buf.append("deadline: ");
            if (remaining > 0) {
                buf.append(remaining);
                buf.append(" ns later, ");
            } else if (remaining < 0) {
                buf.append(-remaining);
                buf.append(" ns ago, ");
            } else {
                buf.append("now, ");
            }

            if (isCancelled()) {
                buf.append (", cancelled");
            }

            return buf.append(')').toString();
        }
    }
}