/*
 * 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
 *
 *  http://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.server.core.entry;


import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import javax.naming.NamingException;
import javax.naming.directory.InvalidAttributeValueException;

import org.apache.directory.shared.asn1.primitives.OID;
import org.apache.directory.shared.ldap.entry.EntryAttribute;
import org.apache.directory.shared.ldap.entry.Value;
import org.apache.directory.shared.ldap.entry.client.ClientBinaryValue;
import org.apache.directory.shared.ldap.entry.client.ClientStringValue;
import org.apache.directory.shared.ldap.entry.client.DefaultClientAttribute;
import org.apache.directory.shared.ldap.schema.AttributeType;
import org.apache.directory.shared.ldap.util.StringTools;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * A server side entry attribute aware of schema.
 *
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 * @version $Rev$, $Date$
 */
public final class DefaultServerAttribute extends DefaultClientAttribute implements ServerAttribute
{
    public static final long serialVersionUID = 1L;
    
    /** logger for reporting errors that might not be handled properly upstream */
    private static final Logger LOG = LoggerFactory.getLogger( DefaultServerAttribute.class );
    
    /** The associated AttributeType */
    private AttributeType attributeType;
    
    
    //-----------------------------------------------------------------------
    // utility methods
    //-----------------------------------------------------------------------
    /**
     * Private helper method used to set an UpId from an attributeType
     * 
     * @param at The attributeType for which we want the upID
     * @return the ID of the given attributeType
     */
    private String getUpId( AttributeType at )
    {
        String atUpId = at.getName();
        
        if ( atUpId == null )
        {
            atUpId = at.getOid();
        }
        
        return atUpId;
    }
    
    
    //-------------------------------------------------------------------------
    // Constructors
    //-------------------------------------------------------------------------
    /**
     * 
     * Creates a new instance of DefaultServerAttribute, by copying
     * another attribute, which can be a ClientAttribute. If the other
     * attribute is a ServerAttribute, it will be copied.
     *
     * @param attributeType The attribute's type 
     * @param attribute The attribute to be copied
     */
    public DefaultServerAttribute( AttributeType attributeType, EntryAttribute attribute )
    {
        // Copy the common values. isHR is only available on a ServerAttribute 
        this.attributeType = attributeType;
        this.id = attribute.getId();
        this.upId = attribute.getUpId();

        if ( attribute instanceof ServerAttribute )
        {
            isHR = attribute.isHR();

            // Copy all the values
            for ( Value<?> value:attribute )
            {
                add( value.clone() );
            }
        }
        else
        {
            
            try
            {
                isHR = attributeType.getSyntax().isHumanReadable();
            }
            catch ( NamingException ne )
            {
                // Do nothing : the syntax should always exist ...
            }
            

            // Copy all the values
            for ( Value<?> clientValue:attribute )
            {
                Value<?> serverValue = null; 

                // We have to convert the value first
                if ( clientValue instanceof ClientStringValue )
                {
                    if ( isHR )
                    {
                        serverValue = new ServerStringValue( attributeType, (String)clientValue.get() );
                    }
                    else
                    {
                        // We have to convert the value to a binary value first
                        serverValue = new ServerBinaryValue( attributeType, 
                            StringTools.getBytesUtf8( (String)clientValue.get() ) );
                    }
                }
                else if ( clientValue instanceof ClientBinaryValue )
                {
                    if ( isHR )
                    {
                        // We have to convert the value to a String value first
                        serverValue = new ServerStringValue( attributeType, 
                            StringTools.utf8ToString( (byte[])clientValue.get() ) );
                    }
                    else
                    {
                        serverValue = new ServerBinaryValue( attributeType, (byte[])clientValue.get() );
                    }
                }

                add( serverValue );
            }
        }
    }
    
    
    // maybe have some additional convenience constructors which take
    // an initial value as a string or a byte[]
    /**
     * Create a new instance of a EntryAttribute, without ID nor value.
     * 
     * @param attributeType the attributeType for the empty attribute added into the entry
     */
    public DefaultServerAttribute( AttributeType attributeType )
    {
        if ( attributeType == null )
        {
            throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
        }
        
        setAttributeType( attributeType );
    }


