/*
    *   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
    *
   *     https://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.directory.ldap.client.api;
  
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.PrintStream;
  import java.io.Writer;
  import java.nio.charset.Charset;
  import java.nio.file.Files;
  import java.nio.file.Paths;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.directory.api.ldap.model.constants.SchemaConstants;
  import org.apache.directory.api.ldap.model.entry.Attribute;
  import org.apache.directory.api.ldap.model.entry.DefaultAttribute;
  import org.apache.directory.api.ldap.model.entry.DefaultEntry;
  import org.apache.directory.api.ldap.model.entry.DefaultModification;
  import org.apache.directory.api.ldap.model.entry.Entry;
  import org.apache.directory.api.ldap.model.entry.Modification;
  import org.apache.directory.api.ldap.model.entry.Value;
  import org.apache.directory.api.ldap.model.exception.LdapException;
  import org.apache.directory.api.ldap.model.exception.LdapInvalidAttributeValueException;
  import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException;
  import org.apache.directory.api.ldap.model.ldif.ChangeType;
  import org.apache.directory.api.ldap.model.ldif.LdifEntry;
  import org.apache.directory.api.ldap.model.ldif.LdifReader;
  import org.apache.directory.api.ldap.model.ldif.LdifUtils;
  import org.apache.directory.api.ldap.model.ldif.anonymizer.Anonymizer;
  import org.apache.directory.api.ldap.model.ldif.anonymizer.BinaryAnonymizer;
  import org.apache.directory.api.ldap.model.ldif.anonymizer.CaseSensitiveStringAnonymizer;
  import org.apache.directory.api.ldap.model.ldif.anonymizer.IntegerAnonymizer;
  import org.apache.directory.api.ldap.model.ldif.anonymizer.StringAnonymizer;
  import org.apache.directory.api.ldap.model.ldif.anonymizer.TelephoneNumberAnonymizer;
  import org.apache.directory.api.ldap.model.name.Ava;
  import org.apache.directory.api.ldap.model.name.Dn;
  import org.apache.directory.api.ldap.model.name.Rdn;
  import org.apache.directory.api.ldap.model.schema.AttributeType;
  import org.apache.directory.api.ldap.model.schema.LdapSyntax;
  import org.apache.directory.api.ldap.model.schema.SchemaManager;
  import org.apache.directory.api.ldap.model.schema.syntaxCheckers.DnSyntaxChecker;
  import org.apache.directory.api.ldap.model.schema.syntaxCheckers.NameAndOptionalUIDSyntaxChecker;
  import org.apache.directory.api.ldap.schema.manager.impl.DefaultSchemaManager;
  
  
  /**
   * Anonymize the content of a LDIF file.
   * 
   * We will replace the values of the defined attributes with random chars. There are a default
   * list of attributes that are going to be anonymized :
   * <ul>
   * <li>userPassword</li>
   * <li>displayName</li>
   * <li>givenName</li>
   * <li>surName</li>
   * <li>homePhone</li>
   * <li>homePostalAddress</li>
   * <li>jpegPhoto</li>
   * <li>labeledURI</li>
   * <li>mail</li>
   * <li>manager</li>
   * <li>mobile</li>
   * <li>organizationName</li>
   * <li>pager</li>
   * <li>photo</li>
   * <li>secretary</li>
   * <li>uid</li>
   * <li>userCertificate</li>
   * <li>userPKCS12</li>
   * <li>userSMIMECertificate</li>
   * <li>x500UniqueIdentifier</li>
   * <li>carLicense</li>
  * <li>host</li>
  * <li>locality</li>
  * <li>organizationName</li>
  * <li>organizationalUnitName</li>
  * <li>seelAlso</li>
  * <li>homeDirectory</li>
  * <li>uidNumber</li>
  * <li>gidNumber</li>
  * <li>commonName</li>
  * <li>gecos</li>
  * <li>description</li>
  * <li>memberUid</li>
  * </ul>
  *
  * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
  */
 public class LdifAnonymizer
 {
     /** The map that stores the anonymized values associated to the original value */
     private Map<Value, Value> valueMap = new HashMap<>();
     
     /** The set that contains all the values we already have anonymized */
     private Set<Value> valueSet = new HashSet<>();
     
     /** The latest anonymized String value Map */
     private Map<Integer, String> latestStringMap;
     
     /** The latest anonymized byte[] value Map */
     private Map<Integer, byte[]> latestBytesMap;
     
     /** The map of AttributeType'sOID we want to anonymize. They are all associated with anonymizers */
     private Map<String, Anonymizer> attributeAnonymizers = new HashMap<>();
     
     /** The list of existing NamingContexts */
     private Set<Dn> namingContexts = new HashSet<>();
 
     /** The schemaManager */
     private SchemaManager schemaManager;
     
     /** The PrintStream used to write informations about the processing */
     private PrintStream out = null;
 
     /**
      * Creates a default instance of LdifAnonymizer. The list of anonymized attribute
      * is set to a default value.
      *
      */
     public LdifAnonymizer()
     {
         try
         {
             schemaManager = new DefaultSchemaManager();
         }
         catch ( Exception e )
         {
             println( "Missing a SchemaManager !" );
             System.exit( -1 );
         }
 
         init( null, null, null, null );
     }
     
     
     /**
      * Creates a default instance of LdifAnonymizer. The list of anonymized attribute
      * is set to a default value.
      * 
      * @param schemaManager The SchemaManager instance we will use
      */
     public LdifAnonymizer( SchemaManager schemaManager )
     {
         this.schemaManager = schemaManager;
 
         init( null, null, null, null );
     }
     
     
     /**
      * Set the PrintStream to use to print information about the processing
      * 
      * @param out The PrintStream to use
      */
     public void setOut( PrintStream out )
     {
         this.out = out;
     }
     
     
     /**
      * Print the string into the PrintStream, with a NL at the end
      * 
      * @param str The string to print
      */
     private void println( String str )
     {
         if ( out != null )
         {
             out.println( str );
         }
     }
     
     
     /**
      * Print a nl into the PrintStream
      */
     private void println()
     {
         if ( out != null )
         {
             out.println();
         }
     }
     
 
     /**
      * Initialize the anonymizer, filling the maps we use.
      * 
      * @param stringLatestValueMap The map of already seen Strings
      * @param binaryLatestValueMap The map of already seen byte[]
      * @param integerLatestValueMap  The map of already seen Integers
      * @param telephoneNumberLatestValueMap   The map of already seen telephone numbers
      */
     private void init( Map<Integer, String> stringLatestValueMap, Map<Integer, byte[]> binaryLatestValueMap, 
         Map<Integer, String> integerLatestValueMap, Map<Integer, String> telephoneNumberLatestValueMap )
     {
         // Load the anonymizers
         attributeAnonymizers.put( SchemaConstants.CAR_LICENSE_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.DOMAIN_COMPONENT_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.CN_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.DESCRIPTION_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.DISPLAY_NAME_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.GECOS_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.GID_NUMBER_AT_OID,
             new IntegerAnonymizer( integerLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.GIVENNAME_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.HOME_DIRECTORY_AT_OID,
             new CaseSensitiveStringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.HOME_PHONE_AT_OID,
             new TelephoneNumberAnonymizer() );
         attributeAnonymizers.put( SchemaConstants.HOME_POSTAL_ADDRESS_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.HOST_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.HOUSE_IDENTIFIER_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.JPEG_PHOTO_AT_OID,
             new BinaryAnonymizer( binaryLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.LABELED_URI_AT_OID,
             new CaseSensitiveStringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.LOCALITY_NAME_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.MAIL_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.MANAGER_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.MEMBER_UID_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.MOBILE_AT_OID, new TelephoneNumberAnonymizer() );
         attributeAnonymizers.put( SchemaConstants.ORGANIZATION_NAME_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.ORGANIZATIONAL_UNIT_NAME_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.PAGER_AT_OID, new TelephoneNumberAnonymizer() );
         attributeAnonymizers.put( SchemaConstants.POSTAL_ADDRESS_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.PHOTO_AT_OID, new BinaryAnonymizer( binaryLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.SECRETARY_AT_OID,
             new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers
             .put( SchemaConstants.SEE_ALSO_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.SN_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.TELEPHONE_NUMBER_AT_OID,
             new TelephoneNumberAnonymizer( telephoneNumberLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.UID_AT_OID, new StringAnonymizer( stringLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.UID_NUMBER_AT_OID,
             new IntegerAnonymizer( integerLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.USER_CERTIFICATE_AT_OID,
             new BinaryAnonymizer( binaryLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.USER_PASSWORD_AT_OID,
             new BinaryAnonymizer( binaryLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.USER_PKCS12_AT_OID,
             new BinaryAnonymizer( binaryLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.USER_SMIME_CERTIFICATE_AT_OID,
             new BinaryAnonymizer( binaryLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.X500_UNIQUE_IDENTIFIER_AT_OID,
             new BinaryAnonymizer( binaryLatestValueMap ) );
         attributeAnonymizers.put( SchemaConstants.FACSIMILE_TELEPHONE_NUMBER_AT_OID,
             new TelephoneNumberAnonymizer( telephoneNumberLatestValueMap ) );
     }
     
     
     /**
      * Set the latest value map to a defined anonymizer - if it exists -.
      *
      * @param attributeType The AttributeType we are targetting
      * @param latestValueMap The latest value map for this attribute
      */
     public void setAttributeLatestValueMap( AttributeType attributeType, Map<Integer, ?> latestValueMap )
     {
         Anonymizer anonymizer = attributeAnonymizers.get( attributeType.getOid() );
         
         if ( anonymizer != null )
         {
             if ( attributeType.getSyntax().isHumanReadable() )
             {
                 anonymizer.setLatestStringMap( latestValueMap );
             }
             else
             {
                 anonymizer.setLatestBytesMap( latestValueMap );
             }
         }
     }
     
     
     /**
      * Add an attributeType that has to be anonymized
      *
      * @param attributeType the AttributeType that has to be anonymized
      * @throws LdapException If the attributeType cannot be added
      */
     public void addAnonAttributeType( AttributeType attributeType ) throws LdapException
     {
         schemaManager.add( attributeType );
         LdapSyntax syntax = attributeType.getSyntax();
         
         if ( syntax.isHumanReadable() )
         {
             if ( syntax.getOid().equals( SchemaConstants.INTEGER_SYNTAX ) )
             {
                 attributeAnonymizers.put( attributeType.getOid(), new IntegerAnonymizer() );
             }
             else if ( syntax.getOid().equals( SchemaConstants.DIRECTORY_STRING_SYNTAX ) )
             {
                 attributeAnonymizers.put( attributeType.getOid(), new StringAnonymizer() );
             }
             else if ( syntax.getOid().equals( SchemaConstants.TELEPHONE_NUMBER_SYNTAX ) )
             {
                 attributeAnonymizers.put( attributeType.getOid(), new TelephoneNumberAnonymizer() );
             }
         }
         else
         {
             attributeAnonymizers.put( attributeType.getOid(), new BinaryAnonymizer() );
         }
     }
     
     
     /**
      * Add an attributeType that has to be anonymized, with its associated anonymizer.
      *
      * @param attributeType the AttributeType that has to be anonymized
      * @param anonymizer the instance of anonymizer to use with this AttributeType
      * @throws LdapException If the attributeType cannot be added
      */
     public void addAnonAttributeType( AttributeType attributeType, Anonymizer<?> anonymizer ) throws LdapException
     {
         schemaManager.add( attributeType );
         attributeAnonymizers.put( attributeType.getOid(), anonymizer );
     }
     
     
     /**
      * Remove an attributeType that has to be anonymized
      *
      * @param attributeType the AttributeType that we don't want to be anonymized
      */
     public void removeAnonAttributeType( AttributeType attributeType )
     {
         attributeAnonymizers.remove( attributeType.getOid() );
     }
     
     
     /**
      * @return The list of configured anonymizers
      */
     public Map<String, Anonymizer> getAttributeAnonymizers()
     {
         return attributeAnonymizers;
     }
     
     /**
      * Add a new NamingContext
      *
      * @param dn The naming context to add
      * @throws LdapInvalidDnException if it's an invalid naming context
      */
     public void addNamingContext( String dn ) throws LdapInvalidDnException
     {
         Dn namingContext = new Dn( schemaManager, dn );
         namingContexts.add( namingContext );
     }
 
     
     /**
      * Anonymize an AVA
      * 
      * @param ava The AVA to anonymize
      * @return The anonymized AVA
      * @throws LdapInvalidDnException If the Ava is invalid
      * @throws LdapInvalidAttributeValueException If teh Ava content is invalid
      */
     private Ava anonymizeAva( Ava ava ) throws LdapInvalidDnException, LdapInvalidAttributeValueException
     {
         Value value = ava.getValue();
         AttributeType attributeType = ava.getAttributeType();
         Value anonymizedValue = valueMap.get( value );
         Ava anonymizedAva;
         
         if ( anonymizedValue == null )
         {
             Attribute attribute = new DefaultAttribute( attributeType );
             attribute.add( value );
             Anonymizer anonymizer = attributeAnonymizers.get( attribute.getAttributeType().getOid() );
 
             if ( value.isHumanReadable() )
             {
                 if ( anonymizer == null )
                 {
                     anonymizedAva = new Ava( schemaManager, ava.getType(), value.getString() );
                 }
                 else
                 {
                     Attribute anonymizedAttribute = anonymizer.anonymize( valueMap, valueSet, attribute );
                     anonymizedAva = new Ava( schemaManager, ava.getType(), anonymizedAttribute.getString() );
                 }
             }
             else
             {
                 if ( anonymizer == null )
                 {
                     anonymizedAva = new Ava( schemaManager, ava.getType(), value.getBytes() );
                 }
                 else
                 {
                     Attribute anonymizedAttribute = anonymizer.anonymize( valueMap, valueSet, attribute );
 
                     anonymizedAva = new Ava( schemaManager, ava.getType(), anonymizedAttribute.getBytes() );
                 }
             }
         }
         else
         {
             if ( value.isHumanReadable() )
             {
                 anonymizedAva = new Ava( schemaManager, ava.getType(), anonymizedValue.getString() );
             }
             else
             {
                 anonymizedAva = new Ava( schemaManager, ava.getType(), anonymizedValue.getBytes() );
             }
         }
 
         return anonymizedAva;
     }
     
     
     /**
      * Anonymize the entry's DN
      * 
      * @param entryDn The DN to anonymize
      * @return The anonymized DN
      * @throws LdapException If the anonymization failed
      */
     private Dn anonymizeDn( Dn entryDn ) throws LdapException
     {
         // Search for the naming context
         Dn descendant = entryDn;
         Dn namingContext = null;
         
         for ( Dn nc : namingContexts )
         {
             if ( entryDn.isDescendantOf( nc ) )
             { 
                 descendant = entryDn.getDescendantOf( nc );
                 namingContext = nc;
                 break;
             }
         }
         
         Rdn[] anonymizedRdns = new Rdn[entryDn.size()];
         int rdnPos = entryDn.size() - 1;
 
         if ( namingContext != null )
         {
             // Copy the naming contex
             for ( Rdn ncRdn : namingContext )
             {
                 anonymizedRdns[rdnPos] = ncRdn;
                 rdnPos--;
             }
         }
         
         // Iterate on all the RDN
         for ( Rdn rdn : descendant )
         {
             Ava[] anonymizedAvas = new Ava[rdn.size()];
             int pos = 0;
             
             // Iterate on the AVAs
             for ( Ava ava : rdn )
             {
                 Ava anonymizedAva = anonymizeAva( ava );
                 anonymizedAvas[pos] = anonymizedAva;
                 pos++;
             }
 
             Rdn anonymizedRdn = new Rdn( schemaManager, anonymizedAvas );
             anonymizedRdns[rdnPos] = anonymizedRdn;
             rdnPos--;
         }
         
         return new Dn( schemaManager, anonymizedRdns );
     }
 
 
     /**
      * Anonymize a LDIF 
      * 
      * @param ldifFile The ldif file to anonymize
      * @param writer The Writer to use to write the result
      * @throws LdapException If we got some LDAP related exception
      * @throws IOException If we had some issue during some IO operations
      */
     public void anonymizeFile( String ldifFile, Writer writer ) throws LdapException, IOException
     {
         File inputFile = new File( ldifFile );
         
         if ( !inputFile.exists() )
         {
             println( "Cannot open file " + ldifFile );
             return;
         }
         
         try ( LdifReader ldifReader = new LdifReader( inputFile, schemaManager ) )
         {
             int count = 0;
             List<LdifEntry> errors = new ArrayList<>();
             List<String> errorTexts = new ArrayList<>();
     
             try
             {
                 for ( LdifEntry ldifEntry : ldifReader )
                 {
                     count++;
                     
                     try
                     {
                         if ( ldifEntry.isEntry() && !ldifEntry.isChangeAdd() )
                         {
                             // process a full entry. Add changes aren't processed here.
                             Entry newEntry = anonymizeEntry( ldifEntry );
                             
                             writer.write( LdifUtils.convertToLdif( newEntry ) );
                             writer.write( "\n" );
                         }
                         else if ( ldifEntry.isChangeDelete() )
                         {
                             // A Delete operation
                             LdifEntry newLdifEntry = anonymizeChangeDelete( ldifEntry );
     
                             if ( ldifEntry != null )
                             {
                                 writer.write( newLdifEntry.toString() );
                                 writer.write( "\n" );
                             }
                         }
                         else if ( ldifEntry.isChangeAdd() )
                         {
                             // A Add operation
                             LdifEntry newLdifEntry = anonymizeChangeAdd( ldifEntry );
     
                             if ( ldifEntry != null )
                             {
                                 writer.write( newLdifEntry.toString() );
                                 writer.write( "\n" );
                             }
                         }
                         else if ( ldifEntry.isChangeModify() )
                         {
                             // A Modify operation
                             LdifEntry newLdifEntry = anonymizeChangeModify( ldifEntry );
     
                             if ( ldifEntry != null )
                             {
                                 writer.write( newLdifEntry.toString() );
                                 writer.write( "\n" );
                             }
                         }
                         else if ( ldifEntry.isChangeModDn() ||  ldifEntry.isChangeModRdn() )
                         {
                             // A MODDN operation
                             LdifEntry newLdifEntry = anonymizeChangeModDn( ldifEntry );
     
                             if ( ldifEntry != null )
                             {
                                 writer.write( newLdifEntry.toString() );
                                 writer.write( "\n" );
                             }
                         }
     
                         System.out.print( '.' );
                         
                         if ( count % 100  == 0 )
                         {
                             println();
                         }
                     }
                     catch ( Exception e )
                     {
                         System.out.print( '*' );
     
                         if ( count % 100  == 0 )
                         {
                             println();
                         }
                         
                         errors.add( ldifEntry );
                         errorTexts.add( e.getMessage() );
                     }
                 }
     
                 println();
                 
                 if ( !errors.isEmpty() )
                 {
                     println( "There are " + errors.size() + " bad entries" );
                     int i = 0;
                     
                     for ( LdifEntry ldifEntry : errors )
                     {
                         println( "---------------------------------------------------" );
                         println( "error : " + errorTexts.get( i ) );
                         println( ldifEntry.getDn().toString() );
                         i++;
                     }
                 }
             }
             finally
             {
                 println();
     
                 if ( !errors.isEmpty() )
                 {
                     println( "There are " + errors.size() + " bad entries" );
                 }
                     
                 println( "Nb entries : " + count ); 
             }
         }
     }
     
     
     /**
      * Anonymize a Modify change
      * 
      * @param ldifEntry The entry to anonymize
      * @return The anonymized entry
      * @throws LdapException If the anonymization failed
      */
     private LdifEntry anonymizeChangeModify( LdifEntry ldifEntry ) throws LdapException
     {
         Dn entryDn = ldifEntry.getDn();
         LdifEntry newLdifEntry = new LdifEntry( schemaManager );
         newLdifEntry.setChangeType( ChangeType.Modify );
 
         // Process the DN first
         Dn anonymizedDn = anonymizeDn( entryDn );
         
         newLdifEntry.setDn( anonymizedDn );
         
         // Now, process the entry's attributes
         for ( Modification modification : ldifEntry.getModifications() )
         {
             Attribute attribute = modification.getAttribute();
             AttributeType attributeType = schemaManager.getAttributeType( attribute.getId() );
             
             if ( attributeType == null )
             {
                 System.out.println( "\nUnknown AttributeType : " + attribute.getId() + " for entry " + entryDn );
                 
                 return null;
             }
             
             attribute.apply( attributeType );
             
             // Deal with the special case of a DN syntax
             if ( attributeType.getSyntax().getSyntaxChecker() instanceof DnSyntaxChecker )
             {
                 Value[] anonymizedValues = new Value[ attribute.size()];
                 int pos = 0;
                 
                 for ( Value dnValue : modification.getAttribute() )
                 {
                     Dn dn = new Dn( schemaManager, dnValue.getString() );
                     Dn newdDn = anonymizeDn( dn );
                     anonymizedValues[pos++] = new Value( newdDn.toString() );
                 }
                 
                 Modification anonymizedModification = new DefaultModification( modification.getOperation(), attributeType, anonymizedValues );
                 newLdifEntry.addModification( anonymizedModification );
             }
             else
             {
                 Anonymizer anonymizer = attributeAnonymizers.get( attributeType.getOid() );
 
                 if ( anonymizer == null )
                 {
                     newLdifEntry.addModification( modification );
                 }
                 else
                 {
                     Attribute anonymizedAttribute = anonymizer.anonymize( valueMap, valueSet, attribute );
                     
                     Modification anonymizedModification = new DefaultModification( modification.getOperation(), anonymizedAttribute );
                     newLdifEntry.addModification( anonymizedModification );
                 }
             }
         }
 
         return newLdifEntry;
     }
 
     
     /**
      * Anonymize a Add change
      * 
      * @param ldifEntry The entry to anonymize
      * @return The anonymized entry
      * @throws LdapException If the anonymization failed
      */
     private LdifEntry anonymizeChangeAdd( LdifEntry ldifEntry ) throws LdapException
     {
         Dn entryDn = ldifEntry.getDn();
         LdifEntry newLdifEntry = new LdifEntry( schemaManager );
         newLdifEntry.setChangeType( ChangeType.Add );
 
         // Process the DN first
         Dn anonymizedDn = anonymizeDn( entryDn );
         
         newLdifEntry.setDn( anonymizedDn );
         
         // Now, process the entry's attributes
         for ( Attribute attribute : ldifEntry )
         {
             AttributeType attributeType = attribute.getAttributeType();
             Attribute anonymizedAttribute = new DefaultAttribute( attributeType );
             
             // Deal with the special case of a DN syntax
             
             if ( attributeType.getSyntax().getSyntaxChecker() instanceof DnSyntaxChecker )
             {
                 for ( Value dnValue : attribute )
                 {
                     Dn dn = new Dn( schemaManager, dnValue.getString() );
                     Dn newdDn = anonymizeDn( dn );
                     anonymizedAttribute.add( newdDn.toString() );
                 }
                 
                 newLdifEntry.addAttribute( attribute );
             }
             else
             {
                 Anonymizer anonymizer = attributeAnonymizers.get( attribute.getAttributeType().getOid() );
 
                 if ( anonymizer == null )
                 {
                     newLdifEntry.addAttribute( attribute );
                 }
                 else
                 {
                     anonymizedAttribute = anonymizer.anonymize( valueMap, valueSet, attribute );
                     
                     if ( anonymizedAttribute != null )
                     {
                         newLdifEntry.addAttribute( anonymizedAttribute );
                     }
                 }
             }
         }
 
         return newLdifEntry;
     }
     
     
     /**
      * Anonymize a Delete change
      * 
      * @param ldifEntry The entry to anonymize
      * @return The anonymized entry
      * @throws LdapException If the anonymization failed
      */
     private LdifEntry anonymizeChangeDelete( LdifEntry ldifEntry ) throws LdapException
     {
         Dn entryDn = ldifEntry.getDn();
 
         // Process the DN, there is nothing more in the entry
         Dn anonymizedDn = anonymizeDn( entryDn );
         
         ldifEntry.setDn( anonymizedDn );
         
         return ldifEntry;
     }
     
     
     /**
      * Anonymize a Delete change
      * 
      * @param ldifEntry The entry to anonymize
      * @return The anonymized entry
      * @throws LdapException If the anonymization failed
      */
     private LdifEntry anonymizeChangeModDn( LdifEntry ldifEntry ) throws LdapException
     {
         Dn entryDn = ldifEntry.getDn();
 
         // Process the DN
         Dn anonymizedDn = anonymizeDn( entryDn );
         
         ldifEntry.setDn( anonymizedDn );
         
         // Anonymize the newRdn if any
         String newRdnStr = ldifEntry.getNewRdn();
         
         if ( newRdnStr != null )
         {
             Dn newRdn = new Dn( schemaManager, newRdnStr );
             Dn anonymizedRdn = anonymizeDn( newRdn );
             
             ldifEntry.setNewRdn( anonymizedRdn.toString() );
         }
         
         // Anonymize the neSuperior if any
         String newSuperiorStr = ldifEntry.getNewSuperior();
         
         if ( newSuperiorStr != null )
         {
             Dn newSuperior = new Dn( schemaManager, newSuperiorStr );
             
             Dn anonymizedSuperior = anonymizeDn( newSuperior );
             
             ldifEntry.setNewSuperior( anonymizedSuperior.toString() );
         }
 
         return ldifEntry;
     }
     
     
     /**
      * Anonymize the full entry
      * 
      * @param ldifEntry The entry to anonymize
      * @return The anonymized entry
      * @throws LdapException If the anonymization failed
      */
     private Entry anonymizeEntry( LdifEntry ldifEntry ) throws LdapException
     {
         Entry entry = ldifEntry.getEntry();
         Entry newEntry = new DefaultEntry( schemaManager );
 
         // Process the DN first
         Dn entryDn = entry.getDn();
         
         Dn anonymizedDn = anonymizeDn( entryDn );
         
         // Now, process the entry's attributes
         for ( Attribute attribute : entry )
         {
             AttributeType attributeType = attribute.getAttributeType();
             
             // Deal with the special case of DN
             if ( attributeType.getSyntax().getSyntaxChecker() instanceof DnSyntaxChecker )
             {
                 for ( Value dnValue : attribute )
                 {
                     Dn dn = new Dn( schemaManager, dnValue.getString() );
                     Dn newdDn = anonymizeDn( dn );
                     newEntry.add( attributeType, newdDn.toString() );
                 }
             }
             // Deal with the special case of a NameAndOptionalUID
             else if ( attributeType.getSyntax().getSyntaxChecker() instanceof NameAndOptionalUIDSyntaxChecker )
             {
                 for ( Value dnValue : attribute )
                 {
                     // Get rid of the # part (UID)
                     String valueStr = dnValue.getString();
                     int uidPos = valueStr.indexOf( '#' );
                     String uid = null;
                     
                     if ( uidPos != -1 )
                     {
                         uid = valueStr.substring( uidPos + 1 );
                         valueStr = valueStr.substring( 0, uidPos ); 
                     }
                     
                     Dn dn = new Dn( schemaManager, valueStr );
                     Dn newDn = anonymizeDn( dn );
                     String newDnStr = newDn.toString();
                     
                     if ( uid != null )
                     {
                         newDnStr = newDnStr + '#' + uid;
                     }
                     
                     newEntry.add( attributeType, newDnStr );
                 }
             }
             else
             {
                 Anonymizer anonymizer = attributeAnonymizers.get( attribute.getAttributeType().getOid() );
 
                 if ( anonymizer == null )
                 {
                     newEntry.add( attribute );
                 }
                 else
                 {
                     Attribute anonymizedAttribute = anonymizer.anonymize( valueMap, valueSet, attribute );
                     
                     if ( anonymizedAttribute != null )
                     {
                         newEntry.add( anonymizedAttribute );
                     }
                 }
             }
         }
 
         newEntry.setDn( anonymizedDn );
 
         return newEntry;
     }
 
 
     /**
      * Anonymize a LDIF 
      * 
      * @param ldif The ldif content to anonymize
      * @return an anonymized version of the given ldif
      * @throws LdapException If we got some LDAP related exception
      * @throws IOException If we had some issue during some IO operations
      */
     public String anonymize( String ldif ) throws LdapException, IOException
     {
         LdifReader ldifReader = new LdifReader( schemaManager );
 
         try
         {
             List<LdifEntry> entries = ldifReader.parseLdif( ldif );
             StringBuilder result = new StringBuilder();
 
             for ( LdifEntry ldifEntry : entries )
             {
                 if ( ldifEntry.isEntry() && !ldifEntry.isChangeAdd() )
                 {
                     // process a full entry. Add changes aren't preocessed ghere.
                     Entry newEntry = anonymizeEntry( ldifEntry );
                     
                     result.append( LdifUtils.convertToLdif( newEntry ) );
                     result.append( "\n" );
                 }
                 else if ( ldifEntry.isChangeDelete() )
                 {
                     // A Delete operation
                     LdifEntry newLdifEntry = anonymizeChangeDelete( ldifEntry );
 
                     if ( newLdifEntry != null )
                     {
                         result.append( newLdifEntry );
                         result.append( "\n" );
                     }
                 }
                 else if ( ldifEntry.isChangeAdd() )
                 {
                     // A Add operation
                     LdifEntry newLdifEntry = anonymizeChangeAdd( ldifEntry );
 
                     if ( newLdifEntry != null )
                     {
                         result.append( newLdifEntry );
                         result.append( "\n" );
                     }
                 }
                 else if ( ldifEntry.isChangeModify() )
                 {
                     // A Modify operation
                     LdifEntry newLdifEntry = anonymizeChangeModify( ldifEntry );
 
                     if ( newLdifEntry != null )
                     {
                         result.append( newLdifEntry );
                         result.append( "\n" );
                     }
                 }
                 else if ( ldifEntry.isChangeModDn() ||  ldifEntry.isChangeModRdn() )
                 {
                     // A MODDN operation
                     LdifEntry newLdifEntry = anonymizeChangeModDn( ldifEntry );
 
                     if ( newLdifEntry != null )
                     {
                         result.append( newLdifEntry );
                         result.append( "\n" );
                     }
                 }
             }
 
             return result.toString();
         }
         catch ( Exception e )
         {
             println( "Error :"  + e.getMessage() );
             return null;
         }
         finally
         {
             ldifReader.close();
         }
     }
 
 
     /**
      * @return the valueMap
      */
     public Map<Value, Value> getValueMap()
     {
         return valueMap;
     }
 
 
     /**
      * @param valueMap the valueMap to set
      */
     public void setValueMap( Map<Value, Value> valueMap )
     {
         this.valueMap = valueMap;
     }
 
 
     /**
      * @return the latest String Value Map
      */
     public Map<Integer, String> getLatestStringMap()
     {
         return latestStringMap;
     }
 
 
     /**
      * @param latestStringMap the latest String Value Map to set
      */
     public void setLatestStringMap( Map<Integer, String> latestStringMap )
     {
         this.latestStringMap = latestStringMap;
     }
 
 
     /**
      * @return the latest byte[] Value Map
      */
     public Map<Integer, byte[]> getLatestBytesMap()
     {
         return latestBytesMap;
     }
 
 
     /**
      * @param latestBytesMap the latest byte[] Value Map to set
      */
     public void setLatestBytesMap( Map<Integer, byte[]> latestBytesMap )
     {
         this.latestBytesMap = latestBytesMap;
     }
 
 
     /**
      * The entry point, when used as a standalone application.
      *
      * @param args Contains the arguments : the file to convert. The anonymized 
      * LDIF will be printed on stdout
      * @throws IOException If we had an issue opening the file to anonymise ot writing the result
      * @throws LdapException If we had some issue while processing the LDAP data
      */
     public static void main( String[] args ) throws IOException, LdapException
     {
         if ( ( args == null ) || ( args.length < 1 ) )
         {
             System.out.println( "No file to anonymize" );
             return;
         }
 
         LdifAnonymizer anonymizer = new LdifAnonymizer();
 
         String ldifString = null;
         
         try ( InputStream fis = Files.newInputStream( Paths.get( args[0] ) ) )
         {
             try ( BufferedReader br = new BufferedReader( new InputStreamReader( fis, Charset.defaultCharset() ) ) )
             {
                 StringBuilder sb = new StringBuilder();
                 String line = br.readLine();
     
                 while ( line != null )
                 {
                     sb.append( line );
                     sb.append( System.lineSeparator() );
                     line = br.readLine();
                 }
 
                 ldifString = sb.toString();
             }
         }
 
         String result = anonymizer.anonymize( ldifString );
 
         System.out.println( result );
     }
 }