/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF 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 org.apache.jackrabbit.util;

import javax.jcr.Node;
import javax.jcr.Repository;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.lock.Lock;
import javax.jcr.lock.LockException;
import javax.jcr.lock.LockManager;
import javax.jcr.observation.Event;
import javax.jcr.observation.EventIterator;
import javax.jcr.observation.EventListener;
import javax.jcr.observation.ObservationManager;

/**
 * <code>Locked</code> is a utility to synchronize modifications on a lockable
 * node. The modification is applied while the lock on the node is held, thus
 * ensuring that the modification will never fail with an {@link
 * javax.jcr.InvalidItemStateException}. This utility can be used with any
 * JCR Repository, not just Jackrabbit.
 * <p/>
 * The following example shows how this utility can be used to implement
 * a persistent counter:
 * <pre>
 * Node counter = ...;
 * long nextValue = ((Long) new Locked() {
 *     protected Object run(Node counter) throws RepositoryException {
 *         Property seqProp = counter.getProperty("value");
 *         long value = seqProp.getLong();
 *         seqProp.setValue(++value);
 *         seqProp.save();
 *         return new Long(value);
 *     }
 * }.with(counter, false)).longValue();
 * </pre>
 * If you specify a <code>timeout</code> you need to check the return value
 * whether the <code>run</code> method could be executed within the timeout
 * period:
 * <pre>
 * Node counter = ...;
 * Object ret = new Locked() {
 *     protected Object run(Node counter) throws RepositoryException {
 *         Property seqProp = counter.getProperty("value");
 *         long value = seqProp.getLong();
 *         seqProp.setValue(++value);
 *         seqProp.save();
 *         return new Long(value);
 *     }
 * }.with(counter, false);
 * if (ret == Locked.TIMED_OUT) {
 *     // do whatever you think is appropriate in this case
 * } else {
 *     // get the value
 *     long nextValue = ((Long) ret).longValue();
 * }
 * </pre>
 */
public abstract class Locked {

    /** The mixin namespace */
    private static final String MIX = "http://www.jcp.org/jcr/mix/1.0";

    /**
     * Object returned when timeout is reached without being able to call
     * {@link #run} while holding the lock.
     */
    public static final Object TIMED_OUT = new Object();

    /**
     * Executes {@link #run} while the lock on <code>lockable</code> is held.
     * This method will block until {@link #run} is executed while holding the
     * lock on node <code>lockable</code>.
     *
     * @param lockable a lockable node.
     * @param isDeep   <code>true</code> if <code>lockable</code> will be locked
     *                 deep.
     * @return the object returned by {@link #run}.
     * @throws IllegalArgumentException if <code>lockable</code> is not
     *      <i>mix:lockable</i>.
     * @throws RepositoryException  if {@link #run} throws an exception.
     * @throws InterruptedException if this thread is interrupted while waiting
     *                              for the lock on node <code>lockable</code>.
     */
    public Object with(Node lockable, boolean isDeep)
            throws RepositoryException, InterruptedException {
        return with(lockable, isDeep, true);
    }

    /**
     * Executes {@link #run} while the lock on <code>lockable</code> is held.
     * This method will block until {@link #run} is executed while holding the
     * lock on node <code>lockable</code>.
     *
     * @param lockable a lockable node.
     * @param isDeep   <code>true</code> if <code>lockable</code> will be locked
     *                 deep.
     * @param isSessionScoped <code>true</code> if the lock is session scoped.
     * @return the object returned by {@link #run}.
     * @throws IllegalArgumentException if <code>lockable</code> is not
     *      <i>mix:lockable</i>.
     * @throws RepositoryException  if {@link #run} throws an exception.
     * @throws InterruptedException if this thread is interrupted while waiting
     *                              for the lock on node <code>lockable</code>.
     */
    public Object with(Node lockable, boolean isDeep, boolean isSessionScoped)
            throws RepositoryException, InterruptedException {
        return with(lockable, isDeep, Long.MAX_VALUE, isSessionScoped);
    }

    /**
     * Executes the method {@link #run} within the scope of a lock held on
     * <code>lockable</code>.
     *
     * @param lockable the node where the lock is obtained from.
     * @param isDeep   <code>true</code> if <code>lockable</code> will be locked
     *                 deep.
     * @param timeout  time in milliseconds to wait at most to acquire the lock.
     * @return the object returned by {@link #run} or {@link #TIMED_OUT} if the
     *         lock on <code>lockable</code> could not be acquired within the
     *         specified timeout.
     * @throws IllegalArgumentException if <code>timeout</code> is negative or
     *                                  <code>lockable</code> is not
     *                                  <i>mix:lockable</i>.
     * @throws RepositoryException      if {@link #run} throws an exception.
     * @throws UnsupportedRepositoryOperationException
     *                                  if this repository does not support
     *                                  locking.
     * @throws InterruptedException     if this thread is interrupted while
     *                                  waiting for the lock on node
     *                                  <code>lockable</code>.
     */
    public Object with(Node lockable, boolean isDeep, long timeout)
            throws UnsupportedRepositoryOperationException, RepositoryException, InterruptedException {
        return with(lockable, isDeep, timeout, true);
    }