    /**
     * Create a new instance of a EntryAttribute, without value.
     * 
     * @param upId the ID for the added attributeType
     * @param attributeType the added AttributeType
     */
    public DefaultServerAttribute( String upId, AttributeType attributeType )
    {
        if ( attributeType == null ) 
        {
            String message = "The AttributeType parameter should not be null";
            LOG.error( message );
            throw new IllegalArgumentException( message );
        }

        setAttributeType( attributeType );
        setUpId( upId );
    }


    /**
     * Doc me more!
     *
     * If the value does not correspond to the same attributeType, then it's
     * wrapped value is copied into a new Value which uses the specified
     * attributeType.
     *
     * @param attributeType the attribute type according to the schema
     * @param vals an initial set of values for this attribute
     */
    public DefaultServerAttribute( AttributeType attributeType, Value<?>... vals )
    {
        this( null, attributeType, vals );
    }


    /**
     * Doc me more!
     *
     * If the value does not correspond to the same attributeType, then it's
     * wrapped value is copied into a new Value which uses the specified
     * attributeType.
     * 
     * Otherwise, the value is stored, but as a reference. It's not a copy.
     *
     * @param upId the ID of the added attribute
     * @param attributeType the attribute type according to the schema
     * @param vals an initial set of values for this attribute
     */
    public DefaultServerAttribute( String upId, AttributeType attributeType, Value<?>... vals )
    {
        if ( attributeType == null )
        {
            throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
        }
        
        setAttributeType( attributeType );
        setUpId( upId, attributeType );
        add( vals );
    }


    /**
     * Create a new instance of a EntryAttribute, without ID but with some values.
     * 
     * @param attributeType The attributeType added on creation
     * @param vals The added value for this attribute
     */
    public DefaultServerAttribute( AttributeType attributeType, String... vals )
    {
        this( null, attributeType, vals );
    }


    /**
     * Create a new instance of a EntryAttribute.
     * 
     * @param upId the ID for the added attribute
     * @param attributeType The attributeType added on creation
     * @param vals the added values for this attribute
     */
    public DefaultServerAttribute( String upId, AttributeType attributeType, String... vals )
    {
        if ( attributeType == null )
        {
            throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
        }

        setAttributeType( attributeType );
        add( vals );
        setUpId( upId, attributeType );
    }


    /**
     * Create a new instance of a EntryAttribute, with some byte[] values.
     * 
     * @param attributeType The attributeType added on creation
     * @param vals The value for the added attribute
     */
    public DefaultServerAttribute( AttributeType attributeType, byte[]... vals )
    {
        this( null, attributeType, vals );
    }


    /**
     * Create a new instance of a EntryAttribute, with some byte[] values.
     * 
     * @param upId the ID for the added attribute
     * @param attributeType the AttributeType to be added
     * @param vals the values for the added attribute
     */
    public DefaultServerAttribute( String upId, AttributeType attributeType, byte[]... vals )
    {
        if ( attributeType == null )
        {
            throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
        }

        setAttributeType( attributeType );
        add( vals );
        setUpId( upId, attributeType );
    }
    
    
    //-------------------------------------------------------------------------
    // API
    //-------------------------------------------------------------------------
    /**
     * <p>
     * Adds some values to this attribute. If the new values are already present in
     * the attribute values, the method has no effect.
     * </p>
     * <p>
     * The new values are added at the end of list of values.
     * </p>
     * <p>
     * This method returns the number of values that were added.
     * </p>
     * <p>
     * If the value's type is different from the attribute's type,
     * the value is not added.
     * </p>
     * It's the responsibility of the caller to check if the stored
     * values are consistent with the attribute's type.
     * <p>
     *
     * @param vals some new values to be added which may be null
     * @return the number of added values, or 0 if none has been added
     */
    public int add( byte[]... vals )
    {
        if ( !isHR )
        {
            int nbAdded = 0;
            
            for ( byte[] val:vals )
            {
                Value<?> value = new ServerBinaryValue( attributeType, val );
                
                try
                {
                    value.normalize();
                }
                catch( NamingException ne )
                {
                    // The value can't be normalized : we don't add it.
                    LOG.error( "The value '" + val + "' can't be normalized, it hasn't been added" );
                    return 0;
                }
                
                if ( add( value ) != 0 )
                {
                    nbAdded++;
                }
                else
                {
                    LOG.error( "The value '" + val + "' is incorrect, it hasn't been added" );
                }
            }
            
            return nbAdded;
        }
        else
        {
            // We can't add Binary values into a String serverAttribute
            return 0;
        }
    }    


