/*
    * 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.service.cache;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.lang.management.ManagementFactory;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Properties;
  
  import javax.management.MBeanServer;
  
  import fr.paris.lutece.portal.service.datastore.DatastoreService;
  import fr.paris.lutece.portal.service.util.AppLogService;
  import fr.paris.lutece.portal.service.util.AppPathService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  import net.sf.ehcache.Cache;
  import net.sf.ehcache.CacheManager;
  import net.sf.ehcache.config.CacheConfiguration;
  import net.sf.ehcache.config.Configuration;
  import net.sf.ehcache.config.ConfigurationFactory;
  import net.sf.ehcache.management.ManagementService;
  
  /**
   * Provides cache object for cacheable services
   */
  public final class CacheService
  {
      private static final String ERROR_NUMERIC_PROP = "Invalid numeric property : {} {} = {}";
      private static final String PROPERTY_PATH_CONF = "path.conf";
      private static final String PROPERTY_IS_ENABLED = ".enabled";
      private static final String FILE_CACHES_STATUS = "caches.dat";
  
      // Cache configuration properties
      private static final String PROPERTY_MAX_ELEMENTS = ".maxElementsInMemory";
      private static final String PROPERTY_ETERNAL = ".eternal";
      private static final String PROPERTY_TIME_TO_IDLE = ".timeToIdleSeconds";
      private static final String PROPERTY_TIME_TO_LIVE = ".timeToLiveSeconds";
      private static final String PROPERTY_OVERFLOW_TO_DISK = ".overflowToDisk";
      private static final String PROPERTY_DISK_PERSISTENT = ".diskPersistent";
      private static final String PROPERTY_DISK_EXPIRY = ".diskExpiryThreadIntervalSeconds";
      private static final String PROPERTY_MAX_ELEMENTS_DISK = ".maxElementsOnDisk";
      private static final String PROPERTY_STATISTICS = ".statistics";
  
      // Datastore
      private static final String KEY_PREFIX = "core.cache.status.";
  
      // JMX monitoring properties
      private static final String PROPERTY_JMX_MONITORING = "lutece.cache.jmx.monitoring.enabled";
      private static final String PROPERTY_MONITOR_CACHE_MANAGER = "lutece.cache.jmx.monitorCacheManager";
      private static final String PROPERTY_MONITOR_CACHES = "lutece.cache.jmx.monitorCaches";
      private static final String PROPERTY_MONITOR_CACHE_CONFIGURATIONS = "lutece.cache.jmx.monitorCacheConfiguration";
      private static final String PROPERTY_MONITOR_CACHE_STATISTICS = "lutece.cache.jmx.monitorCacheStatistics";
      private static final String FALSE = "false";
      private static final String TRUE = "true";
      private static final String ENABLED = "1";
      private static final String DISABLED = "0";
      private static final String NOT_FOUND = "NOT FOUND";
      private static final String PREFIX_DEFAULT = "lutece.cache.default";
      private static final String LUTECE_CACHEMANAGER_NAME = "LuteceCacheManager";
      private static CacheService _singleton;
      private static CacheManager _manager;
  
      private static List<CacheableService> _listCacheableServicesRegistry = new ArrayList<>( );
      private int _nDefaultMaxElementsInMemory;
      private boolean _bDefaultEternal;
     private long _lDefaultTimeToIdle;
     private long _lDefaultTimeToLive;
     private boolean _bDefaultOverflowToDisk;
     private boolean _bDefaultDiskPersistent;
     private long _lDefaultDiskExpiry;
     private int _nDefaultMaxElementsOnDisk;
     private boolean _bDefaultStatistics;
 
     /**
      * Creates a new instance of CacheService
      */
     private CacheService( )
     {
     }
 
     /**
      * Gets the unique instance of the CacheService
      *
      * @return The unique instance of the CacheService
      */
     public static synchronized CacheService getInstance( )
     {
         if ( _singleton == null )
         {
             _singleton = new CacheService( );
             _singleton.init( );
             Configuration configuration = ConfigurationFactory.parseConfiguration( );
             configuration.setName( LUTECE_CACHEMANAGER_NAME );
             _manager = CacheManager.create( configuration );
         }
 
         return _singleton;
     }
 
     /**
      * Itializes the service by creating a manager object with a given configuration file.
      */
     private void init( )
     {
         loadDefaults( );
         loadCachesConfig( );
 
         boolean bJmxMonitoring = AppPropertiesService.getProperty( PROPERTY_JMX_MONITORING, FALSE ).equals( TRUE );
 
         if ( bJmxMonitoring )
         {
             initJmxMonitoring( );
         }
     }
 
     /**
      * Init JMX monitoring configuration
      */
     private void initJmxMonitoring( )
     {
         MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer( );
 
         boolean bRegisterCacheManager = AppPropertiesService.getProperty( PROPERTY_MONITOR_CACHE_MANAGER, FALSE ).equals( TRUE );
         boolean bRegisterCaches = AppPropertiesService.getProperty( PROPERTY_MONITOR_CACHES, FALSE ).equals( TRUE );
         boolean bRegisterCacheConfigurations = AppPropertiesService.getProperty( PROPERTY_MONITOR_CACHE_CONFIGURATIONS, FALSE ).equals( TRUE );
         boolean bRegisterCacheStatistics = AppPropertiesService.getProperty( PROPERTY_MONITOR_CACHE_STATISTICS, FALSE ).equals( TRUE );
         ManagementService.registerMBeans( _manager, mBeanServer, bRegisterCacheManager, bRegisterCaches, bRegisterCacheConfigurations,
                 bRegisterCacheStatistics );
     }
 
     /**
      * Create a cache for a given Service
      *
      * @param strCacheName
      *            The Cache/Service name
      * @return A cache object
      */
     public Cache createCache( String strCacheName )
     {
         Cache cache = new Cache( getCacheConfiguration( strCacheName ) );
         _manager.addCache( cache );
 
         return _manager.getCache( strCacheName );
     }
 
     /**
      * Reset all caches
      */
     public static void resetCaches( )
     {
         // Reset cache
         for ( CacheableService cs : _listCacheableServicesRegistry )
         {
             cs.resetCache( );
         }
     }
 
     /**
      * Shutdown the cache service and the cache manager. Should be called when the webapp is stopped.
      */
     public void shutdown( )
     {
         CacheService.storeCachesStatus( );
         _manager.shutdown( );
     }
 
     /**
      * Registers a new CacheableService
      *
      * @param cs
      *            The CacheableService
      */
     public static void registerCacheableService( CacheableService cs )
     {
         _listCacheableServicesRegistry.add( cs );
 
         // read cache status from file "caches.dat"
         cs.enableCache( getStatus( cs ) );
     }
 
     /**
      * Returns all registered Cacheable services
      *
      * @return A collection containing all registered Cacheable services
      */
     public static List<CacheableService> getCacheableServicesList( )
     {
         return _listCacheableServicesRegistry;
     }
 
     /**
      * Stores cache status
      */
     public static void storeCachesStatus( )
     {
         for ( CacheableService cs : _listCacheableServicesRegistry )
         {
             String strKey = getDSKey( cs.getName( ), PROPERTY_IS_ENABLED );
             DatastoreService.setInstanceDataValue( strKey, cs.isCacheEnable( ) ? ENABLED : DISABLED );
         }
     }
 
     /**
      * Returns cache config
      *
      * @param cache
      *            The cache
      * @return Cache infos
      */
     static String getInfos( Cache cache )
     {
         StringBuilder sbInfos = new StringBuilder( );
         sbInfos.append( PROPERTY_MAX_ELEMENTS ).append( "=" ).append( cache.getCacheConfiguration( ).getMaxElementsInMemory( ) ).append( "\n" );
         sbInfos.append( PROPERTY_ETERNAL ).append( "=" ).append( cache.getCacheConfiguration( ).isEternal( ) ).append( "\n" );
         sbInfos.append( PROPERTY_TIME_TO_IDLE ).append( "=" ).append( cache.getCacheConfiguration( ).getTimeToIdleSeconds( ) ).append( "\n" );
         sbInfos.append( PROPERTY_TIME_TO_LIVE ).append( "=" ).append( cache.getCacheConfiguration( ).getTimeToLiveSeconds( ) ).append( "\n" );
         sbInfos.append( PROPERTY_OVERFLOW_TO_DISK ).append( "=" ).append( cache.getCacheConfiguration( ).isOverflowToDisk( ) ).append( "\n" );
         sbInfos.append( PROPERTY_DISK_PERSISTENT ).append( "=" ).append( cache.getCacheConfiguration( ).isDiskPersistent( ) ).append( "\n" );
         sbInfos.append( PROPERTY_DISK_EXPIRY ).append( "=" ).append( cache.getCacheConfiguration( ).getDiskExpiryThreadIntervalSeconds( ) ).append( "\n" );
         sbInfos.append( PROPERTY_MAX_ELEMENTS_DISK ).append( "=" ).append( cache.getCacheConfiguration( ).getMaxElementsOnDisk( ) ).append( "\n" );
         sbInfos.append( PROPERTY_STATISTICS ).append( '=' ).append( cache.getCacheConfiguration( ).getStatistics( ) ).append( "\n" );
 
         return sbInfos.toString( );
     }
 
     /**
      * Load defaults configuration parameters
      */
     private void loadDefaults( )
     {
         _nDefaultMaxElementsInMemory = AppPropertiesService.getPropertyInt( PREFIX_DEFAULT + PROPERTY_MAX_ELEMENTS, 10000 );
         _bDefaultEternal = AppPropertiesService.getPropertyBoolean( PREFIX_DEFAULT + PROPERTY_ETERNAL, false );
         _lDefaultTimeToIdle = AppPropertiesService.getPropertyLong( PREFIX_DEFAULT + PROPERTY_TIME_TO_IDLE, 10000L );
         _lDefaultTimeToLive = AppPropertiesService.getPropertyLong( PREFIX_DEFAULT + PROPERTY_TIME_TO_LIVE, 10000L );
         _bDefaultOverflowToDisk = AppPropertiesService.getPropertyBoolean( PREFIX_DEFAULT + PROPERTY_OVERFLOW_TO_DISK, true );
         _bDefaultDiskPersistent = AppPropertiesService.getPropertyBoolean( PREFIX_DEFAULT + PROPERTY_DISK_PERSISTENT, true );
         _lDefaultDiskExpiry = AppPropertiesService.getPropertyLong( PREFIX_DEFAULT + PROPERTY_DISK_EXPIRY, 120L );
         _nDefaultMaxElementsOnDisk = AppPropertiesService.getPropertyInt( PREFIX_DEFAULT + PROPERTY_MAX_ELEMENTS_DISK, 10000 );
         _bDefaultStatistics = AppPropertiesService.getPropertyBoolean( PREFIX_DEFAULT + PROPERTY_STATISTICS, false );
     }
 
     /**
      * Load caches status
      */
     private void loadCachesConfig( )
     {
         String strCachesStatusFile = AppPathService.getPath( PROPERTY_PATH_CONF, FILE_CACHES_STATUS );
         File file = new File( strCachesStatusFile );
 
         try ( FileInputStream fis = new FileInputStream( file ) )
         {
             Properties properties = new Properties( );
             properties.load( fis );
 
             // If the keys aren't found in the datastore then create a key in it
             for ( String strKey : properties.stringPropertyNames( ) )
             {
                 String strDSKey = KEY_PREFIX + strKey;
 
                 if ( !DatastoreService.existsInstanceKey( strDSKey ) )
                 {
                     String strValue = properties.getProperty( strKey );
                     DatastoreService.setInstanceDataValue( strDSKey, strValue );
                 }
             }
         }
         catch( FileNotFoundException e )
         {
             AppLogService.error( "No cache.dat file. Should be created at shutdown." );
         }
         catch( Exception e )
         {
             AppLogService.error( "Error loading caches status defined in file : {}", file.getAbsolutePath( ), e );
         }
     }
 
     /**
      * Update cache status
      * 
      * @param cs
      *            Cacheable Service
      */
     public static void updateCacheStatus( CacheableService cs )
     {
         String strKey = getDSKey( cs.getName( ), PROPERTY_IS_ENABLED );
         DatastoreService.setInstanceDataValue( strKey, ( cs.isCacheEnable( ) ? ENABLED : DISABLED ) );
     }
 
     /**
      * Returns the cache status
      *
      * @param cs
      *            The cacheable service
      * @return The status
      */
     private static boolean getStatus( CacheableService cs )
     {
         String strEnabled = DatastoreService.getInstanceDataValue( getDSKey( cs.getName( ), PROPERTY_IS_ENABLED ), DISABLED );
 
         return strEnabled.equals( ENABLED );
     }
 
     /**
      * Return the key of a datastore property
      * 
      * @param strCacheName
      *            The cacheable service
      * @param strProperty
      *            The property
      * @return The DS key
      */
     private static String getDSKey( String strCacheName, String strProperty )
     {
         return KEY_PREFIX + normalizeName( strCacheName ) + strProperty;
     }
 
     /**
      * Normalize name (remove spaces)
      *
      * @param strName
      *            The name to normalize
      * @return The normalized name
      */
     private static String normalizeName( String strName )
     {
         return strName.replace( " ", "" );
     }
 
     /**
      * Read cache config from the file caches.dat
      *
      * @param strCacheName
      *            The cache name
      * @return The config
      */
     private CacheConfiguration getCacheConfiguration( String strCacheName )
     {
         CacheConfiguration config = new CacheConfiguration( );
         config.setName( strCacheName );
         config.setMaxElementsInMemory( getIntProperty( strCacheName, PROPERTY_MAX_ELEMENTS, _nDefaultMaxElementsInMemory ) );
         config.setEternal( getBooleanProperty( strCacheName, PROPERTY_ETERNAL, _bDefaultEternal ) );
         config.setTimeToIdleSeconds( getLongProperty( strCacheName, PROPERTY_TIME_TO_IDLE, _lDefaultTimeToIdle ) );
         config.setTimeToLiveSeconds( getLongProperty( strCacheName, PROPERTY_TIME_TO_LIVE, _lDefaultTimeToLive ) );
         config.setOverflowToDisk( getBooleanProperty( strCacheName, PROPERTY_OVERFLOW_TO_DISK, _bDefaultOverflowToDisk ) );
         config.setDiskPersistent( getBooleanProperty( strCacheName, PROPERTY_DISK_PERSISTENT, _bDefaultDiskPersistent ) );
         config.setDiskExpiryThreadIntervalSeconds( getLongProperty( strCacheName, PROPERTY_DISK_EXPIRY, _lDefaultDiskExpiry ) );
         config.setMaxElementsOnDisk( getIntProperty( strCacheName, PROPERTY_MAX_ELEMENTS_DISK, _nDefaultMaxElementsOnDisk ) );
         config.setStatistics( getBooleanProperty( strCacheName, PROPERTY_STATISTICS, _bDefaultStatistics ) );
 
         return config;
     }
 
     /**
      * Read an Integer property
      *
      * @param strCacheName
      *            Property's prefix
      * @param strProperty
      *            the key
      * @param nDefault
      *            the default value
      * @return The property's value
      */
     private int getIntProperty( String strCacheName, String strProperty, int nDefault )
     {
         String strKey = getDSKey( strCacheName, strProperty );
 
         if ( DatastoreService.existsInstanceKey( strKey ) )
         {
             String strValue = NOT_FOUND;
 
             try
             {
                 strValue = DatastoreService.getInstanceDataValue( strKey, strValue );
 
                 return Integer.parseInt( strValue );
             }
             catch( NumberFormatException e )
             {
                 AppLogService.error( ERROR_NUMERIC_PROP, strCacheName, strProperty, strValue, e );
             }
         }
 
         return nDefault;
     }
 
     /**
      * Read a Long property
      *
      * @param strCacheName
      *            Property's prefix
      * @param strProperty
      *            the key
      * @param lDefault
      *            the default value
      * @return The property's value
      */
     private long getLongProperty( String strCacheName, String strProperty, long lDefault )
     {
         String strKey = getDSKey( strCacheName, strProperty );
 
         if ( DatastoreService.existsInstanceKey( strKey ) )
         {
             String strValue = NOT_FOUND;
 
             try
             {
                 strValue = DatastoreService.getInstanceDataValue( strKey, strValue );
 
                 return Integer.parseInt( strValue );
             }
             catch( NumberFormatException e )
             {
                 AppLogService.error( ERROR_NUMERIC_PROP, strCacheName, strProperty, strValue, e );
             }
         }
 
         return lDefault;
     }
 
     /**
      * Read a Boolean property
      *
      * @param strCacheName
      *            Property's prefix
      * @param strProperty
      *            the key
      * @param bDefault
      *            the default value
      * @return The property's value
      */
     private boolean getBooleanProperty( String strCacheName, String strProperty, boolean bDefault )
     {
         String strKey = getDSKey( strCacheName, strProperty );
 
         if ( DatastoreService.existsInstanceKey( strKey ) )
         {
             String strValue = DatastoreService.getInstanceDataValue( strKey, NOT_FOUND );
 
             return ( strValue.equalsIgnoreCase( TRUE ) );
         }
 
         return bDefault;
     }
 }