    /**
     * Executes the method {@link #run} within the scope of a lock held on
     * <code>lockable</code>.
     *
     * @param lockable the node where the lock is obtained from.
     * @param isDeep   <code>true</code> if <code>lockable</code> will be locked
     *                 deep.
     * @param timeout  time in milliseconds to wait at most to acquire the lock.
     * @param isSessionScoped <code>true</code> if the lock is session scoped.
     * @return the object returned by {@link #run} or {@link #TIMED_OUT} if the
     *         lock on <code>lockable</code> could not be acquired within the
     *         specified timeout.
     * @throws IllegalArgumentException if <code>timeout</code> is negative or
     *                                  <code>lockable</code> is not
     *                                  <i>mix:lockable</i>.
     * @throws RepositoryException      if {@link #run} throws an exception.
     * @throws UnsupportedRepositoryOperationException
     *                                  if this repository does not support
     *                                  locking.
     * @throws InterruptedException     if this thread is interrupted while
     *                                  waiting for the lock on node
     *                                  <code>lockable</code>.
     */
    public Object with(Node lockable, boolean isDeep, long timeout, boolean isSessionScoped)
            throws UnsupportedRepositoryOperationException, RepositoryException, InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout must be >= 0");
        }

        Session session = lockable.getSession();

        EventListener listener = null;
        try {
            // check whether the lockable can be locked at all
            String mix = session.getNamespacePrefix(MIX);
            if (!lockable.isNodeType(mix + ":lockable")) {
                throw new IllegalArgumentException("Node is not lockable");
            }

            Lock lock = tryLock(lockable, isDeep, timeout, isSessionScoped);
            if (lock != null) {
                return runAndUnlock(lock);
            }

            if (timeout == 0) {
                return TIMED_OUT;
            }

            long timelimit;
            if (timeout == Long.MAX_VALUE) {
                timelimit = Long.MAX_VALUE;
            } else {
                timelimit = System.currentTimeMillis() + timeout;
            }

            // node is locked by other session -> register event listener if possible
            if (isObservationSupported(session)) {
                ObservationManager om = session.getWorkspace().getObservationManager();
                listener = new EventListener() {
                    public void onEvent(EventIterator events) {
                        synchronized (Locked.this) {
                            Locked.this.notify();
                        }
                    }
                };
                om.addEventListener(listener, Event.PROPERTY_REMOVED,
                        lockable.getPath(), false, null, null, true);
            }

            // now keep trying to acquire the lock
            // using 'this' as a monitor allows the event listener to notify
            // the current thread when the lockable node is possibly unlocked
            for (; ;) {
                synchronized (this) {
                    lock = tryLock(lockable, isDeep, timeout, isSessionScoped);
                    if (lock != null) {
                        return runAndUnlock(lock);
                    } else {
                        // check timeout
                        if (System.currentTimeMillis() > timelimit) {
                            return TIMED_OUT;
                        }
                        if (listener != null) {
                            // event listener *should* wake us up, however
                            // there is a chance that removal of the lockOwner
                            // property is notified before the node is acutally
                            // unlocked. therefore we use a safety net to wait
                            // at most 1000 millis.
                            this.wait(Math.min(1000, timeout));
                        } else {
                            // repository does not support observation
                            // wait at most 50 millis then retry
                            this.wait(Math.min(50, timeout));
                        }
                    }
                }
            }
        } finally {
            if (listener != null) {
                session.getWorkspace().getObservationManager().removeEventListener(listener);
            }
        }
    }

    /**
     * This method is executed while holding the lock.
     * @param node The <code>Node</code> on which the lock is placed.
     * @return an object which is then returned by {@link #with with()}.
     * @throws RepositoryException if an error occurs.
     */
    protected abstract Object run(Node node) throws RepositoryException;

    /**
     * Executes {@link #run} and unlocks the lockable node in any case, even
     * when an exception is thrown.
     *
     * @param lock The <code>Lock</code> to unlock in any case before returning.
     *
     * @return the object returned by {@link #run}.
     * @throws RepositoryException if an error occurs.
     */
    private Object runAndUnlock(Lock lock) throws RepositoryException {
        Node node = lock.getNode();
        try {
            return run(node);
        } finally {
            node.getSession().getWorkspace().getLockManager().unlock(node.getPath());
        }
    }

    /**
     * Tries to acquire a session scoped lock on <code>lockable</code>.
     *
     * @param lockable the lockable node
     * @param isDeep   <code>true</code> if the lock should be deep
     * @param timeout  time in milliseconds to wait at most to acquire the lock.
     * @param isSessionScoped <code>true</code> if the lock is session scoped.
     * @return The <code>Lock</code> or <code>null</code> if the
     *         <code>lockable</code> cannot be locked.
     * @throws UnsupportedRepositoryOperationException
     *                             if this repository does not support locking.
     * @throws RepositoryException if an error occurs
     */
    private static Lock tryLock(Node lockable, boolean isDeep, long timeout, boolean isSessionScoped)
            throws UnsupportedRepositoryOperationException, RepositoryException {
        try {
            LockManager lm = lockable.getSession().getWorkspace().getLockManager();
            return lm.lock(lockable.getPath(), isDeep, isSessionScoped, timeout, null);
        } catch (LockException e) {
            // locked by some other session
        }
        return null;
    }

    /**
     * Returns <code>true</code> if the repository supports observation.
     *
     * @param s a session of the repository.
     * @return <code>true</code> if the repository supports observation.
     */
    private static boolean isObservationSupported(Session s) {
        return "true".equalsIgnoreCase(s.getRepository().getDescriptor(Repository.OPTION_OBSERVATION_SUPPORTED));
    }

}