    /**
     * <p>
     * Adds some values to this attribute. If the new values are already present in
     * the attribute values, the method has no effect.
     * </p>
     * <p>
     * The new values are added at the end of list of values.
     * </p>
     * <p>
     * This method returns the number of values that were added.
     * </p>
     * If the value's type is different from the attribute's type,
     * the value is not added.
     *
     * @param vals some new values to be added which may be null
     * @return the number of added values, or 0 if none has been added
     */
    public int add( String... vals )
    {
        if ( isHR )
        {
            int nbAdded = 0;
            
            for ( String val:vals )
            {
                Value<String> newValue = new ServerStringValue( attributeType, val );
                
                if ( !contains( newValue ) )
                {
                    if ( add( newValue ) != 0 )
                    {
                        nbAdded++;
                    }
                    else
                    {
                        LOG.error( "The value '" + val + "' is incorrect, it hasn't been added" );
                    }
                }
            }
            
            return nbAdded;
        }
        else
        {
            // We can't add String values into a Binary serverAttribute
            return 0;
        }
    }    


    /**
     * @see EntryAttribute#add(org.apache.directory.shared.ldap.entry.Value...)
     * 
     * @return the number of added values into this attribute
     */
    public int add( Value<?>... vals )
    {
        int nbAdded = 0;
        
        for ( Value<?> val:vals )
        {
            try
            {
                if ( attributeType.getSyntax().isHumanReadable() )
                {
                    if ( val == null )
                    {
                        Value<String> nullSV = new ServerStringValue( attributeType, (String)null );
                        
                        if ( !values.contains( nullSV ) )
                        {
                            values.add( nullSV );
                            nbAdded++;
                        }
                    }
                    else if ( val instanceof ServerStringValue )
                    {
                        if ( !values.contains( val ) )
                        {
                            if ( values.add( val ) )
                            {
                                nbAdded++;
                            }
                        }
                    }
                    else if ( val instanceof ClientStringValue )
                    {
                        // If we get a Client value, convert it to a Server value first 
                        Value<String> serverStringValue = new ServerStringValue( attributeType, (String)val.get() ); 
                        
                        if ( !values.contains( serverStringValue ) )
                        {
                            if ( values.add( serverStringValue ) )
                            {
                                nbAdded++;
                            }
                        }
                    }
                    else
                    {
                        String message = "The value must be a String, as its AttributeType is H/R";
                        LOG.error( message );
                    }
                }
                else
                {
                    if ( val == null )
                    {
                        Value<byte[]> nullSV = new ServerBinaryValue( attributeType, (byte[])null );
                        
                        if ( !values.contains( nullSV ) )
                        {
                            values.add( nullSV );
                            nbAdded++;
                        }
                    }
                    else if ( ( val instanceof ClientBinaryValue ) )
                    {
                        Value<byte[]> serverBinaryValue = new ServerBinaryValue( attributeType, (byte[])val.get() ); 
                        
                        if ( !values.contains( serverBinaryValue ) )
                        {
                            if ( values.add( serverBinaryValue ) )
                            {
                                nbAdded++;
                            }
                        }
                    }
                    else if ( val instanceof ServerBinaryValue )
                    {
                        if ( !values.contains( val ) )
                        {
                            if ( values.add( val ) )
                            {
                                nbAdded++;
                            }
                        }
                    }
                    else
                    {
                        String message = "The value must be a byte[], as its AttributeType is not H/R";
                        LOG.error( message );
                    }
                }
            }
            catch ( NamingException ne )
            {
                String message = "Error while adding value '" + val.toString() +"' : " + ne.getMessage();
                LOG.error( message );
            }
        }
        
        return nbAdded;
    }


    /**
     * Remove all the values from this attribute type, including a 
     * null value. 
     */
    public void clear()
    {
        values.clear();
    }


