/*
    * Copyright (c) 2002-2024, 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.plugins.identitystore.business.identity;
  
  import fr.paris.lutece.plugins.identitystore.service.IdentityStorePlugin;
  import fr.paris.lutece.plugins.identitystore.v3.web.rs.dto.crud.UpdatedIdentityDto;
  import fr.paris.lutece.plugins.identitystore.v3.web.rs.dto.history.IdentityChange;
  import fr.paris.lutece.plugins.identitystore.v3.web.rs.dto.history.IdentityChangeType;
  import fr.paris.lutece.plugins.identitystore.v3.web.rs.dto.search.SearchAttribute;
  import fr.paris.lutece.plugins.identitystore.v3.web.rs.dto.search.SearchUpdatedAttribute;
  import fr.paris.lutece.plugins.identitystore.web.exception.IdentityStoreException;
  import fr.paris.lutece.portal.service.plugin.Plugin;
  import fr.paris.lutece.portal.service.plugin.PluginService;
  import fr.paris.lutece.portal.service.spring.SpringContextService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  import org.apache.commons.lang3.tuple.Pair;
  
  import java.sql.Timestamp;
  import java.util.Date;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  
  /**
   * This class provides instances management methods (create, find, ...) for Identity objects
   */
  public final class IdentityHome
  {
      private static final int PROPERTY_MAX_NB_IDENTITY_RETURNED = AppPropertiesService.getPropertyInt("identitystore.search.maxNbIdentityReturned", 0);
  
      // Static variable pointed at the DAO instance
      private static final IIdentityDAO _dao = SpringContextService.getBean( IIdentityDAO.BEAN_NAME );
      private static final Plugin _plugin = PluginService.getPlugin( IdentityStorePlugin.PLUGIN_NAME );
  
      /**
       * Private constructor - this class need not be instantiated
       */
      private IdentityHome( )
      {
      }
  
      /**
       * Create an instance of the identity class
       *
       * @param identity
       *            The instance of the Identity which contains the informations to store
       * @return The instance of identity which has been created with its primary key.
       */
      public static Identitys/identitystore/business/identity/Identity.html#Identity">Identity create( final Identity identity, final int dataRetentionPeriodInMonth )
      {
          _dao.insert( identity, dataRetentionPeriodInMonth, _plugin );
  
          return identity;
      }
  
      /**
       * Update of the identity which is specified in parameter
       *
       * @param identity
       *            The instance of the Identity which contains the data to store
       * @return The instance of the identity which has been updated
       */
      public static Identity../../../../../../../fr/paris/lutece/plugins/identitystore/business/identity/Identity.html#Identity">Identity update( Identity identity )
      {
          _dao.store( identity, _plugin );
  
          return identity;
      }
 
     /**
      * Archive identities which have been merge as secondary
      *
      * @param identity
      * @return
      */
     public static Identity"../../../../../../../fr/paris/lutece/plugins/identitystore/business/identity/Identity.html#Identity">Identity merge( Identity identity )
     {
         _dao.merge( identity, _plugin );
         IdentityAttributeHome.removeAllAttributes( identity.getId() );
 
         return identity;
     }
 
     public static void cancelMerge( Identity identity )
     {
         _dao.cancelMerge( identity, _plugin );
     }
 
     /**
      * Remove the identity whose identifier is specified in parameter
      *
      * @param nIdentityId
      *            The identity Id
      */
     public static void hardRemove( int nIdentityId )
     {
         IdentityAttributeHome.removeAllAttributes( nIdentityId );
         _dao.hardDelete( nIdentityId, _plugin );
     }
 
     public static void softRemove( String strCuid )
     {
         _dao.softDelete( strCuid, _plugin );
     }
 
     /**
      * Find an identity ID from the specified customer ID
      *
      * @param strCustomerId
      *            the customer ID
      * @return the identity ID
      */
     public static int findIdByCustomerId( String strCustomerId )
     {
         return _dao.selectIdByCustomerId( strCustomerId, _plugin );
     }
 
     /**
      * Returns an instance of a identity whose identifier is specified in parameter
      *
      * @param nKey
      *            The identity primary key
      * @return an instance of Identity
      */
     public static Identity findByPrimaryKey( int nKey )
     {
         return _dao.load( nKey, _plugin );
     }
 
     /**
      * Select All {@link Identity}
      *
      * @return The Identity
      */
     public static List<Identity> findAll( )
     {
         final List<Identity> identities = _dao.selectAll( _plugin );
         identities.forEach( identity -> identity.setAttributes( IdentityAttributeHome.getAttributes( identity.getId( ) ) ) );
         return identities;
     }
 
     /**
      * Find by connection ID
      *
      * @param strConnectionId
      *            The connection ID
      * @return The Identity
      */
     public static Identity findByConnectionId( String strConnectionId )
     {
         return _dao.selectByConnectionId( strConnectionId, _plugin );
     }
 
     /**
      * Find history by customer ID
      *
      * @param strCustomerId
      *            The customer ID
      * @return The Identity
      */
     public static List<IdentityChange> findHistoryByCustomerId( String strCustomerId ) throws IdentityStoreException
     {
         return _dao.selectIdentityHistoryByCustomerId( strCustomerId, _plugin );
     }
 
     /**
      * Find history by customer search parameters
      *
      * @param strCustomerId
      *            The customer ID
      * @return The Identity
      */
     public static List<IdentityChange> findHistoryBySearchParameters( final String strCustomerId, final String clientCode, final String authorName,
             final IdentityChangeType changeType, final String changeStatus, final String authorType, final Date modificationDate, final Map<String, String> metadata, final Integer nbDaysFrom,
             final Pair<Date, Date> modificationDateInterval, final int max ) throws IdentityStoreException
     {
         int nMaxNbIdentityReturned = ( max > 0 ) ? max : PROPERTY_MAX_NB_IDENTITY_RETURNED;
         return _dao.selectIdentityHistoryBySearchParameters( strCustomerId, clientCode, authorName, changeType, changeStatus, authorType, modificationDate, metadata, nbDaysFrom,
                 modificationDateInterval, _plugin, nMaxNbIdentityReturned );
     }
 
     /**
      * Find by customer ID
      *
      * @param strCustomerId
      *            The customer ID
      * @return The Identity
      */
     public static Identity findByCustomerId( String strCustomerId )
     {
         Identity identity = _dao.selectByCustomerId( strCustomerId, _plugin );
 
         if ( identity != null )
         {
             identity.setAttributes( IdentityAttributeHome.getAttributes( identity.getId( ) ) );
         }
 
         return identity;
     }
 
     /**
      * Find by customer ID. Does not load the attributes.
      *
      * @param strCustomerId
      *            The customer ID
      * @return The Identity without attributes
      */
     public static Identity findByCustomerIdNoAttributes( String strCustomerId )
     {
         return _dao.selectByCustomerId( strCustomerId, _plugin );
     }
 
     /**
      * Find by customer ID
      *
      * @param strCustomerId
      *            The customer ID
      * @return The Identity
      */
     public static Identity findMasterIdentityByCustomerId( String strCustomerId )
     {
         Identity identity = _dao.selectNotMergedByCustomerId( strCustomerId, _plugin );
 
         if ( identity != null )
         {
             identity.setAttributes( IdentityAttributeHome.getAttributes( identity.getId( ) ) );
         }
 
         return identity;
     }
 
     /**
      * Get the master identity last update date coresponding to the given customer ID
      * 
      * @param customerId
      *            the customer ID
      * @return the last update date or null if the identity doesn't exist for the provided CUID
      */
     public static Timestamp getMasterIdentityLastUpdateDate( final String customerId )
     {
         final Identity identity = _dao.selectNotMergedByCustomerId( customerId, _plugin );
         return identity != null ? identity.getLastUpdateDate( ) : null;
     }
 
     /**
      * Find by connection ID
      *
      * @param strConnectionId
      *            The customer ID
      * @return The Identity
      */
     public static Identity findMasterIdentityByConnectionId( String strConnectionId )
     {
         Identity identity = _dao.selectNotMergedByConnectionId( strConnectionId, _plugin );
 
         if ( identity != null )
         {
             identity.setAttributes( IdentityAttributeHome.getAttributes( identity.getId( ) ) );
         }
 
         return identity;
     }
 
     /**
      * Get the master identity without attributes coresponding to the given connection ID
      * 
      * @param connectionId
      *            the connection ID
      * @return the identity or null if the identity doesn't exist for the provided connection ID
      */
     public static Identity getMasterIdentityNoAttributesByConnectionId( final String connectionId )
     {
         return _dao.selectNotMergedByConnectionId( connectionId, _plugin );
     }
 
     /**
      * Find all identities matching one of the values defined on each of the selected Attributes. One value must be found for all selected attributes. Always
      * performs an exact search.
      *
      * @param mapAttributes
      *            A map that associates the id of each attributes selected with the list of values
      * @return list of Identity
      */
     public static List<Identity> findByAttributesValueForApiSearch(final List<SearchAttribute> searchAttributes, final int max )
     {
         int nMaxNbIdentityReturned = ( max > 0 ) ? max : PROPERTY_MAX_NB_IDENTITY_RETURNED;
         return _dao.selectByAttributesValueForApiSearch( searchAttributes, nMaxNbIdentityReturned, _plugin );
     }
 
     /**
      * Find all identities that have all attributes specified in the list in parameters.<br/>
      * Identities <b>MUST</b> have all those attributes in order to be returned.
      *
      * @param idAttributeList
      *            the attributes id
      * @param notMerged
      *            if the returned identities have to be not merged
      * @param notSuspicious
      *            if the returned identities have to not be suspicious
      * @param nbFilledAttributes
      *            minimum number of filled attributes over idAttributeList
      * @return A list of matching customer IDs
      */
     public static List<String> findByAttributeExisting( final List<Integer> idAttributeList, final int nbFilledAttributes, final boolean notMerged,
             final boolean notSuspicious, final int rulePriority )
     {
         return _dao.selectByAttributeExisting( idAttributeList, nbFilledAttributes, notMerged, notSuspicious, rulePriority, _plugin );
     }
 
     /**
      * add an identity change event in history table
      *
      * @param identityChange
      *            identity change event
      */
     public static void addIdentityChangeHistory( IdentityChange identityChange ) throws IdentityStoreException
     {
         if ( Objects.equals( identityChange.getChangeType( ), IdentityChangeType.READ ) )
         {
             _dao.addOrUpdateChangeHistory( identityChange, _plugin );
         }
         else
         {
             _dao.addChangeHistory( identityChange, _plugin );
         }
     }
 
     /**
      * get identities that have been updated during the previous `days`.
      *
      * @param days
      *            max number of days since the last update
      * @param identityChangeTypes
      *            filters on specific change types
      * @param updatedAttributes
      *            filters on specific updated attributes
      * @return the list of identities
      */
     public static List<UpdatedIdentityDto> findUpdatedIdentities( final Integer days, final List<IdentityChangeType> identityChangeTypes,
             final List<SearchUpdatedAttribute> updatedAttributes, final Integer max )
     {
         int nMaxNbIdentityReturned = ( max > 0 ) ? max : PROPERTY_MAX_NB_IDENTITY_RETURNED;
         return _dao.selectUpdated( days, identityChangeTypes, updatedAttributes, nMaxNbIdentityReturned, _plugin );
     }
 
     /**
      * get identity IDs that have been updated during the previous `days`.
      *
      * @param days
      *            max number of days since the last update
      * @param identityChangeTypes
      *            filters on specific change types
      * @param updatedAttributes
      *            filters on specific updated attributes
      * @return the list of identities
      */
     public static List<Integer> findUpdatedIdentityIds( final Integer days, final List<IdentityChangeType> identityChangeTypes,
             final List<SearchUpdatedAttribute> updatedAttributes, final Integer max )
     {
         int nMaxNbIdentityReturned = ( max > 0 ) ? max : PROPERTY_MAX_NB_IDENTITY_RETURNED;
         return _dao.selectUpdatedIds( days, identityChangeTypes, updatedAttributes, nMaxNbIdentityReturned, _plugin );
     }
 
     /**
      * get updated identities from their IDs.
      * 
      * @param identityIds
      *            list of desired identity IDs
      * @return the list of identities
      */
     public static List<UpdatedIdentityDto> getUpdatedIdentitiesFromIds( final List<Integer> identityIds )
     {
         return _dao.selectUpdatedFromIds( identityIds, _plugin );
     }
 
     /**
      * Search for identities that are not connected, and have a past expirationDate.
      * 
      * @param limit
      *            the max number of returned results
      * @return a list of expired {@link Identity}
      */
     public static List<Identity> findExpiredNotMergedAndNotConnectedIdentities( final int limit )
     {
         return _dao.selectExpiredNotMergedAndNotConnectedIdentities( limit, _plugin );
     }
 
     /**
      * Search for identity customer IDs that are not connected, not merged, and have the specified attribute non-certified.
      *
      * @param attributeKey
      *            the attribute key to be present and non-certified
      * @param limit
      *            the max number of returned identities
      * @return a list of customer IDs
      */
     public static List<String> findNotMergedNotConnectedWithNonCertifiedAttributeCustomerIds( final String attributeKey, String certProcess, final int limit )
     {
         return _dao.selectNotMergedNotConnectedWithNonCertifiedAttributeCustomerIds( attributeKey, certProcess, limit, _plugin );
     }
 
     /**
      * Search for identities that are merged to the provided identity ID.
      * 
      * @param identityId
      *            the 'master' identity ID
      * @return a list of {@link Identity}
      */
     public static List<Identity> findMergedIdentities( final int identityId )
     {
         return _dao.selectMergedIdentities( identityId, _plugin );
     }
 
     /**
      * Delete all attribute history of the identity's provided id.
      * 
      * @param identityId
      *            the identity id
      */
     public static void deleteAttributeHistory( final int identityId )
     {
         _dao.deleteAttributeHistory( identityId, _plugin );
     }
 
     /**
      * Count All Identities.
      */
     public static Integer getCountIdentities( )
     {
         return _dao.getCountIdentities( _plugin );
     }
 
     /**
      * Count All identities that has been deleted or not.
      *
      * @param deleted
      *            define if the dao count deleted or not deleted identities
      */
     public static Integer getCountDeletedIdentities( final boolean deleted )
     {
         return _dao.getCountDeletedIdentities( deleted, _plugin) ;
     }
 
     /**
      * Count All identities that has been merged or not.
      *
      * @param merged
      *            define if the dao count merged or not merged identities
      */
     public static Integer getCountMergedIdentities( final boolean merged )
     {
         return _dao.getCountMergedIdentities( merged, _plugin );
     }
 
     /**
      * Count All identities that has been connected or not.
      *
      * @param monParisActive
      *            define if the dao count connected or not connected identities
      */
     public static Integer getCountActiveMonParisdentities( final boolean monParisActive )
     {
         return _dao.getCountActiveMonParisdentities( monParisActive, _plugin );
     }
 
     /**
      * Count how many attributes each entity has.
      */
     public static Map<Integer, Integer> getCountAttributesByIdentities( )
     {
         return _dao.getCountAttributesByIdentities( _plugin );
     }
 
     /**
      * Count how many attributes has no attribute and isn't merged.
      */
     public static Integer getCountUnmergedIdentitiesWithoutAttributes( )
     {
         return _dao.getCountUnmergedIdentitiesWithoutAttributes( _plugin );
     }
 
     public static Integer getCountIndexEligibleIdentities( )
     {
         return _dao.getCountIndexEligibleIdentities( _plugin );
     }
 
     public static Integer getCountIndexNotEligibleIdentities( )
     {
         return _dao.getCountIndexNotEligibleIdentities( _plugin );
     }
 
     public static List<IndicatorsActionsType> getActionsTypesDuringInterval(int interval)
     {
         return _dao.getActionsTypesDuringInterval(interval, _plugin);
     }
 
     public static List<String> getHistoryStatusList( )
     {
         return _dao.getHistoryStatusList( _plugin );
     }
 }