/*
    * Copyright (c) 2002-2022, City of Paris
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    *  1. Redistributions of source code must retain the above copyright notice
   *     and the following disclaimer.
   *
   *  2. Redistributions in binary form must reproduce the above copyright notice
   *     and the following disclaimer in the documentation and/or other materials
   *     provided with the distribution.
   *
   *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
   *     contributors may be used to endorse or promote products derived from
   *     this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   *
   * License 1.0
   */
  package fr.paris.lutece.portal.web.system;
  
  import fr.paris.lutece.portal.business.portlet.PortletType;
  import fr.paris.lutece.portal.business.portlet.PortletTypeHome;
  import fr.paris.lutece.portal.service.admin.AccessDeniedException;
  import fr.paris.lutece.portal.service.admin.AdminUserService;
  import fr.paris.lutece.portal.service.database.AppConnectionService;
  import fr.paris.lutece.portal.service.i18n.I18nService;
  import fr.paris.lutece.portal.service.init.AppInfo;
  import fr.paris.lutece.portal.service.message.AdminMessage;
  import fr.paris.lutece.portal.service.message.AdminMessageService;
  import fr.paris.lutece.portal.service.plugin.Plugin;
  import fr.paris.lutece.portal.service.plugin.PluginService;
  import fr.paris.lutece.portal.service.security.SecurityTokenService;
  import fr.paris.lutece.portal.service.template.AppTemplateService;
  import fr.paris.lutece.portal.service.util.AppLogService;
  import fr.paris.lutece.portal.web.admin.AdminFeaturesPageJspBean;
  import fr.paris.lutece.util.ReferenceList;
  import fr.paris.lutece.util.html.HtmlTemplate;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpServletRequest;
  
  /**
   * This class provides the user interface to manage the lutece plugins (install, enable, disable)
   */
  public class PluginJspBean extends AdminFeaturesPageJspBean
  {
      // //////////////////////////////////////////////////////////////////////////////
      // Constants
      public static final String RIGHT_MANAGE_PLUGINS = "CORE_PLUGINS_MANAGEMENT";
      private static final long serialVersionUID = -9058113426951331118L;
      private static final String TEMPLATE_MANAGE_PLUGINS = "admin/system/manage_plugins.html";
      private static final String MARK_PLUGINS_LIST = "plugins_list";
      private static final String MARK_CORE = "core";
      private static final String MARK_POOLS_LIST = "pools_list";
      private static final String MARK_FILTER_LIST = "filter_list";
      private static final String MARK_CURRENT_FILTER = "current_filter";
      private static final String PROPERTY_PLUGIN_MESSAGE = "portal.system.message.confirmDisable";
      private static final String PROPERTY_PLUGIN_PORTLET_EXIST_MESSAGE = "portal.system.message.portletExist";
      private static final String PROPERTY_PLUGIN_NO_CORE_COMPATIBILITY_MESSAGE = "portal.system.message.noCoreCompatibility";
      private static final String PROPERTY_PLUGIN_INSTALL_ERROR = "portal.system.message.installError";
      private static final String PARAM_PLUGIN_NAME = "plugin_name";
      private static final String PARAM_PLUGIN_TYPE = "plugin_type";
      private static final String PARAM_DB_POOL_NAME = "db_pool_name";
      private static final String PARAM_PLUGIN_TYPE_ALL = "all";
      private static final String PARAM_PLUGIN_TYPE_PORTLET = "portlet";
      private static final String PARAM_PLUGIN_TYPE_APPLICATION = "application";
      private static final String PARAM_PLUGIN_TYPE_FEATURE = "feature";
      private static final String PARAM_PLUGIN_TYPE_INSERTSERVICE = "insertservice";
      private static final String PARAM_PLUGIN_TYPE_CONTENTSERVICE = "contentservice";
      private static final String PROPERTY_PLUGIN_TYPE_NAME_ALL = "portal.system.pluginType.name.all";
      private static final String PROPERTY_PLUGIN_TYPE_NAME_APPLICATION = "portal.system.pluginType.name.application";
      private static final String PROPERTY_PLUGIN_TYPE_NAME_PORTLET = "portal.system.pluginType.name.portlet";
      private static final String PROPERTY_PLUGIN_TYPE_NAME_FEATURE = "portal.system.pluginType.name.feature";
      private static final String PROPERTY_PLUGIN_TYPE_NAME_INSERTSERVICE = "portal.system.pluginType.name.insertService";
      private static final String PROPERTY_PLUGIN_TYPE_NAME_CONTENTSERVICE = "portal.system.pluginType.name.contentService";
      private static final String TEMPLATE_PLUGIN_DETAILS = "/admin/system/view_plugin.html";
      private static final String JSP_UNINSTALL_PLUGIN = "jsp/admin/system/DoUninstallPlugin.jsp";
  
     /**
      * Returns the plugins management page
      *
      * @param request
      *            The Http request
      * @return Html page
      */
     public String getManagePlugins( HttpServletRequest request )
     {
         Locale locale = AdminUserService.getLocale( request );
         String strPluginTypeFilter = request.getParameter( PARAM_PLUGIN_TYPE );
         Collection<Plugin> listPlugins = PluginService.getPluginList( );
         HashMap<String, Object> model = new HashMap<>( );
         model.put( MARK_PLUGINS_LIST, filterPluginsList( listPlugins, strPluginTypeFilter ) );
         model.put( MARK_CORE, PluginService.getCore( ) );
         model.put( MARK_POOLS_LIST, getPoolsList( ) );
         model.put( MARK_FILTER_LIST, getPluginTypeFilterList( locale ) );
         model.put( MARK_CURRENT_FILTER, ( strPluginTypeFilter != null ) ? strPluginTypeFilter : "" );
         model.put( SecurityTokenService.MARK_TOKEN, SecurityTokenService.getInstance( ).getToken( request, TEMPLATE_MANAGE_PLUGINS ) );
 
         HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_PLUGINS, locale, model );
 
         return getAdminPage( template.getHtml( ) );
     }
 
     /**
      * Install a plugin
      *
      * @param request
      *            The Http request
      * @param context
      *            The servlet context
      * @return the url of the page containing a log essage
      * @throws AccessDeniedException
      *             if the security token is invalid
      */
     public String doInstallPlugin( HttpServletRequest request, ServletContext context ) throws AccessDeniedException
     {
         String strPluginName = request.getParameter( PARAM_PLUGIN_NAME );
         Plugin plugin = PluginService.getPlugin( strPluginName );
 
         if ( !verifyCoreCompatibility( plugin ) )
         {
             Object [ ] args = {
                     plugin.getMinCoreVersion( ), plugin.getMaxCoreVersion( )
             };
 
             return AdminMessageService.getMessageUrl( request, PROPERTY_PLUGIN_NO_CORE_COMPATIBILITY_MESSAGE, args, AdminMessage.TYPE_STOP );
 
         }
         if ( !SecurityTokenService.getInstance( ).validate( request, TEMPLATE_MANAGE_PLUGINS ) )
         {
             throw new AccessDeniedException( ERROR_INVALID_TOKEN );
         }
         try
         {
             plugin.install( );
         }
         catch( Exception e )
         {
             AppLogService.error( e.getMessage( ), e );
 
             return AdminMessageService.getMessageUrl( request, PROPERTY_PLUGIN_INSTALL_ERROR, AdminMessage.TYPE_STOP );
         }
 
         return getHomeUrl( request );
     }
 
     /**
      * Uninstall a plugin
      *
      * @param request
      *            The Http request
      * @param context
      *            The servlet context
      * @return the url of the page containing a log essage
      * @throws AccessDeniedException
      *             if the security token is invalid
      */
     public String doUninstallPlugin( HttpServletRequest request, ServletContext context ) throws AccessDeniedException
     {
         if ( !SecurityTokenService.getInstance( ).validate( request, JSP_UNINSTALL_PLUGIN ) )
         {
             throw new AccessDeniedException( ERROR_INVALID_TOKEN );
         }
         try
         {
             String strPluginName = request.getParameter( PARAM_PLUGIN_NAME );
             Plugin plugin = PluginService.getPlugin( strPluginName );
             plugin.uninstall( );
         }
         catch( Exception e )
         {
             AppLogService.error( e.getMessage( ), e );
         }
 
         return getHomeUrl( request );
     }
 
     /**
      * Returns the page of confirmation for uninstalling a plugin
      *
      * @param request
      *            The Http Request
      * @return the HTML page
      */
     public String getConfirmUninstallPlugin( HttpServletRequest request )
     {
         String strPluginName = request.getParameter( PARAM_PLUGIN_NAME );
         Plugin plugin = PluginService.getPlugin( strPluginName );
         Collection<PortletType> listPortletTypes = plugin.getPortletTypes( );
         String strMessageKey = PROPERTY_PLUGIN_MESSAGE;
         Map<String, String> parameters = new HashMap<>( );
         parameters.put( PARAM_PLUGIN_NAME, strPluginName );
         parameters.put( SecurityTokenService.PARAMETER_TOKEN, SecurityTokenService.getInstance( ).getToken( request, JSP_UNINSTALL_PLUGIN ) );
         String strAdminMessageUrl = AdminMessageService.getMessageUrl( request, strMessageKey, JSP_UNINSTALL_PLUGIN, AdminMessage.TYPE_CONFIRMATION,
                 parameters );
 
         for ( PortletType portletType : listPortletTypes )
         {
             String strPluginHomeClass = portletType.getHomeClass( );
 
             if ( ( plugin.getType( ) & Plugin.PLUGIN_TYPE_PORTLET ) != 0 && isPortletExists( strPluginHomeClass ) )
             {
                 strMessageKey = PROPERTY_PLUGIN_PORTLET_EXIST_MESSAGE;
                 strAdminMessageUrl = AdminMessageService.getMessageUrl( request, strMessageKey, AdminMessage.TYPE_CONFIRMATION );
             }
         }
 
         return strAdminMessageUrl;
     }
 
     /**
      * Defines the database connection pool to be used by the plugin
      * 
      * @param request
      *            The http request
      * @return the URL to redirect after this action
      * @throws AccessDeniedException
      *             if the security token is invalid
      */
     public String doModifyPluginPool( HttpServletRequest request ) throws AccessDeniedException
     {
         if ( !SecurityTokenService.getInstance( ).validate( request, TEMPLATE_MANAGE_PLUGINS ) )
         {
             throw new AccessDeniedException( ERROR_INVALID_TOKEN );
         }
         String strPluginName = request.getParameter( PARAM_PLUGIN_NAME );
         String strDbPoolName = request.getParameter( PARAM_DB_POOL_NAME );
 
         try
         {
             Plugin plugin = PluginService.getPlugin( strPluginName );
             plugin.updatePoolName( strDbPoolName );
         }
         catch( Exception e )
         {
             AppLogService.error( e.getMessage( ), e );
         }
 
         return getHomeUrl( request );
     }
 
     /**
      * Displays a plugin's description
      * 
      * @param request
      *            The HTTP request
      * @return The popup HTML code
      */
     public String getPluginDescription( HttpServletRequest request )
     {
         String strPluginName = request.getParameter( PARAM_PLUGIN_NAME );
         Plugin plugin;
         if ( PluginService.getCore( ).getName( ).equals( strPluginName ) )
         {
             plugin = PluginService.getCore( );
         }
         else
         {
             plugin = PluginService.getPlugin( strPluginName );
         }
 
         // set the locale for the feature labels
         I18nService.localizeCollection( plugin.getRights( ), getLocale( ) );
         // set the locale for the portlet types labels
         I18nService.localizeCollection( plugin.getPortletTypes( ), getLocale( ) );
         // set the locale for the link services labels
         I18nService.localizeCollection( plugin.getInsertServices( ), getLocale( ) );
 
         HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_PLUGIN_DETAILS, getLocale( ), plugin );
 
         return getAdminPage( template.getHtml( ) );
     }
 
     // ////////////////////////////////////////////////////////////////////////////////////////////////////////
     // Private implementation
 
     /**
      * Return a filter list of plugins
      * 
      * @param listPlugins
      *            the COllection of plugins
      * @param strPluginTypeFilter
      *            The filter
      * @return list The list of plugins
      */
     private Collection<Plugin> filterPluginsList( Collection<Plugin> listPlugins, String strPluginTypeFilter )
     {
         Collection<Plugin> list = new ArrayList<>( );
         if ( strPluginTypeFilter == null )
         {
             return listPlugins;
         }
 
         for ( Plugin plugin : listPlugins )
         {
             boolean filter = false;
             if ( strPluginTypeFilter.equals( PARAM_PLUGIN_TYPE_APPLICATION ) )
             {
                 // skip this plugin
                 filter = ( plugin.getType( ) & Plugin.PLUGIN_TYPE_APPLICATION ) == 0;
             }
             else
                 if ( strPluginTypeFilter.equals( PARAM_PLUGIN_TYPE_PORTLET ) )
                 {
                     // skip this plugin
                     filter = ( plugin.getType( ) & Plugin.PLUGIN_TYPE_PORTLET ) == 0;
                 }
                 else
                     if ( strPluginTypeFilter.equals( PARAM_PLUGIN_TYPE_FEATURE ) )
                     {
                         // skip this plugin
                         filter = ( plugin.getType( ) & Plugin.PLUGIN_TYPE_FEATURE ) == 0;
                     }
                     else
                         if ( strPluginTypeFilter.equals( PARAM_PLUGIN_TYPE_INSERTSERVICE ) )
                         {
                             // skip this plugin
                             filter = ( plugin.getType( ) & Plugin.PLUGIN_TYPE_INSERTSERVICE ) == 0;
                         }
                         else
                             if ( strPluginTypeFilter.equals( PARAM_PLUGIN_TYPE_CONTENTSERVICE ) )
                             {
                                 // skip this plugin
                                 filter = ( plugin.getType( ) & Plugin.PLUGIN_TYPE_CONTENTSERVICE ) == 0;
                             }
 
             if ( !filter )
             {
                 list.add( plugin );
             }
         }
         return list;
     }
 
     /**
      * Create a ReferenceList containing all Plugin types
      * 
      * @param locale
      *            The Locale
      * @return A ReferenceList containing all Plugin types
      */
     private ReferenceList getPluginTypeFilterList( Locale locale )
     {
         ReferenceListnceList.html#ReferenceList">ReferenceList list = new ReferenceList( );
         list.addItem( PARAM_PLUGIN_TYPE_ALL, I18nService.getLocalizedString( PROPERTY_PLUGIN_TYPE_NAME_ALL, locale ) );
         list.addItem( PARAM_PLUGIN_TYPE_APPLICATION, I18nService.getLocalizedString( PROPERTY_PLUGIN_TYPE_NAME_APPLICATION, locale ) );
         list.addItem( PARAM_PLUGIN_TYPE_PORTLET, I18nService.getLocalizedString( PROPERTY_PLUGIN_TYPE_NAME_PORTLET, locale ) );
         list.addItem( PARAM_PLUGIN_TYPE_FEATURE, I18nService.getLocalizedString( PROPERTY_PLUGIN_TYPE_NAME_FEATURE, locale ) );
         list.addItem( PARAM_PLUGIN_TYPE_INSERTSERVICE, I18nService.getLocalizedString( PROPERTY_PLUGIN_TYPE_NAME_INSERTSERVICE, locale ) );
         list.addItem( PARAM_PLUGIN_TYPE_CONTENTSERVICE, I18nService.getLocalizedString( PROPERTY_PLUGIN_TYPE_NAME_CONTENTSERVICE, locale ) );
 
         return list;
     }
 
     /**
      * Return a list of pools
      * 
      * @return listPools the list of pools
      */
     private ReferenceList getPoolsList( )
     {
         ReferenceListst.html#ReferenceList">ReferenceList listPools = new ReferenceList( );
         listPools.addItem( AppConnectionService.NO_POOL_DEFINED, " " );
         AppConnectionService.getPoolList( listPools );
 
         return listPools;
     }
 
     /**
      * Returns the status of the existence of a portlet on the site
      *
      * @param strPluginHomeClass
      *            The home class of the plugin
      * @return The existence status as a boolean
      */
     private boolean isPortletExists( String strPluginHomeClass )
     {
         String strPortletTypeId = PortletTypeHome.getPortletTypeId( strPluginHomeClass );
 
         return ( PortletTypeHome.getNbPortletTypeByPortlet( strPortletTypeId ) != 0 );
     }
 
     /**
      * Verify the core compatibility for a plugin
      *
      * @param plugin
      *            The plugin
      * @return true if compatible with the current core version
      */
     private boolean verifyCoreCompatibility( Plugin plugin )
     {
         String strCoreVersion = AppInfo.getVersion( );
 
         // Remove version qualifier (-SNAPSHOT, -RC-XX, ...)
         int nPos = strCoreVersion.indexOf( '-' );
 
         if ( nPos > 0 )
         {
             strCoreVersion = strCoreVersion.substring( 0, nPos );
         }
 
         String [ ] coreVersion = strCoreVersion.split( "\\." );
 
         String strMinCoreVersion = ( plugin.getMinCoreVersion( ) == null ) ? "" : plugin.getMinCoreVersion( );
         String strMaxCoreVersion = ( plugin.getMaxCoreVersion( ) == null ) ? "" : plugin.getMaxCoreVersion( );
 
         // test the min core version
         boolean bMin = ( strMinCoreVersion == null ) || strMinCoreVersion.trim( ).equals( "" );
 
         if ( ( strMinCoreVersion != null ) && !strMinCoreVersion.trim( ).equals( "" ) )
         {
             String [ ] minCoreVersion = strMinCoreVersion.split( "\\." );
 
             if ( checkCoreMinCompatibility( minCoreVersion, coreVersion ) )
             {
                 AppLogService.debug( "Min core version ok : {}", plugin.getMinCoreVersion( ) );
                 bMin = true;
             }
         }
 
         // test the max core version
         boolean bMax = ( strMaxCoreVersion == null ) || strMaxCoreVersion.trim( ).equals( "" );
 
         if ( ( strMaxCoreVersion != null ) && !strMaxCoreVersion.trim( ).equals( "" ) )
         {
             String [ ] maxCoreVersion = strMaxCoreVersion.split( "\\." );
 
             if ( checkCoreMaxCompatibility( maxCoreVersion, coreVersion ) )
             {
                 AppLogService.debug( "Max core version ok : {}", plugin.getMaxCoreVersion( ) );
                 bMax = true;
             }
         }
 
         return bMin && bMax;
     }
 
     /**
      * Checks the compatibility
      * 
      * @param minCoreVersion
      *            The min core version
      * @param coreVersion
      *            The current core version
      * @return true if compatible with the current core version
      */
     private boolean checkCoreMinCompatibility( String [ ] minCoreVersion, String [ ] coreVersion )
     {
         for ( int i = 0; i < Math.min( minCoreVersion.length, coreVersion.length ); ++i )
         {
             if ( ( Integer.parseInt( minCoreVersion [i] ) ) < ( Integer.parseInt( coreVersion [i] ) ) )
             {
                 return true;
             }
 
             if ( ( Integer.parseInt( minCoreVersion [i] ) ) > ( Integer.parseInt( coreVersion [i] ) ) )
             {
                 return false;
             }
         }
 
         return true; // inclusive
     }
 
     /**
      * Checks the compatibility
      * 
      * @param maxCoreVersion
      *            The max core version
      * @param coreVersion
      *            The current core version
      * @return true if compatible with the current core version
      */
     private boolean checkCoreMaxCompatibility( String [ ] maxCoreVersion, String [ ] coreVersion )
     {
         for ( int i = 0; i < Math.min( maxCoreVersion.length, coreVersion.length ); ++i )
         {
             if ( ( Integer.parseInt( maxCoreVersion [i] ) ) > ( Integer.parseInt( coreVersion [i] ) ) )
             {
                 return true;
             }
 
             if ( ( Integer.parseInt( maxCoreVersion [i] ) ) < ( Integer.parseInt( coreVersion [i] ) ) )
             {
                 return false;
             }
         }
 
         return false; // exclusive
     }
 }