    /**
     * <p>
     * Indicates whether all the specified values are attribute's values. If
     * at least one value is not an attribute's value, this method will return 
     * <code>false</code>
     * </p>
     * <p>
     * If the Attribute is HR, this method will returns <code>false</code>
     * </p>
     *
     * @param vals the values
     * @return true if this attribute contains all the values, otherwise false
     */
    public boolean contains( byte[]... vals )
    {
        if ( !isHR )
        {
            // Iterate through all the values, and quit if we 
            // don't find one in the values
            for ( byte[] val:vals )
            {
                ServerBinaryValue value = new ServerBinaryValue( attributeType, val );
                
                try
                {
                    value.normalize();
                }
                catch ( NamingException ne )
                {
                    return false;
                }
                
                if ( !values.contains( value ) )
                {
                    return false;
                }
            }
            
            return true;
        }
        else
        {
            return false;
        }
    }
    
    
    /**
     * <p>
     * Indicates whether all the specified values are attribute's values. If
     * at least one value is not an attribute's value, this method will return 
     * <code>false</code>
     * </p>
     * <p>
     * If the Attribute is not HR, this method will returns <code>false</code>
     * </p>
     *
     * @param vals the values
     * @return true if this attribute contains all the values, otherwise false
     */
    public boolean contains( String... vals )
    {
        if ( isHR )
        {
            // Iterate through all the values, and quit if we 
            // don't find one in the values
            for ( String val:vals )
            {
                ServerStringValue value = new ServerStringValue( attributeType, val );
                
                if ( !values.contains( value ) )
                {
                    return false;
                }
            }
            
            return true;
        }
        else
        {
            return false;
        }
    }
    
    
    /**
     * <p>
     * Indicates whether the specified values are some of the attribute's values.
     * </p>
     * <p>
     * If the Attribute is HR, te metho will only accept String Values. Otherwise, 
     * it will only accept Binary values.
     * </p>
     *
     * @param vals the values
     * @return true if this attribute contains all the values, otherwise false
     */
    public boolean contains( Value<?>... vals )
    {
        // Iterate through all the values, and quit if we 
        // don't find one in the values. We have to separate the check
        // depending on the isHR flag value.
        if ( isHR )
        {
            for ( Value<?> val:vals )
            {
                if ( val instanceof ServerStringValue )
                {
                    if ( !values.contains( val ) )
                    {
                        return false;
                    }
                }
                else if ( val instanceof ClientStringValue )
                {
                    ServerStringValue serverValue = new ServerStringValue( attributeType, (String)val.get() );
                    
                    if ( !values.contains( serverValue ) )
                    {
                        return false;
                    }
                }
                else
                {
                    // Not a String value
                    return false;
                }
            }
        }
        else
        {
            for ( Value<?> val:vals )
            {
                if ( val instanceof ClientBinaryValue )
                {
                    if ( !values.contains( val ) )
                    {
                        return false;
                    }
                }
                else
                {
                    // Not a Binary value
                    return false;
                }
            }
        }
        
        return true;
    }


    /**
     * Get the attribute type associated with this ServerAttribute.
     *
     * @return the attributeType associated with this entry attribute
     */
    public AttributeType getAttributeType()
    {
        return attributeType;
    }
    
    
    /**
     * <p>
     * Check if the current attribute type is of the expected attributeType
     * </p>
     * <p>
     * This method won't tell if the current attribute is a descendant of 
     * the attributeType. For instance, the "CN" serverAttribute will return
     * false if we ask if it's an instance of "Name". 
     * </p> 
     *
     * @param attributeId The AttributeType ID to check
     * @return True if the current attribute is of the expected attributeType
     * @throws InvalidAttributeValueException If there is no AttributeType
     */
    public boolean instanceOf( String attributeId ) throws InvalidAttributeValueException
    {
        String trimmedId = StringTools.trim( attributeId );
        
        if ( StringTools.isEmpty( trimmedId ) )
        {
            return false;
        }
        
        String normId = StringTools.lowerCaseAscii( trimmedId );
        
        for ( String name:attributeType.getNamesRef() )
        {
            if ( normId.equalsIgnoreCase( name ) )
            {
                return true;
            }
        }
        
        return normId.equalsIgnoreCase( attributeType.getOid() );
    }
    

