/**
    * This file Copyright (c) 2003-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.context;
  
  import info.magnolia.cms.beans.runtime.MultipartForm;
  import info.magnolia.cms.core.AggregationState;
  import info.magnolia.cms.core.HierarchyManager;
  import info.magnolia.cms.core.search.QueryManager;
  import info.magnolia.cms.i18n.Messages;
  import info.magnolia.cms.security.AccessManager;
  import info.magnolia.cms.security.User;
  import info.magnolia.objectfactory.Components;
  
  import java.util.Locale;
  import java.util.Map;
  
  import javax.jcr.InvalidItemStateException;
  import javax.jcr.LoginException;
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.lock.LockException;
  import javax.jcr.lock.LockManager;
  import javax.security.auth.Subject;
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * This class allows obtaining of the current Request without passing the request around the world. A ThreadLocal variable is used to
   * manage the request and to make sure it doesn't escape to another processing.
   * <p>
   * In a later version this class should not depend on servlets. The core should use the context to get and set
   * attributes instead of using the request or session object directly. Magnolia could run then in a neutral and
   * configurable context.
   */
  
  public class MgnlContext {
      private static final Logger log = LoggerFactory.getLogger(MgnlContext.class);
  
      /**
       * The thread local variable holding the current context.
       */
      private static ThreadLocal<Context> localContext = new ThreadLocal<Context>();
  
      /**
       * Do not instantiate this class. The constructor must be public to use discovery
       */
      public MgnlContext() {
      }
  
      /**
       * A short cut for the current user.
       *
       * @return the current user
       */
      public static User getUser() {
          return getInstance().getUser();
      }
  
      /**
       * Set the locale for the current context.
       */
      public static void setLocale(Locale locale) {
         getInstance().setLocale(locale);
     }
 
     /**
      * Get the context's locale object.
      *
      * @return the current locale
      */
     public static Locale getLocale() {
         return getInstance().getLocale();
     }
 
     public static Messages getMessages() {
         return getInstance().getMessages();
     }
 
     public static Messages getMessages(String basename) {
         return getInstance().getMessages(basename);
     }
 
     public static void login(Subject subject) {
         ((UserContext) getInstance()).login(subject);
     }
 
     /**
      * Get hierarchy manager initialized for this user.
      *
      * @deprecated since 4.5 - use {@link #getJCRSession(String)}
      */
     @Deprecated
     public static HierarchyManager getHierarchyManager(String repositoryId) {
         return getInstance().getHierarchyManager(repositoryId);
     }
 
     /**
      * Get access manager for a resource, usually a workspace.
      */
     public static AccessManager getAccessManager(String name) {
         return getInstance().getAccessManager(name);
     }
 
     /**
      * Get access manager for the specified repository on the specified workspace.
      *
      * @deprecated since 4.5 - use {@link #getJCRSession(String)} and acquire the JCR query manager directly from the session.
      */
     @Deprecated
     public static QueryManager getQueryManager(String workspaceName) {
         return getInstance().getQueryManager(workspaceName);
     }
 
     /**
      * Get form object assembled by <code>MultipartRequestFilter</code>.
      *
      * @return multipart form object
      *         TODO - move to getAggregationState() ?
      */
     public static MultipartForm getPostedForm() {
         WebContext ctx = getWebContextOrNull();
         if (ctx != null) {
             return ctx.getPostedForm();
         }
         return null;
     }
 
     /**
      * Get parameter value as string.
      */
     public static String getParameter(String name) {
         WebContext ctx = getWebContextOrNull();
         if (ctx != null) {
             return ctx.getParameter(name);
         }
         return null;
 
     }
 
     public static String[] getParameterValues(String name) {
         WebContext ctx = getWebContextOrNull();
         if (ctx != null) {
             return ctx.getParameterValues(name);
         }
         return null;
 
     }
 
     /**
      * Get parameter value as a Map&lt;String, String&gt;.
      */
     public static Map<String, String> getParameters() {
         WebContext ctx = getWebContextOrNull();
         if (ctx != null) {
             return ctx.getParameters();
         }
         return null;
     }
 
     /**
      * @return the context path.
      */
     public static String getContextPath() {
         WebContext ctx = getWebContextOrNull();
         if (ctx != null) {
             return ctx.getContextPath();
         }
         throw new IllegalStateException("Can only get the context path within a WebContext.");
     }
 
     /**
      * Returns the AggregationState if we're in a WebContext, throws an
      * IllegalStateException otherwise.
      */
     public static AggregationState getAggregationState() {
         final WebContext ctx = getWebContextOrNull();
         if (ctx != null) {
             return ctx.getAggregationState();
         }
         throw new IllegalStateException("Can only get the aggregation state within a WebContext.");
     }
 
     /**
      * Resets the current aggregation state if we're in a WebContext, throws an IllegalStateException otherwise.
      */
     public static void resetAggregationState() {
         final WebContext ctx = getWebContextOrNull();
         if (ctx != null) {
             ctx.resetAggregationState();
         } else {
             throw new IllegalStateException("Can only reset the aggregation state within a WebContext.");
         }
     }
 
     /**
      * Set attribute value, scope of the attribute is {@link Context#LOCAL_SCOPE}.
      */
     public static void setAttribute(String name, Object value) {
         getInstance().setAttribute(name, value, Context.LOCAL_SCOPE);
     }
 
     /**
      * Set attribute value, scope of the attribute is defined.
      *
      * @param scope , highest level of scope from which this attribute is visible.
      */
     public static void setAttribute(String name, Object value, int scope) {
         getInstance().setAttribute(name, value, scope);
     }
 
     /**
      * Get attribute value.
      */
     public static <T> T getAttribute(String name) {
         return (T) getInstance().getAttribute(name);
     }
 
     /**
      * Get the attribute from the specified scope.
      */
     public static <T> T getAttribute(String name, int scope) {
         return (T) getInstance().getAttribute(name, scope);
     }
 
     /**
      * Check if this attribute exists in the local scope.
      */
     public static boolean hasAttribute(String name) {
         return getInstance().getAttribute(name, Context.LOCAL_SCOPE) != null;
     }
 
     /**
      * Check if this attribute exists in the specified scope.
      */
     public static boolean hasAttribute(String name, int scope) {
         return getInstance().getAttribute(name, scope) != null;
     }
 
     /**
      * Remove an attribute in the local scope.
      */
     public static void removeAttribute(String name) {
         getInstance().removeAttribute(name, Context.LOCAL_SCOPE);
     }
 
     /**
      * Remove an attribute in the specified scope.
      */
     public static void removeAttribute(String name, int scope) {
         getInstance().removeAttribute(name, scope);
     }
 
     /**
      * Set context implementation instance.
      */
     public static void setInstance(Context context) {
         localContext.set(context);
     }
 
     /**
      * Get the current context of this thread.
      */
     public static Context getInstance() {
         Context context = localContext.get();
         // It should never fall back, We need to fix all false callers instead
         if (context == null) {
             final IllegalStateException ise = new IllegalStateException("MgnlContext is not set for this thread");
             log.error("MgnlContext is not initialized. This could happen if the request does not go through the Magnolia default filters.", ise);
             throw ise;
         }
         return context;
     }
 
     /**
      * Throws an IllegalStateException if the current context is not set, or if it is not an instance of WebContext.
      *
      * @see #getWebContext(String)
      */
     public static WebContext getWebContext() {
         return getWebContext(null);
     }
 
     /**
      * Throws an IllegalStateException if the current context is not set, or if it is not an instance of WebContext.
      * Yes, you can specify the exception message if you want. This is useful if you're calling this from a component
      * which only supports WebContext and still care enough to actually throw an exception with a meaningful message.
      *
      * @see #getWebContext()
      */
     public static WebContext getWebContext(String exceptionMessage) {
         final WebContext wc = getWebContextIfExisting(getInstance());
         if (wc == null) {
             throw new IllegalStateException(exceptionMessage == null ? "The current context is not an instance of WebContext (" + localContext.get() + ")" : exceptionMessage);
         }
         return wc;
     }
 
     /**
      * Returns the current context if it is set and is an instance of WebContext, returns null otherwise.
      */
     public static WebContext getWebContextOrNull() {
         return hasInstance() ? getWebContextIfExisting(getInstance()) : null;
     }
 
     /**
      * Used to check if an instance is already set since getInstance() will always return a context.
      *
      * @return true if an instance was set.
      */
     public static boolean hasInstance() {
         return localContext.get() != null;
     }
 
     public static boolean isSystemInstance() {
         return localContext.get() instanceof SystemContext;
     }
 
     /**
      * Returns true if the current context is set and is an instance of WebContext. (it might be wrapped in a ContextDecorator)
      */
     public static boolean isWebContext() {
         return hasInstance() && getWebContextIfExisting(getInstance()) != null;
     }
 
     /**
      * Get Magnolia system context. This context has full permissions over all repositories/ workspaces.
      *
      * @deprecated since 4.5, use IoC, i.e., declare a dependency on SystemContext in your component.
      */
     @Deprecated
     public static SystemContext getSystemContext() {
         return ContextFactory.getInstance().getSystemContext();
     }
 
     /**
      * Executes the given operation in the system context and sets it back to the original once done
      * (also if an exception is thrown). Also works if there was no context upon calling. (sets it back
      * to null in this case)
      */
     public static <T, E extends Throwable> T doInSystemContext(final Op<T, E> op) throws E {
         return doInSystemContext(op, false);
     }
 
     /**
      * Executes the given operation in the system context and sets it back to the original once done
      * (also if an exception is thrown). Also works if there was no context upon calling (sets it back
      * to null in this case)
      *
      * @param releaseAfterExecution set to true if the context should be released once the execution is done (e.g. in workflow operations or scheduled jobs).
      */
     public static <T, E extends Throwable> T doInSystemContext(final Op<T, E> op, boolean releaseAfterExecution) throws E {
         final Context originalCtx = MgnlContext.hasInstance() ? MgnlContext.getInstance() : null;
         T result;
         try {
             if (MgnlContext.isSystemInstance()) {
                 log.debug("Requested to run {}:{} in system context while already in system context.", op.getClass().getName(), op);
             }
             SystemContext systemContext = Components.getComponent(SystemContext.class);
             MgnlContext.setInstance(systemContext);
             if (systemContext instanceof AbstractSystemContext) {
                 ((AbstractSystemContext) systemContext).setOriginalContext((originalCtx instanceof AbstractSystemContext) ? ((AbstractSystemContext) originalCtx).getOriginalContext() : originalCtx);
             }
             result = op.exec();
         } finally {
             if (releaseAfterExecution) {
                 MgnlContext.release();
             }
             MgnlContext.setInstance(originalCtx);
         }
         return result;
     }
 
     /**
      * A simple execution interface to be used with the doInSystemContext method.
      * If no return value is necessary, return null (for semantic's sake, declare T as <Void>)
      * If no checked exception need to be thrown, declare E as <RuntimeException>)
      *
      * @param <T> the return type of this operation
      * @param <E> an exception this operation can throw
      * @see MgnlContext#doInSystemContext(Op op)
      */
     public static interface Op<T, E extends Throwable> {
         T exec() throws E;
     }
 
     /**
      * An Op that does not return values and can only throw RuntimeExceptions.
      */
     public abstract static class VoidOp implements Op<Void, RuntimeException> {
         @Override
         public Void exec() {
             doExec();
             return null;
         }
 
         abstract public void doExec();
     }
 
     /**
      * An Op that does not return values and can only throw RepositoryExceptions.
      */
     public abstract static class RepositoryOp implements Op<Void, RepositoryException> {
         @Override
         public Void exec() throws RepositoryException {
             doExec();
             return null;
         }
 
         abstract public void doExec() throws RepositoryException;
     }
 
     /**
      * Operation that is performed only if JCR lock can be issued on the path specified by combination of parameters in constructor. Lock issued and held by this operation prevents other concurrent modifications and should not be used without reason. Locking is always session scoped, meaning that is issuing session is closed, any locks held by the session are forcefully released at this point. Since Magnolia uses request scoped sessions in most cases, it means that no matter what happens lock will be released latest when request processing is finished.
      */
     public abstract static class LockingOp extends RepositoryOp {
 
         private final long sleepTime = 200;
         private final int maxAttempts = 50;
 
         final private String workspaceName;
         final private String lockPath;
         final private String userName;
         final private boolean deepLock;
         final private String lockedNodeType;
 
         /**
          * Performs operation only if shallow lock can be obtained within reasonable time on a path specified by params.
          */
         public LockingOp(String workspaceName, String lockPath) {
             this(workspaceName, lockPath, false);
         }
 
         /**
          * Performs operation only if shallow or deep lock can be obtained within reasonable time on a path specified by params.
          * Use deep locking with care as it will stop all other locking operations all the way down your tree structure. Obtaining and releasing deep lock is also more expensive then shallow locking.
          */
         public LockingOp(String workspaceName, String lockPath, boolean deepLock) {
             this(workspaceName, lockPath, deepLock, null);
         }
 
         /**
          * Performs operation only if shallow lock can be obtained within reasonable time on a path specified by params.
          * If node at specified path is not of specified primary type, this action will attempt to locate and lock nearest parent node that is of specified type. Failing to locate such node, lock will be issued on the specified path itself.
          */
         public LockingOp(String workspaceName, String lockPath, String nodeType) {
             // since this is used in constructor the call should be done still prior the use of system context and we should still get real user
             this(workspaceName, lockPath, false, nodeType, MgnlContext.getUser() == null ? "not available" : MgnlContext.getUser().getName());
         }
 
         /**
          * Performs operation only if shallow or deep lock can be obtained within reasonable time on a path specified by params.
          * If node at specified path is not of specified primary type, this action will attempt to locate and lock nearest parent node that is of specified type. Failing to locate such node, lock will be issued on the specified path itself.
          * Use deep locking with care as it will stop all other locking operations all the way down your tree structure. Obtaining and releasing deep lock is also more expensive then shallow locking.
          */
         public LockingOp(String workspaceName, String lockPath, boolean deepLock, String nodeType) {
             // since this is used in constructor the call should be done still prior the use of system context and we should still get real user
             this(workspaceName, lockPath, deepLock, nodeType, MgnlContext.getUser() == null ? "not available" : MgnlContext.getUser().getName());
         }
 
         /**
          * Performs operation only if shallow or deep lock can be obtained within reasonable time on a path specified by params.
          * If node at specified path is not of specified primary type, this action will attempt to locate and lock nearest parent node that is of specified type. Failing to locate such node, lock will be issued on the specified path itself.
          * Use deep locking with care as it will stop all other locking operations all the way down your tree structure. Obtaining and releasing deep lock is also more expensive then shallow locking.
          * Specify a user name to be used in lock description in case this operation should be assigned to other user then one currently logged in (doesn't have any effect on permissions, information is stored for debugging and troubleshooting purposes only).
          */
         public LockingOp(String workspaceName, String lockPath, boolean deepLock, String lockedNodeType, String userName) {
             this.workspaceName = workspaceName;
             this.userName = userName;
             this.deepLock = deepLock;
             this.lockedNodeType = lockedNodeType;
             this.lockPath = lockPath;
         }
 
         private String getLockPath() throws RepositoryException {
             if (lockedNodeType == null) {
                 return lockPath;
             }
             Session sysSession = MgnlContext.getJCRSession(workspaceName);
             Node parentNode = sysSession.getNode(lockPath);
             Node lockNode = parentNode;
             while (lockNode != null && lockNode.getDepth() > 0 && !lockedNodeType.equals(lockNode.getPrimaryNodeType().getName())) {
                 lockNode = lockNode.getParent();
             }
 
             final String lockPath;
             if (lockNode == null || lockNode.getDepth() == 0) {
                 if (parentNode == null) {
                     throw new RepositoryException("Can't perform locking operaion without the locked node. " + workspaceName + ":" + this.lockPath + " doesn't exist.");
                 }
                 // root node is not lockable
                 lockPath = parentNode.getPath();
                 log.info("Failed to find page path for {}:{}", workspaceName, lockPath);
             } else {
                 lockPath = lockNode.getPath();
             }
             return lockPath;
         }
 
         @Override
         public Void exec() throws RepositoryException {
             final String threadName = Thread.currentThread().getName();
             final String lockPath = getLockPath();
             final Session sysSession = MgnlContext.getJCRSession(workspaceName);
             final String sessionName = sysSession.toString();
             final LockManager guard = sysSession.getWorkspace().getLockManager();
             // check if someone else is trying to do something here and lock if not
             int attempts = maxAttempts;
             while (attempts > 0) {
                 if (!guard.isLocked(lockPath)) {
                     try {
                         Node node = sysSession.getNode(lockPath);
                         if (!node.isNodeType("mix:lockable")) {
                             node.addMixin("mix:lockable");
                         }
                         node.save();
                         guard.lock(lockPath, deepLock, true, sleepTime * maxAttempts, "Lock guarded node update requested by " + userName);
                         log.debug("Locked {} from {}:{}", lockPath, sessionName, threadName);
                         break;
                     } catch (LockException e) {
                         log.debug("this should happen very rarely. If you are seeing this message something is probably very wrong.", e);
                         // someone was faster, let's retry
                     }
                 }
                 try {
                     Thread.sleep(sleepTime);
                 } catch (InterruptedException e) {
                     Thread.interrupted();
                 }
                 attempts--;
             }
             if (attempts == 0) {
                 log.info("Lock on {} is already held by {}", lockPath, guard.getLock(lockPath));
                 // we've exhausted all time we got.
                 String message = "Failed to obtain lock by " + userName + "(" + threadName + ") on " + workspaceName + ":" + lockPath + " within " + ((maxAttempts * sleepTime) / 1000) + " seconds. Will NOT execute operation that requires locking.";
                 throw new LockException(message);
             }
             long timestamp = System.nanoTime();
             try {
                 doExec();
             } catch (LockException e) {
                 String failedPath = e.getFailureNodePath();
                 // we locked the node so either someone invoking the op has requested lock on wrong path or is using wrong session ... or something is seriously screwed up
                 log.error("Lock exception while updating node [{}] supposedly guarded by lock. is it really locked? {}, we hold the lock? {} ... as for [{}] is it locked? {}, we hold the lock? {}", failedPath, "" + guard.isLocked(failedPath), "" + guard.holdsLock(failedPath), lockPath, "" + guard.isLocked(lockPath), "" + guard.holdsLock(lockPath));
 
             } finally {
                 timestamp = System.nanoTime() - timestamp;
                 // 2 seconds
                 if (timestamp > 2000000000L) {
                     log.warn("Lock guarded operation on {}:{}:{} performed by {}:{} took {} seconds to execute. Performance of your server might be sub-optimal.", sessionName, workspaceName, lockPath, userName, threadName, "" + (timestamp / 1000000000L));
                 }
                 // always unlock
                 log.debug("Unocking {} from {}:{}", lockPath, sessionName, threadName);
                 try {
                     guard.unlock(lockPath);
                 } catch (InvalidItemStateException e) {
                     log.error("Failed to unlock {} from {}:{} with {}. Will attempt to save the session and try again.", lockPath, sessionName, threadName, e.getMessage(), e);
                     sysSession.save();
                     guard.unlock(lockPath);
                 }
             }
             return null;
         }
     }
 
     /**
      * Sets this context as a web context.
      *
      * @param request HttpServletRequest
      * @param response HttpServletResponse
      * @param servletContext ServletContext instance
      * @deprecated since 4.5, use WebContextFactory.
      */
     @Deprecated
     public static void initAsWebContext(HttpServletRequest request, HttpServletResponse response, ServletContext servletContext) {
         WebContext ctx = ContextFactory.getInstance().createWebContext(request, response, servletContext);
         setInstance(ctx);
     }
 
     /**
      * Returns the web context, also if eventually wrapped in a ContextDecorator.
      *
      * @return WebContext instance or null if no web context is set
      */
     private static WebContext getWebContextIfExisting(Context ctx) {
         if (ctx instanceof WebContext) {
             return (WebContext) ctx;
         } else if (ctx instanceof ContextDecorator) {
             return getWebContextIfExisting(((ContextDecorator) ctx).getWrappedContext());
         }
         return null;
     }
 
     /**
      * Releases the current thread (if not a system context) and calls the releaseThread() method of the system context.
      */
     public static void release() {
         if (hasInstance() && !(getInstance() instanceof SystemContext)) {
             getInstance().release();
         }
         SystemContext systemContext = getSystemContext();
         if (systemContext instanceof ThreadDependentSystemContext) {
             ((ThreadDependentSystemContext) systemContext).releaseThread();
         }
     }
 
     public static void push(HttpServletRequest request, HttpServletResponse response) {
         if (isWebContext()) {
             WebContext wc = getWebContext();
             wc.push(request, response);
         }
     }
 
     public static void pop() {
         if (isWebContext()) {
             WebContext wc = getWebContext();
             wc.pop();
         }
     }
 
     /**
      * Note: this is the way to go, if you no longer want to rely on the Content-API.
      *
      * @param workspaceName - repository to get session for
      * @return a JCR session to the provided repository
      */
     public static Session getJCRSession(String workspaceName) throws LoginException, RepositoryException {
         return getInstance().getJCRSession(workspaceName);
     }
 
     public static Subject getSubject() {
         return getInstance().getSubject();
     }
 }