/*
    * 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.shiro.session.mgt;
  
  import org.apache.shiro.authz.AuthorizationException;
  import org.apache.shiro.session.*;
  import org.apache.shiro.util.CollectionUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Date;
  
  /**
   * Abstract implementation supporting the {@link NativeSessionManager NativeSessionManager} interface, supporting
   * {@link SessionListener SessionListener}s and application of the
   * {@link #getGlobalSessionTimeout() globalSessionTimeout}.
   *
   * @since 1.0
   */
  public abstract class AbstractNativeSessionManager extends AbstractSessionManager implements NativeSessionManager {
  
      private static final Logger log = LoggerFactory.getLogger(AbstractSessionManager.class);
  
      private Collection<SessionListener> listeners;
  
      public AbstractNativeSessionManager() {
          this.listeners = new ArrayList<SessionListener>();
      }
  
      public void setSessionListeners(Collection<SessionListener> listeners) {
          this.listeners = listeners != null ? listeners : new ArrayList<SessionListener>();
      }
  
      @SuppressWarnings({"UnusedDeclaration"})
      public Collection<SessionListener> getSessionListeners() {
          return this.listeners;
      }
  
      public Session start(SessionContext context) {
          Session session = createSession(context);
          applyGlobalSessionTimeout(session);
          onStart(session, context);
          notifyStart(session);
          //Don't expose the EIS-tier Session object to the client-tier:
          return createExposedSession(session, context);
      }
  
      /**
       * Creates a new {@code Session Session} instance based on the specified (possibly {@code null})
       * initialization data.  Implementing classes must manage the persistent state of the returned session such that it
       * could later be acquired via the {@link #getSession(SessionKey)} method.
       *
       * @param context the initialization data that can be used by the implementation or underlying
       *                {@link SessionFactory} when instantiating the internal {@code Session} instance.
       * @return the new {@code Session} instance.
       * @throws org.apache.shiro.authz.HostUnauthorizedException
       *                                if the system access control policy restricts access based
       *                                on client location/IP and the specified hostAddress hasn't been enabled.
       * @throws AuthorizationException if the system access control policy does not allow the currently executing
       *                                caller to start sessions.
       */
      protected abstract Session createSession(SessionContext context) throws AuthorizationException;
  
      protected void applyGlobalSessionTimeout(Session session) {
          session.setTimeout(getGlobalSessionTimeout());
          onChange(session);
      }
  
      /**
       * Template method that allows subclasses to react to a new session being created.
       * <p/>
       * This method is invoked <em>before</em> any session listeners are notified.
       *
       * @param session the session that was just {@link #createSession created}.
       * @param context the {@link SessionContext SessionContext} that was used to start the session.
       */
      protected void onStart(Session session, SessionContext context) {
      }
  
      public Session getSession(SessionKey key) throws SessionException {
         Session session = lookupSession(key);
         return session != null ? createExposedSession(session, key) : null;
     }
 
     private Session lookupSession(SessionKey key) throws SessionException {
         if (key == null) {
             throw new NullPointerException("SessionKey argument cannot be null.");
         }
         return doGetSession(key);
     }
 
     private Session lookupRequiredSession(SessionKey key) throws SessionException {
         Session session = lookupSession(key);
         if (session == null) {
             String msg = "Unable to locate required Session instance based on SessionKey [" + key + "].";
             throw new UnknownSessionException(msg);
         }
         return session;
     }
 
     protected abstract Session doGetSession(SessionKey key) throws InvalidSessionException;
 
     protected Session createExposedSession(Session session, SessionContext context) {
         return new DelegatingSession(this, new DefaultSessionKey(session.getId()));
     }
 
     protected Session createExposedSession(Session session, SessionKey key) {
         return new DelegatingSession(this, new DefaultSessionKey(session.getId()));
     }
 
     /**
      * Returns the session instance to use to pass to registered {@code SessionListener}s for notification
      * that the session has been invalidated (stopped or expired).
      * <p/>
      * The default implementation returns an {@link ImmutableProxiedSession ImmutableProxiedSession} instance to ensure
      * that the specified {@code session} argument is not modified by any listeners.
      *
      * @param session the {@code Session} object being invalidated.
      * @return the {@code Session} instance to use to pass to registered {@code SessionListener}s for notification.
      */
     protected Session beforeInvalidNotification(Session session) {
         return new ImmutableProxiedSession(session);
     }
 
     /**
      * Notifies any interested {@link SessionListener}s that a Session has started.  This method is invoked
      * <em>after</em> the {@link #onStart onStart} method is called.
      *
      * @param session the session that has just started that will be delivered to any
      *                {@link #setSessionListeners(java.util.Collection) registered} session listeners.
      * @see SessionListener#onStart(org.apache.shiro.session.Session)
      */
     protected void notifyStart(Session session) {
         for (SessionListener listener : this.listeners) {
             listener.onStart(session);
         }
     }
 
     protected void notifyStop(Session session) {
         Session forNotification = beforeInvalidNotification(session);
         for (SessionListener listener : this.listeners) {
             listener.onStop(forNotification);
         }
     }
 
     protected void notifyExpiration(Session session) {
         Session forNotification = beforeInvalidNotification(session);
         for (SessionListener listener : this.listeners) {
             listener.onExpiration(forNotification);
         }
     }
 
     public Date getStartTimestamp(SessionKey key) {
         return lookupRequiredSession(key).getStartTimestamp();
     }
 
     public Date getLastAccessTime(SessionKey key) {
         return lookupRequiredSession(key).getLastAccessTime();
     }
 
     public long getTimeout(SessionKey key) throws InvalidSessionException {
         return lookupRequiredSession(key).getTimeout();
     }
 
     public void setTimeout(SessionKey key, long maxIdleTimeInMillis) throws InvalidSessionException {
         Session s = lookupRequiredSession(key);
         s.setTimeout(maxIdleTimeInMillis);
         onChange(s);
     }
 
     public void touch(SessionKey key) throws InvalidSessionException {
         Session s = lookupRequiredSession(key);
         s.touch();
         onChange(s);
     }
 
     public String getHost(SessionKey key) {
         return lookupRequiredSession(key).getHost();
     }
 
     public Collection<Object> getAttributeKeys(SessionKey key) {
         Collection<Object> c = lookupRequiredSession(key).getAttributeKeys();
         if (!CollectionUtils.isEmpty(c)) {
             return Collections.unmodifiableCollection(c);
         }
         return Collections.emptySet();
     }
 
     public Object getAttribute(SessionKey sessionKey, Object attributeKey) throws InvalidSessionException {
         return lookupRequiredSession(sessionKey).getAttribute(attributeKey);
     }
 
     public void setAttribute(SessionKey sessionKey, Object attributeKey, Object value) throws InvalidSessionException {
         if (value == null) {
             removeAttribute(sessionKey, attributeKey);
         } else {
             Session s = lookupRequiredSession(sessionKey);
             s.setAttribute(attributeKey, value);
             onChange(s);
         }
     }
 
     public Object removeAttribute(SessionKey sessionKey, Object attributeKey) throws InvalidSessionException {
         Session s = lookupRequiredSession(sessionKey);
         Object removed = s.removeAttribute(attributeKey);
         if (removed != null) {
             onChange(s);
         }
         return removed;
     }
 
     public boolean isValid(SessionKey key) {
         try {
             checkValid(key);
             return true;
         } catch (InvalidSessionException e) {
             return false;
         }
     }
 
     public void stop(SessionKey key) throws InvalidSessionException {
         Session session = lookupRequiredSession(key);
         try {
             if (log.isDebugEnabled()) {
                 log.debug("Stopping session with id [" + session.getId() + "]");
             }
             session.stop();
             onStop(session, key);
             notifyStop(session);
         } finally {
             afterStopped(session);
         }
     }
 
     protected void onStop(Session session, SessionKey key) {
         onStop(session);
     }
 
     protected void onStop(Session session) {
         onChange(session);
     }
 
     protected void afterStopped(Session session) {
     }
 
     public void checkValid(SessionKey key) throws InvalidSessionException {
         //just try to acquire it.  If there is a problem, an exception will be thrown:
         lookupRequiredSession(key);
     }
 
     protected void onChange(Session s) {
     }
 }