    /**
     * <p>
     * Checks to see if this attribute is valid along with the values it contains.
     * </p>
     * <p>
     * An attribute is valid if :
     * <li>All of its values are valid with respect to the attributeType's syntax checker</li>
     * <li>If the attributeType is SINGLE-VALUE, then no more than a value should be present</li>
     *</p>
     * @return true if the attribute and it's values are valid, false otherwise
     * @throws NamingException if there is a failure to check syntaxes of values
     */
    public boolean isValid() throws NamingException
    {
        // First check if the attribute has more than one value
        // if the attribute is supposed to be SINGLE_VALUE
        if ( attributeType.isSingleValue() && ( values.size() > 1 ) )
        {
            return false;
        }

        for ( Value<?> value : values )
        {
            if ( ! value.isValid() )
            {
                return false;
            }
        }

        return true;
    }


    /**
     * @see EntryAttribute#remove(byte[]...)
     * 
     * @return <code>true</code> if all the values shave been removed from this attribute
     */
    public boolean remove( byte[]... vals )
    {
        if ( isHR ) 
        {
            return false;
        }
        
        boolean removed = true;
        
        for ( byte[] val:vals )
        {
            ServerBinaryValue value = new ServerBinaryValue( attributeType, val );
            removed &= values.remove( value );
        }
        
        return removed;
    }


    /**
     * @see EntryAttribute#remove(String...)
     * 
     * @return <code>true</code> if all the values shave been removed from this attribute
     */
    public boolean remove( String... vals )
    {
        if ( !isHR )
        {
            return false;
        }
        
        boolean removed = true;
        
        for ( String val:vals )
        {
            ServerStringValue value = new ServerStringValue( attributeType, val );
            removed &= values.remove( value );
        }
        
        return removed;
    }


