package fr.ifremer.quadrige3.core.security;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Client Core
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program 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 for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import com.google.common.collect.Lists;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.core.service.ClientServiceLocator;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  import org.springframework.security.core.Authentication;
  import org.springframework.security.core.AuthenticationException;
  import org.springframework.security.core.context.SecurityContextHolder;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  
  /**
   * helper class to handle Spring Security Context
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class SecurityContextHelper {
  
      private static final Log LOG = LogFactory.getLog(SecurityContextHelper.class);
  
      /**
       * <p>getAuthentication.</p>
       *
       * @return a {@link org.springframework.security.core.Authentication} object.
       */
      public static Authentication getAuthentication() {
          return SecurityContextHolder.getContext().getAuthentication();
      }
  
      /**
       * Clear authentication in Spring context
       */
      public static void clear() {
          SecurityContextHolder.clearContext();
      }
  
      /**
       * get the current authenticated user
       *
       * @return the user if correctly authenticated or null
       */
      public static QuadrigeUserDetails getQuadrigeUser() {
          Authentication authentication = getAuthentication();
          if (authentication == null || authentication.getPrincipal() == null) {
              return null;
          }
          Object principal = authentication.getPrincipal();
          if (principal instanceof QuadrigeUserDetails) {
              return (QuadrigeUserDetails) principal;
          }
          return null;
      }
  
      public static int getQuadrigeUserId() {
          QuadrigeUserDetails quadrigeUser = getQuadrigeUser();
          if (quadrigeUser == null) {
              throw new QuadrigeTechnicalException("No Authenticated Quadrige User");
          }
          return quadrigeUser.getUserId();
      }
  
     /**
       * try to authenticate the user by its login
       *
       * @param login the user login
       * @param password the user password
       * @return true if correctly authenticated
       */
      public static boolean authenticate(String login, String password) {
         if (StringUtils.isBlank(password)) {
 
             // Reset
             password = StringUtils.EMPTY;
         }
         else {
 
             // Encrypt password
             password = Encryption.sha(password);
         }
 
         Authentication authentication = new UsernamePasswordAuthenticationToken(login, password);
         try {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("try to authenticate '" + login + "' in local database");
             }
 
             authentication = ClientServiceLocator.instance().getAuthenticationManager().authenticate(authentication);
 
             if (LOG.isDebugEnabled()) {
                 LOG.debug("database authentication successful");
             }
         } catch (AuthenticationException ae) {
             authentication.setAuthenticated(false);
             if (LOG.isDebugEnabled()) {
                 LOG.debug("database authentication failed : " + ae.getLocalizedMessage());
             }
         }
         SecurityContextHolder.getContext().setAuthentication(authentication);
         return authentication.isAuthenticated();
     }
 
     /**
      * <p>hasAuthority.</p>
      *
      * @param authority a {@link QuadrigeUserAuthority} object.
      * @return a boolean.
      */
     public static boolean hasAuthority(QuadrigeUserAuthority authority) {
         return hasAuthority(getAuthentication(), authority);
     }
 
     /**
      * <p>hasAuthority.</p>
      *
      * @param authorities a {@link List} object.
      * @return a boolean.
      */
     public static boolean hasAuthority(List<QuadrigeUserAuthority> authorities) {
         return hasAuthority(getAuthentication(), authorities);
     }
 
     /**
      * <p>hasAuthority.</p>
      *
      * @param authentication a {@link org.springframework.security.core.Authentication} object.
      * @param authorities a {@link Object} object.
      * @return a boolean.
      */
     @SuppressWarnings("unchecked")
     public static boolean hasAuthority(Authentication authentication, Object authorities) {
 
         if (authentication == null || CollectionUtils.isEmpty(authentication.getAuthorities()) || authorities == null) {
             return false;
         }
 
         List<QuadrigeUserAuthority> authList = Lists.newArrayList();
         if (authorities instanceof Collection) {
             authList.addAll((Collection<? extends QuadrigeUserAuthority>) authorities);
         }
         else if (authorities instanceof QuadrigeUserAuthority) {
             authList.add((QuadrigeUserAuthority) authorities);
         }
         else {
             LOG.error("the 'authorities' object is not a QuadrigeUserAuthority and not a Collection<QuadrigeUserAuthority>");
             return false;
         }
 
         // remove from this list all authorities not contained in authenticated user authorities list
         authList.retainAll(authentication.getAuthorities());
 
         // return true if the user has one or more needed authorities, else otherwise
         return !authList.isEmpty();
 
     }
 
     /**
      * <p>hasMinimumAuthority.</p>
      *
      * @param authority a {@link QuadrigeUserAuthority} object.
      * @return a boolean.
      */
     public static boolean hasMinimumAuthority(QuadrigeUserAuthority authority) {
 
         return hasMinimumAuthority(getAuthentication(), authority);
     }
 
 
     /**
      * <p>hasMinimumAuthority.</p>
      *
      * @param authentication a {@link org.springframework.security.core.Authentication} object.
      * @param authorities a {@link Object} object.
      * @return a boolean.
      */
     @SuppressWarnings("unchecked")
     public static boolean hasMinimumAuthority(Authentication authentication, Object authorities) {
 
         if (authentication == null || CollectionUtils.isEmpty(authentication.getAuthorities()) || authorities == null) {
             return false;
         }
 
         List<QuadrigeUserAuthority> miniAuthList = Lists.newArrayList();
         if (authorities instanceof Collection) {
             miniAuthList.addAll((Collection<? extends QuadrigeUserAuthority>) authorities);
         }
         else if (authorities instanceof QuadrigeUserAuthority) {
             miniAuthList.add((QuadrigeUserAuthority) authorities);
         }
         else {
             LOG.error("the 'authorities' object is not a QuadrigeUserAuthority and not a Collection<QuadrigeUserAuthority>");
             return false;
         }
 
         // sort by level
         Collections.sort(miniAuthList);
 
         // get the highest level (the last item)
         QuadrigeUserAuthority minimumAuthority = miniAuthList.get(miniAuthList.size() - 1);
 
         List<QuadrigeUserAuthority> userAuthorities = (List<QuadrigeUserAuthority>) authentication.getAuthorities();
         for (QuadrigeUserAuthority userAuthority : userAuthorities) {
             if (userAuthority.compareTo(minimumAuthority) >= 0) {
                 return true;
             }
         }
 
         return false;
     }
 
 }