    /**
     * @see EntryAttribute#remove(org.apache.directory.shared.ldap.entry.Value...)
     * 
     * @return <code>true</code> if all the values shave been removed from this attribute
     */
    public boolean remove( Value<?>... vals )
    {
        boolean removed = true;
        
        // Loop through all the values to remove. If one of
        // them is not present, the method will return false.
        // As the attribute may be HR or not, we have two separated treatments
        if ( isHR )
        {
            for ( Value<?> val:vals )
            {
                if ( val instanceof ClientStringValue )
                {
                    ServerStringValue ssv = new ServerStringValue( attributeType, (String)val.get() );
                    removed &= values.remove( ssv );
                }
                else if ( val instanceof ServerStringValue )
                {
                    removed &= values.remove( val );
                }
                else
                {
                    removed = false;
                }
            }
        }
        else
        {
            for ( Value<?> val:vals )
            {
                if ( val instanceof ClientBinaryValue )
                {
                    ServerBinaryValue sbv = new ServerBinaryValue( attributeType, (byte[])val.get() );
                    removed &= values.remove( sbv );
                }
                else if ( val instanceof ServerBinaryValue )
                {
                    removed &= values.remove( val );
                }
                else
                {
                    removed = false;
                }
            }
        }
        
        return removed;
    }


    
    /**
     * <p>
     * Set the attribute type associated with this ServerAttribute.
     * </p>
     * <p>
     * The current attributeType will be replaced. It is the responsibility of
     * the caller to insure that the existing values are compatible with the new
     * AttributeType
     * </p>
     *
     * @param attributeType the attributeType associated with this entry attribute
     */
    public void setAttributeType( AttributeType attributeType )
    {
        if ( attributeType == null )
        {
            throw new IllegalArgumentException( "The AttributeType parameter should not be null" );
        }

        this.attributeType = attributeType;
        setUpId( null, attributeType );
        
        try
        {
            if ( attributeType.getSyntax().isHumanReadable() )
            {
                isHR = true;
            }
            else
            {
                isHR = false;
            }
        }
        catch ( NamingException ne )
        {
            // If we have an exception while trying to get the Syntax for this attribute
            // just set it as Binary
            isHR = false;
        }
    }
    
    
    /**
     * <p>
     * Overload the ClientAttribte isHR method : we can't change this flag
     * for a ServerAttribute, as the HR is already set using the AttributeType.
     * Set the attribute to Human Readable or to Binary. 
     * </p>
     * 
     * @param isHR <code>true</code> for a Human Readable attribute, 
     * <code>false</code> for a Binary attribute.
     */
    public void setHR( boolean isHR )
    {
        // Do nothing...
    }

    
    /**
     * <p>
     * Overload the {@link DefaultClientAttribute#setId(String)} method.
     * </p>
     * <p>
     * As the attributeType has already been set, we have to be sure that the 
     * argument is compatible with the attributeType's name. 
     * </p>
     * <p>
     * If the given ID is not compatible with the attributeType's possible
     * names, the previously loaded ID will be kept.
     * </p>
     *
     * @param id The attribute ID
     */
    public void setId( String id )
    {
        if ( !StringTools.isEmpty( StringTools.trim( id  ) ) )
        {
            if ( attributeType.getName() == null )
            {
                // If the name is null, then we may have to store an OID
                if ( OID.isOID( id )  && attributeType.getOid().equals( id ) )
                {
                    // Everything is fine, store the upId.
                    // This should not happen...
                    super.setId( id );
                }
            }
            else
            {
                // We have at least one name. Check that the normalized upId
                // is one of those names. Otherwise, the upId may be an OID too.
                // In this case, it must be equals to the attributeType OID.
                String normId = StringTools.lowerCaseAscii( StringTools.trim( id ) );
                
                for ( String atName:attributeType.getNamesRef() )
                {
                    if ( atName.equalsIgnoreCase( normId ) )
                    {
                        // Found ! We can store the upId and get out
                        super.setId( normId );
                        return;
                    }
                }
                
                // Last case, the UpId is an OID
                if ( OID.isOID( normId ) && attributeType.getOid().equals( normId ) )
                {
                    // We have an OID : stores it
                    super.setUpId( normId );
                }
                else
                {
                    // The id is incorrect : this is not allowed 
                    throw new IllegalArgumentException( "The ID '" + id + "'is incompatible with the AttributeType's id '" + 
                        attributeType.getName() + "'" );
                }
            }
        }
        else
        {
            throw new IllegalArgumentException( "An ID cannnot be null, empty, or resolved to an emtpy" +
            " value when trimmed" );
        }
    }
    
    
    /**
     * <p>
     * Overload the {@link DefaultClientAttribute#setUpId(String)} method.
     * </p>
     * <p>
     * As the attributeType has already been set, we have to be sure that the 
     * argument is compatible with the attributeType's name. 
     * </p>
     * <p>
     * If the given ID is not compatible with the attributeType's possible
     * names, the previously loaded ID will be kept.
     * </p>
     *
     * @param upId The attribute ID
     */
    public void setUpId( String upId )
    {
        if ( !StringTools.isEmpty( StringTools.trim( upId  ) ) )
        {
            if ( attributeType.getName() == null )
            {
                // If the name is null, then we may have to store an OID
                if ( OID.isOID( upId )  && attributeType.getOid().equals( upId ) )
                {
                    // Everything is fine, store the upId.
                    // This should not happen...
                    super.setUpId( upId );
                    
                }
            }
            else
            {
                // We have at least one name. Check that the normalized upId
                // is one of those names. Otherwise, the upId may be an OID too.
                // In this case, it must be equals to the attributeType OID.
                String normUpId = StringTools.lowerCaseAscii( StringTools.trim( upId ) );
                
                for ( String atId:attributeType.getNamesRef() )
                {
                    if ( atId.equalsIgnoreCase( normUpId ) )
                    {
                        // Found ! We can store the upId and get out
                        super.setUpId( upId );
                        return;
                    }
                }
                
                // Last case, the UpId is an OID
                if ( OID.isOID( normUpId ) && attributeType.getOid().equals( normUpId ) )
                {
                    // We have an OID : stores it
                    super.setUpId( upId );
                }
            }
        }
    }
    
    
    /**
     * <p>
     * Set the user provided ID. If we have none, the upId is assigned
     * the attributetype's name. If it does not have any name, we will
     * use the OID.
     * </p>
     * <p>
     * If we have an upId and an AttributeType, they must be compatible. :
     *  - if the upId is an OID, it must be the AttributeType's OID
     *  - otherwise, its normalized form must be equals to ones of
     *  the attributeType's names.
     * </p>
     * <p>
     * In any case, the ATtributeType will be changed. The caller is responsible for
     * the present values to be compatoble with the new AttributeType.
     * </p>
     *
     * @param upId The attribute ID
     * @param attributeType The associated attributeType
     */
    public void setUpId( String upId, AttributeType attributeType )
    {
        if ( StringTools.isEmpty( StringTools.trim( upId  ) ) )
        {
            super.setUpId( getUpId( attributeType ) );
            this.attributeType = attributeType;
        }
        else
        {
            String name = attributeType.getName();
            
            if ( name == null )
            {
                // If the name is null, then we may have to store an OID
                if ( OID.isOID( upId )  && attributeType.getOid().equals( upId ) )
                {
                    //  Everything is fine, store the upId. 
                    super.setUpId( upId );
                    this.attributeType = attributeType;
                }
                else
                {
                    // We have a difference or the upId is not a valid OID :
                    // we will use the attributeTypeOID in this case.
                    LOG.warn( "The upID ({}) is not an OID or is different from the AttributeType OID({})",
                        upId, attributeType.getOid() );
                    super.setUpId( attributeType.getOid() );
                    this.attributeType = attributeType;
                }
            }
            else
            {
                // We have at least one name. Check that the normalized upId
                // is one of those names. Otherwise, the upId may be an OID too.
                // In this case, it must be equals to the attributeType OID.
                String normUpId = StringTools.lowerCaseAscii( StringTools.trim( upId ) );
                
                for ( String atId:attributeType.getNamesRef() )
                {
                    if ( atId.equalsIgnoreCase( normUpId ) )
                    {
                        // Found ! We can store the upId and get out
                        super.setUpId( upId );
                        this.attributeType = attributeType;
                        return;
                    }
                }
    
                // UpId was not found in names. It should be an OID, or if not, we 
                // will use the AttributeType name.
                if ( OID.isOID( normUpId ) && attributeType.getOid().equals( normUpId ) )
                {
                    // We have an OID : stores it
                    super.setUpId( upId );
                    this.attributeType = attributeType;
                }
                else
                {
                    String message = "The upID (" + upId + ") is not an OID or is different from the AttributeType OID (" + 
                                        attributeType.getOid() + ")";
                    // Not a valid OID : use the AttributeTypes OID name instead
                    LOG.error( message );
                    throw new IllegalArgumentException( message );
                }
            }
        }
    }


    /**
     * Convert the ServerAttribute to a ClientAttribute
     *
     * @return An instance of ClientAttribute
     */
    public EntryAttribute toClientAttribute()
    {
        // Create the new EntryAttribute
        EntryAttribute clientAttribute = new DefaultClientAttribute( upId );
        
        // Copy the values
        for ( Value<?> value:this )
        {
            Value<?> clientValue = null;
            
            if ( value instanceof ServerStringValue )
            {
                clientValue = new ClientStringValue( (String)value.get() );
            }
            else
            {
                clientValue = new ClientBinaryValue( (byte[])value.get() );
            }
            
            clientAttribute.add( clientValue );
        }
        
        return clientAttribute;
    }


    //-------------------------------------------------------------------------
    // Serialization methods
    //-------------------------------------------------------------------------
    
    /**
     * @see java.io.Externalizable#writeExternal(ObjectOutput)
     * 
     * We can't use this method for a ServerAttribute, as we have to feed the value
     * with an AttributeType object
     */
    public void writeExternal( ObjectOutput out ) throws IOException
    {
        throw new IllegalStateException( "Cannot use standard serialization for a ServerAttribute" );
    }
    
    
    /**
     * @see Externalizable#writeExternal(ObjectOutput)
     * <p>
     * 
     * This is the place where we serialize attributes, and all theirs
     * elements. 
     * 
     * The inner structure is the same as the client attribute, but we can't call
     * it as we won't be able to serialize the serverValues
     * 
     */
    public void serialize( ObjectOutput out ) throws IOException
    {
        // Write the UPId (the id will be deduced from the upID)
        out.writeUTF( upId );
        
        // Write the HR flag, if not null
        if ( isHR != null )
        {
            out.writeBoolean( true );
            out.writeBoolean( isHR );
        }
        else
        {
            out.writeBoolean( false );
        }
        
        // Write the number of values
        out.writeInt( size() );
        
        if ( size() > 0 ) 
        {
            // Write each value
            for ( Value<?> value:values )
            {
                // Write the value, using the correct method
                if ( value instanceof ServerStringValue )
                {
                    ((ServerStringValue)value).serialize( out );
                }
                else
                {
                    ((ServerBinaryValue)value).serialize( out );
                }
            }
        }
    }

    
    /**
     * @see java.io.Externalizable#readExternal(ObjectInput)
     * 
     * We can't use this method for a ServerAttribute, as we have to feed the value
     * with an AttributeType object
     */
    public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException
    {
        throw new IllegalStateException( "Cannot use standard serialization for a ServerAttribute" );
    }
    
    
    /**
     * @see Externalizable#readExternal(ObjectInput)
     */
    public void deserialize( ObjectInput in ) throws IOException, ClassNotFoundException
    {
        // Read the ID and the UPId
        upId = in.readUTF();
        
        // Compute the id
        setUpId( upId );
        
        // Read the HR flag, if not null
        if ( in.readBoolean() )
        {
            isHR = in.readBoolean();
        }

        // Read the number of values
        int nbValues = in.readInt();

        if ( nbValues > 0 )
        {
            for ( int i = 0; i < nbValues; i++ )
            {
                Value<?> value = null;
                
                if ( isHR )
                {
                    value  = new ServerStringValue( attributeType );
                    ((ServerStringValue)value).deserialize( in );
                }
                else
                {
                    value  = new ServerBinaryValue( attributeType );
                    ((ServerBinaryValue)value).deserialize( in );
                }
                
                try
                {
                    value.normalize();
                }
                catch ( NamingException ne )
                {
                    // Do nothing...
                }
                    
                values.add( value );
            }
        }
    }
    
    
    //-------------------------------------------------------------------------
    // Overloaded Object class methods
    //-------------------------------------------------------------------------
    /**
     * Clone an attribute. All the element are duplicated, so a modification on
     * the original object won't affect the cloned object, as a modification
     * on the cloned object has no impact on the original object
     * 
     * @return a clone of the current attribute
     */
    public ServerAttribute clone()
    {
        // clone the structure by cloner the inherited class
        ServerAttribute clone = (ServerAttribute)super.clone();
        
        // We are done !
        return clone;
    }


    /**
     * @see Object#equals(Object)
     * 
     * @return <code>true</code> if the two objects are equal
     */
    public boolean equals( Object obj )
    {
        if ( obj == this )
        {
            return true;
        }
        
        if ( ! (obj instanceof ServerAttribute ) )
        {
            return false;
        }
        
        ServerAttribute other = (ServerAttribute)obj;
        
        if ( !attributeType.equals( other.getAttributeType() ) )
        {
            return false;
        }
        
        if ( values.size() != other.size() )
        {
            return false;
        }
        
        for ( Value<?> val:values )
        {
            if ( ! other.contains( val ) )
            {
                return false;
            }
        }
        
        return true;
    }
    
    
    /**
     * The hashCode is based on the id, the isHR flag and 
     * on the internal values.
     *  
     * @see Object#hashCode()
     * 
     * @return the instance's hash code 
     */
    public int hashCode()
    {
        int h = super.hashCode();
        
        if ( attributeType != null )
        {
            h = h*17 + attributeType.hashCode();
        }
        
        return h;
    }
    
    
    /**
     * @see Object#toString()
     * 
     * @return A String representation of this instance
     */
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        
        if ( ( values != null ) && ( values.size() != 0 ) )
        {
            for ( Value<?> value:values )
            {
                sb.append( "    " ).append( upId ).append( ": " );
                
                if ( value.isNull() )
                {
                    sb.append( "''" );
                }
                else
                {
                    sb.append( value );
                }
                
                sb.append( '\n' );
            }
        }
        else
        {
            sb.append( "    " ).append( upId ).append( ": (null)\n" );
        }
        
        return sb.toString();
    }
}